`Chevie.Uch`

— ModuleLet $𝐆$ 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
```

`Chevie.Uch.UnipotentCharacters`

— Method`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 nems of the unipotent characters. Then the following column numbers display:

```
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 classical 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]).

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)
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 +,+
.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`

— Method`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
```

`Chevie.Chars.charnames`

— Methodcharnames(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.

`Chevie.ComplexR.degrees`

— Function`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
```

`Chevie.Families.fourier`

— Method`fourier(uc::UnipotentCharacters)`

the Lusztig Fourier matrix for `uc`

.

`Chevie.Uch.CycPoldegrees`

— Method`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 `CycPol`

s. 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
```

`Chevie.Uch.FixRelativeType`

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

`Chevie.Uch.almost_character`

— Function`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₂>
```

`Chevie.Uch.cuspidal`

— Function`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
```

`Chevie.Uch.cuspidal_data`

— Method`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 = ζ₃)
```

`Chevie.Uch.deligne_lusztigCharTable`

— Method`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
```

`Chevie.Uch.deligne_lusztig_character`

— Method`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₂[ζ₃²]>
```

`Chevie.Uch.deligne_lusztig_lefschetz`

— Function`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.

`Chevie.Uch.lusztig_induce`

— Method`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₂]:<φ₁‚₀>-<φ₁‚₆>-<φ′₁‚₃>+<φ″₁‚₃>
```

`Chevie.Uch.lusztig_restrict`

— Method`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
```

`Chevie.Uch.on_unipotents`

— Method`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)
```

`Chevie.Uch.unipotent_character`

— Method`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
```

`CycPols.CycPol`

— Method`CycPol(x::Mvp)`

converts univariate `Mvp`

`x`

to a `CycPol`

`Chevie.Tools2.eigmat`

— Method`eigmat(m::Matrix)`

eigenvalues of finite order of `m`

, as a `Vector{Root1}`

`Combinat.blocks`

— Method`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]
```

`Primes.factor`

— Method`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
```

`Chevie.Lusztig.FindSeriesInParent`

— Method`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)

`Chevie.Lusztig.lusztig_induction_table`

— Method`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 . .
```

`Chevie.GAPENV`

— ModuleThe module GAPENV creates a GAP3-like environment by extending locally the base functions `*, +, -, ^, isless, copy, //, inv, length, union`

to their GAP3 semantics and defining quite a few other GAP3 functions, then loads the Chevie database in that environment.

`CycPols.CycPol`

— Method`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-ζ₇³)
```

`Chevie.GAPENV.BDSymbols`

— Method`BDSymbols(n,d)`

returns 2-symbols of defect `d`

and rank `n`

(for Weyl types B,C,D,2D). If `d==0`

the symbols with equal entries are returned twice, represented as the first entry, followed by the repetition factor 2 and an ordinal number 0 or 1, so that `BDSymbols(n, 0)`

is a set of parameters for the characters of the Weyl group of type `Dₙ`

.

```
julia> GAPENV.BDSymbols(2,1)
5-element Vector{Vector{Vector{Int64}}}:
[[1, 2], [0]]
[[0, 2], [1]]
[[0, 1, 2], [1, 2]]
[[2], []]
[[0, 1], [2]]
julia> GAPENV.BDSymbols(4,0)
13-element Vector{Vector{T} where T}:
Any[[1, 2], 2, 0]
Any[[1, 2], 2, 1]
[[0, 1, 3], [1, 2, 3]]
[[0, 1, 2, 3], [1, 2, 3, 4]]
[[1, 2], [0, 3]]
[[0, 2], [1, 3]]
[[0, 1, 2], [1, 2, 4]]
Any[[2], 2, 0]
Any[[2], 2, 1]
[[0, 1], [2, 3]]
[[1], [3]]
[[0, 1], [1, 4]]
[[0], [4]]
```

`Chevie.GAPENV.EvalPolRoot`

— MethodEvalPolRoot(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

`Chevie.GAPENV.elementary_symmetric_function`

— Methodthe elementary symmetric function of degree t in the variables v

`Chevie.GAPENV.homogeneous_symmetric_function`

— Methodthe homogeneous symmetric function of degree t in the variables v

`Chevie.GAPENV.hooksβ`

— Methodhooksβ(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.

`Chevie.GAPENV.stripsβ`

— Methodstripsβ(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.

`Chevie.Algebras`

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

`Chevie.Algebras.GroupAlgebra`

— Type`GroupAlgebra(G,T=Int)`

group algebra of `G`

with coefficients `T`

`Chevie.Algebras.SolomonAlgebra`

— Type'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.solomon*conjugacy': 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 `W*I` 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₄₃₂₁₂₃₄
```

`Chevie.Algebras.ppart`

— Method`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₁`

.

`Chevie.Algebras.pprimesections`

— Method`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]
```

`PermGroups.Groups.isabelian`

— Method`isabelian(A::FiniteDimAlgebra)`

whether `A`

is commutative

`Chevie.Fact`

— ModuleFactoring polynomials over the rationals

`Chevie.Fact.LogInt`

— Method`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
```

`Primes.factor`

— Method`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.Semisimple`

— Module**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 giving similarly the dual roots `Φ^⊂ Y=Y(𝐓)`

.

This is obtained by a slight generalization of our setup for a Coxeter group `W`

. This time we assume 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 lines are the simple roots expressed in this basis of `X`

. Similarly `Φ^`

is described by a matrix `simplecoroots(W)`

whose lines 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 `simpleroots(W)*transpose(simplecoroots(W))=cartan(W)`

.

We get that by a 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 instance, the root datum of the linear group of rank 3 can be specified 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 symmetric group on 3 letters acts 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 2.

The default form `W=coxgroup(:A,2)`

defines the adjoint algebraic group (the group with a trivial center). In that 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.

There is an extreme form of root data which requires another function to specify: when `W`

is the trivial `coxgroup()`

and there are thus no roots (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.

Finally, the function `rootdatum`

also understands some familiar names for the algebraic groups and gives the results that could be obtained by giving the appropriate matrices `simpleroots(W)`

and `simplecoroots(W)`

:

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

The known types of root data 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**

It is possible to compute with semi-simple elements; there are 2 type of them. The first type are 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 `Rational`

s `r`

such that `0≤r<1`

. The function `ss`

constructs such a semisimple element from a vector of `Rational`

s. More generally `𝐓`

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 given by the function `SemisimplElement`

; in this setting the representation given by `ss`

is naturally interpreted as a `Vector{Root1}`

.

```
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 extended reflection group; 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)$.

`Chevie.Semisimple.SubTorus`

— Type`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
```

`Chevie.Semisimple.affine`

— MethodA *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
```

`Chevie.Semisimple.algebraic_center`

— Method`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>]))
```

`Chevie.Semisimple.coweights`

— Method`coweights(W)`

simple coweights in the basis of Y(T)

`Chevie.Semisimple.fundamental_group`

— Method`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, that is 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)
A₃
julia> fundamental_group(W)
Group((1,12,3,2))
julia> W=rootdatum(:sl,4)
sl₄
julia> fundamental_group(W)
Group(Perm{Int16}[])
```

`Chevie.Semisimple.intermediate_group`

— Method`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))
```

`Chevie.Semisimple.quasi_isolated_reps`

— Function`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>
```

`Chevie.Semisimple.semisimple_centralizer_representatives`

— Function`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]
```

`Chevie.Semisimple.structure_rational_points_connected_centre`

— Method`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]
```

julia-repl

`Chevie.Semisimple.torsion_subgroup`

— Method`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>
<ζ₃,ζ₃²,ζ₃>
<ζ₃²,ζ₃,ζ₃²>
```

`Chevie.Semisimple.weightinfo`

— Method`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 the `C=transpose(cartan(W))`

. The property 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 7 entries:
:moduli => [3, 2]
:minusculeWeights => [[1, 3], [1], [2, 3], [2], [3]]
:decompositions => [[2, 1], [2, 0], [1, 1], [1, 0], [0, 1]]
: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)]
```

`Chevie.Semisimple.weights`

— Method`weights(W)`

simple weights in the basis of X(T)

`PermGroups.Groups.centralizer`

— Method`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₁)Φ₂
```

`Chevie.ComplexR.Reflection`

— Type`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
```

`Chevie.ComplexR.codegrees`

— Method`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
```

`Chevie.ComplexR.complex_reflection_group`

— Method`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₂
A₂
julia> crg(4) # there is also a short alias
G₄
```

`Chevie.ComplexR.degrees`

— Method`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, ζ₃²)
```

`Chevie.ComplexR.degrees`

— Method`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
```

`Chevie.ComplexR.hyperplane_orbits`

— Method`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])
```

`Chevie.ComplexR.reflections`

— Method`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,ζ₃²)
```

`Chevie.KL`

— ModuleThis module defines Kazhdan-Lusztig polynomials and bases, and computes W-graphs and asymptotic algebras.

Let `ℋ`

be the Iwahori-Hecke algebra of a Coxeter system `(W,S)`

, with quadratic relations `(Tₛ-uₛ₀)(Tₛ-uₛ₁)=0`

for `s∈ S`

. If `-uₛ₀uₛ₁`

has a square root `wₛ`

, we can scale the basis `Tₛ`

to get a new basis `tₛ=-Tₛ/wₛ`

with quadratic relations `(tₛ-vₛ)(tₛ+vₛ⁻¹)=0`

where `vₛ=wₛ/uₛ₁`

. The most general case when Kazhdan-Lusztig bases and polynomials can be defined is when the parameters `vₛ`

belong to a totally ordered abelian group `Γ`

for multiplication, see Lusztig1983. We set `Γ⁺= {γ∈ Γ∣γ>0}`

and `Γ⁻={γ⁻¹∣γ∈ Γ⁺}={γ∈ Γ∣γ<0}`

.

Thus we assume `ℋ`

defined over the ring `ℤ[Γ]`

, the group algebra of `Γ`

over `ℤ`

, and the quadratic relations of `ℋ`

associate to each `s∈ S`

a `vₛ∈ Γ⁺`

such that `(tₛ-vₛ)(tₛ+vₛ⁻¹)=0`

. We also set `qₛ=vₛ²`

and define the basis `Tₛ=vₛtₛ`

with quadratic relations `(Tₛ-qₛ)(Tₛ+1)=0`

; for `w∈ W`

with reduced expression `w=s₁…sₙ`

we define $q_w∈ Γ⁺$ by $q_w^½=v_{s₁}…v_{sₙ}$ and let $q_w=(q_w^½)²$; we have $T_w=q_w^½t_w$.

We define the bar involution on `ℋ`

by linearity: on `ℤ[Γ]`

we define it by $\overline{∑_{γ∈ Γ}a_γγ}= ∑_{γ∈ Γ} a_γ γ⁻¹$ and we extend it to `ℋ`

by $\overline T_s=T_s^{-1}$ (equivalently `\overline t_s=t_s^{-1}`

`). Then the Kazhdan-Lusztig basis`

`C^′_w`

`is defined as the only basis of`

ℋ `stable by the bar involution and congruent to`

`t_w`

`modulo`

`∑_{w∈ W}Γ⁻.t_w`

`.

The basis $C^′_w$ can be computed as follows. We define elements $R_{x,y}$ of `ℤ[Γ]`

by $T_y⁻¹=∑_x \overline{R_{x,y⁻¹}} q_x⁻¹T_x$. We then define inductively the Kazhdan-Lusztig polynomials (in this general context we should say the Kazhdan-Lusztig elements of `ℤ[Γ]`

, which belong to the subalgebra of `ℤ[Γ]`

generated by the `qₛ`

) by $P_{x,w}=τ_{≤(q_w/q_x)^½} (∑_{x<y≤w}R_{x,y}P_{y,w})$ where `τ`

is the truncation: $τ_≤\nu ∑_{γ∈ Γ} a_γγ= ∑_{γ≤\nu}a_γγ$; the induction is thus on decreasing `x`

for the Bruhat order and starts at $P_{w,w}=1$. We have then $C^′_w=∑_y q_w^{-1/2} P_{y,w}T_y$.

The Chevie code for the Kazhdan-Lusztig bases `C`

, `D`

and their primed versions, was originally written by Andrew Mathas around 1994, who also contributed to the design of the programs dealing with Kazhdan-Lusztig bases. He also implemented some other bases, such as the Murphy basis which we also implement. The code for the case of unequal parameters was written around 1999 by F.Digne and J.Michel. The other Kazhdan-Lusztig bases are computed in terms of the `C′`

basis.

When the `ℤ[Γ]`

is a Laurent polynomial ring the bar operation is taking the inverse of the variables, and truncation is keeping terms of degree smaller or equal to that of `ν`

. It is possible to use arbitrary groups `Γ`

as long as methods `bar`

:$∑_{γ∈ Γ} a_γγ↦ ∑_{γ∈ Γ} a_γγ⁻¹$, `positive_part`

: $∑_{γ∈ Γ} a_γγ↦ ∑_{γ≥ 1} a_γγ$ and `negative_part`

: $∑_{γ∈ Γ} a_γγ ↦ ∑_{γ≤ 1} a_γγ$ have been defined on `ℤ[Γ]`

. These operations will be used internally by the programs to compute Kazhdan-Lusztig bases.

We provide also functionality to study the Kazhdan-Lusztig left cells (for the equal-parameter Hecke algebra).

```
julia> W=coxgroup(:H,3)
H₃
julia> c=left_cells(W)
22-element Vector{LeftCell{FiniteCoxeterGroup{Perm{Int16},Cyc{Int64}}}}:
LeftCell<H₃: duflo= character=φ₁‚₀>
LeftCell<H₃: duflo=123 character=φ₁‚₁₅>
LeftCell<H₃: duflo=(15) character=φ₅‚₅>
LeftCell<H₃: duflo=(10) character=φ₅‚₅>
LeftCell<H₃: duflo=(14) character=φ₅‚₅>
LeftCell<H₃: duflo=7 character=φ₅‚₅>
LeftCell<H₃: duflo=(12) character=φ₅‚₅>
LeftCell<H₃: duflo=(9,12) character=φ₅‚₂>
LeftCell<H₃: duflo=(5,11) character=φ₅‚₂>
LeftCell<H₃: duflo=13 character=φ₅‚₂>
⋮
LeftCell<H₃: duflo=(8,13) character=φ₃‚₆+φ₃‚₈>
LeftCell<H₃: duflo=(1,15) character=φ₃‚₆+φ₃‚₈>
LeftCell<H₃: duflo=3 character=φ₃‚₁+φ₃‚₃>
LeftCell<H₃: duflo=2 character=φ₃‚₁+φ₃‚₃>
LeftCell<H₃: duflo=1 character=φ₃‚₁+φ₃‚₃>
LeftCell<H₃: duflo=6 character=φ₄‚₃+φ₄‚₄>
LeftCell<H₃: duflo=(13) character=φ₄‚₃+φ₄‚₄>
LeftCell<H₃: duflo=(11) character=φ₄‚₃+φ₄‚₄>
LeftCell<H₃: duflo=9 character=φ₄‚₃+φ₄‚₄>
```

see also the functions `elements`

, `character`

, `representation`

and `Wgraph`

for left cells. The operations `length`

, `in`

(which refer to `elements`

) and `==`

(which compares Duflo involutions) are also defined for left cells. When `character(c)`

has been computed, then `c.a`

also has been bound which holds the common value of Lusztig's `a`

-function for the elements of `c`

and the irreducible constituents of `character(c)`

.

finally, benchmarks

```
julia> function test_kl(W)
q=Pol(); H=hecke(W,q^2,rootpara=q)
C=Cpbasis(H); T=Tbasis(H)
[T(C(w)) for w in elements(W)]
end
test_kl (generic function with 1 method)
julia> @btime test_kl(coxgroup(:F,4)); #julia 1.8
1.332 s (13934392 allocations: 2.27 GiB)
```

in GAP3 the following function takes 11s for W=F4

```
test_kl:=function(W)local q,H,T,C;
q:=X(Rationals);H:=Hecke(W,q^2,q);
T:=Basis(H,"T");C:=Basis(H,"C'");
List(Elements(W),e->T(C(e)));
end;
```

Another benchmark:

```
function test_kl2(W)
el=elements(W)
[KLPol(W,x,y) for x in el, y in el]
end
test_kl2 (generic function with 1 method)
julia>@btime test_kl2(coxgroup(:F,4)); # julia 1.9
4.307 s (42294917 allocations: 5.24 GiB)
```

in GAP3 the following function takes 42s for F4

```
test_kl2:=function(W)local el;
el:=Elements(W);
List(el,x->List(el,y->KazhdanLusztigPolynomial(W,x,y)));
end;
```

`Chevie.KL.AsymptoticAlgebra`

— Method`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 . . . . .
```

`Chevie.KL.LeftCell`

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

`Chevie.Chars.representation`

— Method`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]
```

`Chevie.HeckeAlgebras.Tbasis`

— Method`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).

`Chevie.KL.Cbasis`

— Method`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
```

`Chevie.KL.Cpbasis`

— Method`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′₁
```

`Chevie.KL.KLPol`

— Method`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.

`Chevie.KL.LusztigAw`

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

`Chevie.KL.Lusztigaw`

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

`Chevie.KL.Wgraph`

— Method`Wgraph(W::CoxeterGroup,i)`

return the W-graph for the `i`

-th irreducible representation of `W`

(or of the 1-parameter Hecke algebra of `W`

).

Only implemented for irreducible groups of type `E`

, `F`

or `H`

.

`Chevie.KL.Wgraph`

— Method`Wgraph(c::LeftCell)`

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

`Chevie.KL.character`

— Method`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
```

`Chevie.KL.critical_pair`

— Method`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
```

julia-repl

`Chevie.KL.left_cells`

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

`Chevie.KL.minimal_word`

— Method`minimal_word(cond::Function,gens::Vector,e;action::Function=^)`

returns minimal word `w`

such that composition(gens[w]) applied to `e`

satifies `cond`

`Chevie.KL.μ`

— Method`μ(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.

`Chevie.Nf`

— ModuleNumber 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 `Cyc`

s; 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₆₀)
```

`Chevie.Nf.Aut`

— Method`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
```

`Chevie.Nf.CF`

— Method`CF(N::Integer)`

the cyclotomic field generated by the `N`

-th roots of unity.

`Chevie.Nf.LenstraBase`

— Method`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₁₅]
```

`Chevie.Nf.NF`

— Method`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₁₅)
```

`Chevie.Nf.NF`

— Method`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`

.

`Chevie.Nf.gens_prime_residues`

— Method`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]
```

`CyclotomicNumbers.galois`

— Method`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₅)
```

julia-repl

`Chevie.Cosets`

— ModuleLet `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₁)
```

`Chevie.Cosets.Frobenius`

— Method`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
```

`Chevie.Cosets.graph_automorphisms`

— Method`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))
```

`Chevie.Cosets.spets`

— Methodspets(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₃‚₃‚₃₍₁‚₂‚₃‚₃₂‚₁₆‚₃₆‚₃₀‚₁₀₎
```

`Chevie.Cosets.spets`

— Method`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₃
```

`Chevie.Cosets.subspets`

— Function`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
```

`Chevie.Cosets.twistings`

— Method`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₄Φ₂²
```

`Chevie.Cosets.twistings`

— Method`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₄
```

`Chevie.Weyl.rootdatum`

— Method`rootdatum(type::String or Symbol[,dimension or bond::Integer])`

root datum from type. The known types are

`2B2, 2E6, 2E6sc, 2F4, 2G2, 2I, 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`

`Chevie.Weyl.torus`

— Method`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])
Φ₃
```

`Chevie.Weyl.torus`

— Method`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₃₍₎=Φ₁Φ₂²
```

`Chevie.CoxGroups`

— ModuleA 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 in 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.

`FinitePosets.Poset`

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

`Base.length`

— Method`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
```

`Chevie.CoxGroups.braid_relations`

— Method`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`

.

`Chevie.CoxGroups.bruhatless`

— Method`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]
```

`Chevie.CoxGroups.bruhatless`

— Method`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.

`Chevie.CoxGroups.coxeter_group`

— Method`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 `Ã₁`

.

`Chevie.CoxGroups.coxeter_hyperoctaedral_group`

— Method`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)
```

`Chevie.CoxGroups.coxeter_matrix`

— Method`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
```

`Chevie.CoxGroups.coxeter_matrix`

— Method`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
```

`Chevie.CoxGroups.coxeter_symmetric_group`

— Method`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
```

`Chevie.CoxGroups.firstleftdescent`

— Method`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 returns`

nothing`for`

one(W)`.

```
julia> W=coxsym(3)
𝔖 ₃
julia> firstleftdescent(W,Perm(2,3))
2
```

`Chevie.CoxGroups.inversions`

— Method`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
```

`Chevie.CoxGroups.isleftdescent`

— Method`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
```

`Chevie.CoxGroups.isrightdescent`

— Method`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
```

`Chevie.CoxGroups.leftdescents`

— Method`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
```

`Chevie.CoxGroups.longest`

— Function`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)
```

`Chevie.CoxGroups.standard_parabolic_class`

— Method`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]
```

`Chevie.PermRoot.cartan`

— Method`cartan(W::CoxeterGroup)`

The Cartan matrix of `W`

.

`Chevie.PermRoot.reflection_subgroup`

— Method`reflection_subgroup(W::CoxHyp,I)`

is defined only for `I=1:m`

for `m≤ngens(W)`

.

`Chevie.PermRoot.reflection_subgroup`

— Method`reflection_subgroup(W::CoxSym,I)`

The only reflection subgroups defined for `coxsym(n)`

are for `I=1:m`

for `m≤n`

`PermGroups.Groups.elements`

— Method`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
```

`PermGroups.Groups.word`

— Method`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)`

).

`PermGroups.Groups.words`

— Method`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
```

`PermGroups.Groups.words`

— Method`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]
```

`PermGroups.reduced`

— Function`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]
```

`PermGroups.reduced`

— Method`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]
```

`Chevie.Chars`

— ModuleCharacters 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}E(m)^j&0\\0&E(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 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 `φ₂,₁`

; `φ₂,₅'`

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

`Chevie.Chars.CharTable`

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

`Chevie.Chars.CharTable`

— Method`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
```

`Chevie.Chars.J_induction_table`

— Method`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
```

`Chevie.Chars.WGraphToRepresentation`

— Method`WGraphToRepresentation(coxrank::Integer,graph,v)`

We store some representations of one-parameter Iwahori-Hecke algebras as `W`

-graphs. For a Coxeter system `(W,S)`

where `coxrank=length(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 set`I(x)`

, 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]
```

`Chevie.Chars.charinfo`

— Method`charinfo(W)`

returns information about the irreducible characters of the finite reflection group or Spets `W`

. The result has the following entry:

`.charparams`

: contains parameters for the irreducible characters as described in the helpstring for `Chars`

. The parameters are lists with one component for each irreducible component of `W`

(as given by `refltype`

). For an irreducible component which is an imprimitive reflection group the component of the `charparam`

is a list of partitions (partitions for type `:A`

, double partitions for type `:B`

), and for a primitive irreducible group it is a list `[d,e]`

where `d`

is the degree of the character and `e`

is the smallest symmetric power of the character of the reflection representation which contains the given character as a component (the same as `b`

below). In addition, there is an ordinal number if more than one character shares the same `[d,e]`

.

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

when you print a `charinfo`

at the Repl or in Pluto or Jupyter, you get a table synthesizing the information.

```
julia> charinfo(coxgroup(:G,2))
n0│ name ext b B a A spaltenstein lusztig
──┼───────────────────────────────────────
1 │ φ₁‚₀ Id 0 0 0 0 1 1
2 │ φ₁‚₆ det 6 6 6 6 ε ε
3 │φ′₁‚₃ 3 3 1 5 εₗ ε′
4 │φ″₁‚₃ 3 3 1 5 ε_c ε″
5 │ φ₂‚₁ Λ¹ 1 5 1 5 θ′ θ′
6 │ φ₂‚₂ 2 4 1 5 θ″ θ″
```

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`

on.

The column `ext`

shows the exterior powers of the reflection representation. If `W`

is not irreducible, only two of these are irreducible thus shown: `Id`

corresponds to the field `.positionId`

and shows which is the trivial character. `det`

corresponds to the field `.positionDet`

and shows the determinant character (for Coxeter groups the sign character); it is the highest non-trivial exterior power if the reflection representation.

The characters marked `Λⁱ`

are the `i`

-th exterior power of the reflection representation. They are only present if `W`

is irreducible, in which case thye are irreducible characters by a thoerem of Steinberg. They are given by the field `.extRefl`

whose `i+1`

-th element is the index of the character `Λⁱ`

.

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.

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

`Chevie.Chars.charnames`

— Method`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.

`Chevie.Chars.classinfo`

— Method`classinfo(W)`

returns information about the conjugacy classes of the finite reflection group or Spets `W`

. The result has attributes:

`.classtext`

: contains words in the generators describing 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`map(x->word(W,representative(x)),conjugacyclasses(W))`

, and each such representative is of minimal length in its conjugacy class and is a "very good" element in the sense of GeckMichel1997.`.classparams`

: The elements of this list are tuples which have one component for each irreducible component of`W`

. These components for the infinite series, contain partitions or partition tuples describing the class (see the introduction). For the exceptional Coxeter groups they contain Carter's admissible diagrams, see Carter1972. For exceptional complex reflection groups they contain in general the same information as in classtext.`.classnames`

: Contains strings describing the conjugacy classes, made out of the information in`:classparams`

.

```
julia> classinfo(coxgroup(:A,2))
n0│name length order word
──┼───────────────────────
1 │ 111 1 1 .
2 │ 21 3 2 1
3 │ 3 2 3 12
```

See also the introduction of this section.

`Chevie.Chars.classnames`

— Method`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.

`Chevie.Chars.conjPerm`

— Method`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)
```

`Chevie.Chars.decompose`

— Method`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.

`Chevie.Chars.decomposition_matrix`

— Method`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`

.

`Chevie.Chars.detPerm`

— Method`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)
```

`Chevie.Chars.fakedegree`

— Function`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
```

`Chevie.Chars.fakedegrees`

— Function`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
```

`Chevie.Chars.induction_table`

— Method`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 Gap4
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 .
```

using an `IOContext`

allows to transmit attributes to the table format method

```
julia> xprint(t;rows=[5],cols=[3,2])
Induction table
│3 21
────┼─────
φ₂‚₁│. 1
```

It is also possible to TeX induction tables with an `IOContext`

of `TeX=true`

.

**This function also works for Spets (Reflection Cosets)**

`Chevie.Chars.j_induction_table`

— Method`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
```

`Chevie.Chars.on_chars`

— Method`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)
```

`Chevie.Chars.representation`

— Method`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]
```

`Chevie.Chars.representations`

— Method`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;;]]
```

`Chevie.Chars.schur_functor`

— Method`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
```

julia-repl

`LaurentPolynomials.discriminant`

— Method`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²
```

`Chevie.InitChevie.chevieget`

— Methodchevieget(t,w) returns CHEVIE[Symbol(t)][w]

`Chevie.InitChevie.getchev`

— Method`getchev(t::TypeIrred,f::Symbol,extra...)`

get `CHEVIE[field(t)][f](extra...)`

`Chevie.Murphy`

— ModuleThis 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.

`Chevie.Murphy.SpechtModules`

— ConstantSet `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.

`Chevie.Families`

— ModuleFamilies 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.

`Chevie.Families.Family`

— Type`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
```

`Base.:*`

— Method`<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.

`Base.conj`

— Method`conj(f::Family)`

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

`Base.length`

— Method`length(f::Family)`

: how many characters are in the family.

`Chevie.Families.FamiliesClassical`

— Method`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])
```

`Chevie.Families.cospecial`

— Method`cospecial(f::Family)`

the index of the cospecial character in `f`

`Chevie.Families.drinfeld_double`

— Method`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))
Family(D(coxsym(3)):8)
label│eigen
────────┼─────────────────────────────────────────────
(1,X.1) │ 1 1/6 1/3 1/6 -3/2 -3/2 1/3 1/3 1/3
(1,X.2) │ 1 1/3 2/3 1/3 0 0 -1/3 -1/3 -1/3
(1,1) │ 1 1/6 1/3 1/6 3/2 3/2 1/3 1/3 1/3
(2a,X.1)│ -1 -1/6 0 1/6 1/2 -1/2 0 0 0
(2a,1) │ 1 -1/6 0 1/6 -1/2 1/2 0 0 0
(3a,1) │ 1 1/3 -1/3 1/3 0 0 2/3 -1/3 -1/3
(3a,X.2)│ ζ₃² 1/3 -1/3 1/3 0 0 -1/3 -1/3 2/3
(3a,X.3)│ ζ₃ 1/3 -1/3 1/3 0 0 -1/3 2/3 -1/3
julia> drinfeld_double(coxsym(3);lu=true)
Family(LD(coxsym(3)):8)
label│eigen
────────┼─────────────────────────────────────────────
(1,X.1) │ 1 1/6 1/3 1/6 -3/2 -3/2 1/3 1/3 1/3
(1,X.2) │ 1 1/3 2/3 1/3 0 0 -1/3 -1/3 -1/3
(1,1) │ 1 1/6 1/3 1/6 3/2 3/2 1/3 1/3 1/3
(2a,X.1)│ -1 -1/6 0 1/6 1/2 -1/2 0 0 0
(2a,1) │ 1 -1/6 0 1/6 -1/2 1/2 0 0 0
(3a,1) │ 1 1/3 -1/3 1/3 0 0 2/3 -1/3 -1/3
(3a,X.2)│ ζ₃² 1/3 -1/3 1/3 0 0 -1/3 2/3 -1/3
(3a,X.3)│ ζ₃ 1/3 -1/3 1/3 0 0 -1/3 -1/3 2/3
```

`Chevie.Families.family_imprimitive`

— Method`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
```

`Chevie.Families.fourier`

— Method`fourier(f::Family`

: returns the Fourier matrix for the family `f`

.

`Chevie.Families.fusion_algebra`

— Function`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ᵢ)`is`

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

`Chevie.Families.ndrinfeld_double`

— Method`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
```

`Chevie.Families.special`

— Method`special(f::Family)`

the index of the special character in `f`

`CyclotomicNumbers.galois`

— Method`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(overline 0011,[4, 3, 2])
ComplexConjugate(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
```

`PermGroups.Perms.invpermute`

— Method`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
```

`FiniteFields.FFE`

— Method`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₇₂₉¹⁰⁴
```

`Chevie.Tools.abelian_gens`

— Method`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)
```

`Chevie.Tools.abelian_invariants`

— Method`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
```

`LaurentPolynomials.valuation`

— Method`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)
```

`Chevie.FFfac`

— ModuleFactoring polynomials over finite fields

see `factor`

.

`Chevie.FFfac.factors_same_degree`

— Method`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`

.

`Chevie.FFfac.factors_squarefree`

— Method`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`

.

`Primes.factor`

— Method`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³
```

`Chevie.HeckeAlgebras`

— ModuleThis 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 `KL`

for 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;
```

`Chevie.Chars.CharTable`

— Method`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²
```

`Chevie.HeckeAlgebras.FactSchur`

— TypeA `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
```

julia-repl

`Chevie.HeckeAlgebras.HeckeCoset`

— Type`HeckeCoset`

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

`Chevie.Chars.WGraphToRepresentation`

— Method`WGraphToRepresentation(H::HeckeAlgebra,gr::Vector)`

`H`

should be a one-parameter Hecke algebra for a finite Coxeter group where `rootpara`

is defined. The function returns the matrices of the representation of `H`

defined by the W-graph `gr`

.

```
julia> W=coxgroup(:H,3)
H₃
julia> H=hecke(W,Pol(:q)^2)
hecke(H₃,q²)
julia> g=Wgraph(W,3)
2-element Vector{Vector{Vector{Any}}}:
[[2], [1, 2], [1, 3], [1, 3], [2, 3]]
[[-1, [[1, 3], [2, 4], [3, 5], [4, 5]]]]
julia> WGraphToRepresentation(H,g)
3-element Vector{Matrix{Pol{Int64}}}:
[q² 0 … 0 0; 0 -1 … 0 0; … ; 0 0 … -1 q; 0 0 … 0 q²]
[-1 0 … 0 0; 0 -1 … q 0; … ; 0 0 … q² 0; 0 0 … q -1]
[q² 0 … 0 0; 0 q² … 0 0; … ; 0 q … -1 0; 0 0 … 0 -1]
```

`Chevie.Chars.representation`

— Method`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)]
```

`Chevie.Chars.representations`

— Method`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])
```

`Chevie.Garside.α`

— Method`α(a::HeckeTElt)`

the anti-involution on the Hecke algebra defined by $T_w↦ T_{inv(w)}$.

`Chevie.HeckeAlgebras.Tbasis`

— Method`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₁₁
```

`Chevie.HeckeAlgebras.alt`

— Method`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₁₂₁
```

`Chevie.HeckeAlgebras.central_monomials`

— Method`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¹⁵
```

`Chevie.HeckeAlgebras.char_values`

— Function`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
```

`Chevie.HeckeAlgebras.char_values`

— Method`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
```

`Chevie.HeckeAlgebras.class_polynomials`

— Method`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.

`Chevie.HeckeAlgebras.factorized_schur_element`

— Method`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)
```

`Chevie.HeckeAlgebras.factorized_schur_elements`

— Method`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)
```

`Chevie.HeckeAlgebras.hecke`

— Method`hecke(HF::HeckeCoset)`

returns the underlying Hecke algebra

`Chevie.HeckeAlgebras.hecke`

— Method`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`

.

`Chevie.HeckeAlgebras.hecke`

— Method`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]
```

`Chevie.HeckeAlgebras.isrepresentation`

— Method`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
```

`Chevie.HeckeAlgebras.schur_elements`

— Method`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⁻²Φ₂²Φ₄
```

`Chevie.PermRoot.reflection_representation`

— Method`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]
```

`Chevie.Chevie`

— ModuleThis 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.

`Chevie.jl`

requires julia 1.8 or later.

`Chevie.InducedDecompositionMatrix`

— Method`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`

.

`GenericDecMats.generic_decomposition_matrix`

— Method`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`

.

`LaurentPolynomials.coefficients`

— Function`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
```

`LaurentPolynomials.root`

— Function`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
```

`Chevie.Diagrams.diagram`

— Method`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₃₃
/^\
② ——② ——② ——② 423423==342342
1 2 4 5
```

`Chevie.PermRoot`

— ModuleLet `V`

be a vector space over a subfield `K`

of the complex numbers (in Julia the elements of `K`

will be usually represented by `Rational`

s or `Cyc`

s).

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

`Chevie.PermRoot.PRG`

— Method`PRG(roots,coroots)`

complex reflection group with given roots and coroots

`Chevie.PermRoot.PermRootGroup`

— Type`PermRootGroup`

is the type of reflection groups represented as a permutation group on a set of roots.

`Chevie.PermRoot.PermX`

— Method`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
```

`Chevie.PermRoot.PermY`

— Method`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
```

`Chevie.PermRoot.YMatrix`

— Method`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
```

`Chevie.PermRoot.action`

— Method`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)`

.

`Chevie.PermRoot.asreflection`

— Method`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)
```

`Chevie.PermRoot.bipartite_decomposition`

— Method`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])
```

`Chevie.PermRoot.cartan`

— Method`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`

`Chevie.PermRoot.cartan`

— Method`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
```

`Chevie.PermRoot.check_minimal_relation`

— Method`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.

`Chevie.PermRoot.coroot`

— Function`coroot(r,λ=-1)`

the coroot for a unitary reflection of root `r`

and eigenvalue `λ`

.

`Chevie.PermRoot.coroots`

— Method`coroots(W,i)`

same as but better than `coroots(W)[i]`

`Chevie.PermRoot.coroots`

— Method`coroots(W)`

the list of coroots of `W`

(listed in the same order as the roots)

`Chevie.PermRoot.coxeter_number`

— Method`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`

.

`Chevie.PermRoot.coxeter_number`

— Method`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.

`Chevie.PermRoot.generic_order`

— Function`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⁴
```

`Chevie.PermRoot.inclusion`

— Method`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).

`Chevie.PermRoot.invariant_form`

— Method`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
```

`Chevie.PermRoot.invariants`

— Method`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 `Mvp`

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

`Chevie.PermRoot.isparabolic`

— Method`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
```

`Chevie.PermRoot.number_of_hyperplanes`

— Method`number_of_hyperplanes(W::ComplexReflectionGroup)`

or `nhyp(W)`

The number of reflecting hyperplanes of `W`

`Chevie.PermRoot.number_of_reflections`

— Method`number_of_reflections(W::ComplexReflectionGroup)`

or `nref(W)`

the number of reflections of `W`

`Chevie.PermRoot.parabolic_closure`

— Method`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
```

`Chevie.PermRoot.parabolic_reps`

— Method`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]
```

`Chevie.PermRoot.radical`

— Method`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`

.

`Chevie.PermRoot.rank`

— Method`rank(W::ComplexReflectionGroup)`

This function returns the *rank* of a reflection group, which is the dimension of the space where it acts.

```
julia> rank(complex_reflection_group(31))
4
```

`Chevie.PermRoot.reflectionMatrix`

— Function`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
```

`Chevie.PermRoot.reflectionMatrix`

— Method`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.

`Chevie.PermRoot.reflection_character`

— Method`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
```

`Chevie.PermRoot.reflection_character`

— Method`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
```

`Chevie.PermRoot.reflection_eigenvalues`

— Method`refleigen(W,i)`

faster than `refleigen(W)[i]`

`Chevie.PermRoot.reflection_eigenvalues`

— Method`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]
[ζ₄³, ζ₄]
```

`Chevie.PermRoot.reflection_representation`

— Method`reflection_representation(W,i::Integer)`

or `reflrep(W,i)`

the matrix for the distinguished reflection around the `i`

-th root of `W`

.

`Chevie.PermRoot.reflection_representation`

— Method`reflection_representation(W::ComplexReflectionGroup)`

or `reflrep(W)`

returns `reflrep.(Ref(W),gens(W))`

, that is the generators of `W`

as matrices.

`Chevie.PermRoot.reflection_representation`

— Method`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
```

`Chevie.PermRoot.reflection_subgroup`

— Method`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₃₍₃₁₂₎Φ₁
```

`Chevie.PermRoot.refls`

— Method`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)

`Chevie.PermRoot.refls`

— Method`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.

`Chevie.PermRoot.restriction`

— Method`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).

`Chevie.PermRoot.roots`

— Method`roots(W::PermRootGroup,i)`

same as `roots(W)[i]`

`Chevie.PermRoot.roots`

— Method`roots(W::PermRootGroup)`

the roots of `W`

`Chevie.PermRoot.semisimplerank`

— Method`semisimpleRank(W::ComplexReflectionGroup)`

This function returns the *semisimple rank* of the reflection group `W`

, which is the dimension of the space where it effectively acts. If `W`

is a reflection group acting on `V`

, and `V₁`

is the subspace generated by the `roots(W)`

, then the dimension of `V₁`

is the semisimple rank. `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
```

`Chevie.PermRoot.simple_conjugating`

— Method`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)`

.

`Chevie.PermRoot.simple_conjugating`

— Method`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`

.

`Chevie.PermRoot.simple_reps`

— Method`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`

).

`Chevie.PermRoot.simple_reps`

— Method`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`

).

`Chevie.PermRoot.simplecoroots`

— Method`simplecoroots(W::ComplexReflectionGroup)`

the simple coroots of `W`

(those `corresponding to gens(W)`

) as a matrix (each coroot is a row)

`Chevie.PermRoot.simpleroots`

— Method`simpleroots(W::ComplexReflectionGroup)`

the simple roots of `W`

(those corresponding to `gens(W)`

) as a matrix (each root is a row)

`Chevie.PermRoot.torus_order`

— Function`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+ζ₃
```

`Chevie.PermRoot.type_irred`

— MethodLet 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)

`Chevie.PermRoot.unique_refls`

— Method`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`

.

`Combinat.catalan`

— Function`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
```

`PermGroups.Perms.reflection_length`

— Method`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 in a well-generated complex reflection group if `w`

divides a Coxeter element for the reflection length.

```
julia> W=coxgroup(:A,4)
A₄
julia> reflength(W,longest(W))
2
julia> reflength(W,W(1,2,3,4))
4
```

`Chevie.Urad`

— ModuleThis 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(repr(u^16;context=rio(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²)
```

`Chevie.Urad.UnipotentGroup`

— TypeA `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: a`

NamedTuple`for 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)])
```

`Chevie.Urad.UnipotentGroup`

— Method`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₂)
```

`Chevie.Urad.UnipotentGroup`

— Method'U(r)'

'U(r*1=>c*1`,..,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)
```

`Chevie.Chars.decompose`

— Method`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)
```

`Chevie.Urad.abelianpart`

— Method'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)
```

`Chevie.Urad.reorder`

— Function'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
```

`Chevie.Weyl`

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

`Chevie.CoxGroups.coxeter_group`

— Function`coxeter_group(type,rank[,bond];sc=false)`

(or `coxgroup`

)

This is equivalent to `rootdatum(cartan(type,rank[,bond]))`

.

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, equivalent to `rootdatum(id,cartan(type,rank[,bond]))`

where `id`

is the identity matrix of size `rank`

.

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

`Chevie.CoxGroups.coxeter_group`

— Method`coxeter_group()`

or `coxgroup()`

the trivial Coxeter group

`Chevie.CoxGroups.coxeter_matrix`

— Function`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.

`Chevie.CoxGroups.inversions`

— Method`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
```

`Chevie.PermRoot.cartan`

— Function`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
```

`Chevie.PermRoot.cartan`

— Method`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
```

`Chevie.PermRoot.reflection_subgroup`

— Method`reflection_subgroup(W::FiniteCoxeterGroup,I)`

The subgroup `H`

of `W`

generated by `refls(W,I)`

A theorem discovered 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.

`Chevie.PermRoot.roots`

— Method`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.

`Chevie.Weyl.badprimes`

— Method`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
```

`Chevie.Weyl.derived_datum`

— Method`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.

`Chevie.Weyl.describe_involution`

— Method`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.

`Chevie.Weyl.highest_short_root`

— Method`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
```

`Chevie.Weyl.istorus`

— Method`istorus(W)`

whether `W`

is a torus

`Chevie.Weyl.relative_group`

— Method`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 $R=N_W(W_J)/W_J$ is a Coxeter group with Coxeter generators the `v(s,J)`

. The program returns `R`

in its reflection representation on $X(ZL_J/ZG)$. (according to Lusztig1976, the images of the roots of `W`

in $X(ZL_J/ZG)$ form a root system).

`R`

has some extra properties reflecting its origin

`R.relativeIndices=setdiff(S,J)`

in a certain order`R.parentMap=`

the list of`v(s,J)`

corresponding to`.relativeIndices`

.`R.MappingFromNormalizer`

is a function mapping`J`

-reduced elements of $N_W(W_J)$ to elements of`R`

.

`Chevie.Weyl.rootdatum`

— Method`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₂Φ₁
```

`Chevie.Weyl.rootdatum`

— Method`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₃
```

`Chevie.Weyl.rootlengths`

— Method`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)`

.

`Chevie.Weyl.standard_parabolic`

— Method`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> reflection_subgroup(W,[20,30,19,22].^p)
E₆₍₂₄₅₆₎=A₄Φ₁²
julia> R=reflection_subgroup(W,[1,2,3,5,6,35])
E₆₍₁‚₃‚₂‚₃₅‚₅‚₆₎=A₂₍₁₃₎×A₂₍₂₆₎×A₂₍₄₅₎
julia> standard_parabolic(W,R)
```

`Chevie.Weyl.torus`

— Method`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)
Φ₁³
```

`Chevie.Weyl.two_tree`

— Function`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.

```
julia> two_tree(cartan(:A,4))
4-element Vector{Int64}:
1
2
3
4
julia> two_tree(cartan(:E,8))
(4, [2], [3, 1], [5, 6, 7, 8])
```

`Chevie.Weyl.type_cartan`

— Method`type_cartan(C)`

return a list of (series=s,indices=[i1,..,in]) for a Cartan matrix

`Chevie.Weyl.type_fincox_cartan`

— Method(series,rank,indices,cartantype,bond) for an irreducible Cartan matrix

`Chevie.Weyl.with_inversions`

— Method`with_inversions(W,N)`

`W`

should be a finite Coxeter group and `N`

a subset of `1:nref(W)`

. Returns the element `w`

of `W`

such that `N==inversions(W,w)`

. Returns `nothing`

if no such element exists.

```
julia> W=coxgroup(:A,2)
A₂
julia> map(N->with_inversions(W,N),combinations(1:nref(W)))
8-element Vector{Union{Nothing, Perm{Int16}}}:
()
(1,4)(2,3)(5,6)
(1,3)(2,5)(4,6)
nothing
nothing
(1,6,2)(3,5,4)
(1,2,6)(3,4,5)
(1,5)(2,4)(3,6)
```

`Chevie.Garside`

— ModuleGarside monoids are a general class of monoids whose most famous examples are the braid and dual braid monoids. They have groups of fractions which in both examples are the braid group. Here we implement braid groups in the framework of a general implementation of Garside monoids and groups.

To define Garside monoids we introduce some vocabulary about divisibility in monoids. A *left-divisor* of `x`

is a `d`

such that there exists `y`

with `x=dy`

(and then we say that `x`

is a *right multiple* of `d`

, and write `d≼ x`

). We say that a monoid `M`

is left cancellable if an equality `dx=dy`

implies `x=y`

. We define symmetrically right-divisors, left multiples and right cancellability. We say that `x`

is an *atom* if `1`

and `x`

are its only divisors. A *left gcd* of `x`

and `y`

is a common left divisor `d`

of `x`

and `y`

such that any other common left-divisor is a left-divisor of `d`

. Similarly a *right lcm* of `x`

and `y`

is a common multiple which is a left-divisor of any other common multiple.

We call *Garside* a monoid `M`

which:

- is left and right cancellable.
- is generated by its atoms.
- admits left and right gcds and lcms.
- is such that any element has only finitely many left (or right) divisors.
- admits a
*Garside element*, which is an element`Δ`

whose set of left and right-divisors coincide and generate`M`

.

Garside elements are not unique, but there is a unique minimal one (for divisibility); we assume that a Garside element `Δ`

has been chosen. Then the divisors of `Δ`

are called the *simples* of `M`

. A Garside monoid embeds into its group of fractions, which is called a *Garside group* (a group can have several different Garside structures, for instance braid groups of finite Coxeter groups have an ordinary and a dual braid monoid).

We also implement *locally Garside* monoids, which are monoids where lcms do not always exist, but exist if any common multiple exists; the set of simples is then not defined by a Garside element, but by the condition that they contain the atoms and are closed under lcms and taking divisors (see BDM01); since this is not ensured by the existence of a Garside element, one has to add the condition that each element is divisible by finitely many simples (but the number of simples can be infinite). The most important example is the Artin monoid of an infinite Coxeter group. It is not known whether these monoids embed in their group of fractions (although this has been proved for Artin monoids of Coxeter groups by Paris Paris01) and thus computing in the monoid does not help for computing in the group; only the monoid is implemented here for these cases.

What allows computing with Garside and locally Garside monoids, and Garside groups, is the fact that they admit normal forms –- these normal forms were exhibited for braid monoids of Coxeter groups by Deligne Del72, who extended earlier work of Brieskorn, Saito BS72 and Garside Gar69:

Let

`M`

be a locally Garside monoid. Then for`b∈ M`

there is a unique maximal simple left-divisor`α(b)`

of`b`

; any other simple dividing`b`

divides`α(b)`

.Let

`M`

be a Garside monoid with Garside element`Δ`

and group of fractions`G`

. Then for any`x∈ G`

, for large enough`i`

we have`Δⁱx∈ M`

.

A consequence of 1. is that every element has a canonical decomposition as a product of simples, called its left-greedy normal form. If we define `ω(x)`

by `x=α(x)ω(x)`

, then the normal form of `x`

is `α(x)α(ω(x))α(ω^2(x))…`

We use the normal form to represent elements of `M`

, and when `M`

is Garside we use 2. to represent elements of `G`

: given `x∈ G`

we compute the smallest power `i`

such that `Δⁱ x∈ M`

, and we represent `x`

by the pair `(i,Δ⁻ⁱx)`

. We are thus reduced to the case where `x∈ M`

, not divisible by `Δ`

, where we represent `x`

by the sequence of simples that make up its normal form.

We now describe Artin-Tits braid monoids. Let `(W,S)`

be a Coxeter system, that is `W`

has presentation

`⟨s∈ S∣s²=1, sts⋯ =tst⋯ (mₛₜ factors on each side) for s,t∈ S⟩`

for some Coxeter matrix `mₛₜ`

. The braid group `B`

associated to `(W,S)`

is the group defined by the presentation

`⟨𝐬∈ 𝐒∣ 𝐬𝐭𝐬⋯ =𝐭𝐬𝐭⋯ (mₛₜ factors on each side) for 𝐬,𝐭∈ 𝐒⟩`

The *positive* braid monoid `B⁺`

associated with `W`

is the monoid defined by the presentation above –- it identifies with the submonoid of `B`

generated by `𝐒`

by Paris01. This monoid is locally Garside, with the set of simples in bijection with the elements of `W`

and with `𝐒`

as atoms; we will denote by `𝐖`

the set of simples, and by `𝐰 ↦ w`

the bijection between simples and elements of `W`

. The group `W`

has a length defined in terms of reduced expressions. Similarly, having only homogeneous relations, `B⁺`

has a natural length function. Then `𝐖`

can be characterised as the subset of elements of `B⁺`

with the same length as their image in `W`

.

If `W`

is finite, then `B⁺`

is Garside with Garside element the element of `𝐖`

whose image is the longest element of `W`

. A finite Coxeter group is also a reflection group in a real vector space, thus in its complexified `V`

, and `B`

also has a topological definition as the fundamental group of the space `Vʳᵉᵍ/W`

, where `Vʳᵉᵍ`

is the set of elements of `V`

which are not fixed by any non-identity element of `S`

; however, we will not use this here.

We implement in general only monoids which have a finite number of atoms (there an implementation following the work of François Digne for the dual braid monoid of the affine Coxeter group `W(Ãₙ)`

).

Given a Coxeter group `W`

,

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

constructs the associated braid monoid, and then, used as a function, `B`

constructs elements of the braid monoid (or group when `W`

is finite) from a list of generators:

```
julia> w=B(1,2,3,4) # represents 𝐬₁𝐬₂𝐬₃𝐬₄
1234
julia> w^3 # the terms of the normal form are printed separated by a .
121321432.343
julia> word(α(w^3))
9-element Vector{Int64}:
1
2
1
3
2
1
4
3
2
julia> w^4
Δ.232432
julia> inv(w)
(1234)⁻¹
```

How an element of a Garside group is printed is controlled by the `IOcontext`

attribute ':greedy'. By default, elements are printed as fractions `a⁻¹b`

where `a`

and `b`

have no left common divisor. Each of `a`

and `b`

is printed using its left-greedy normal form, that is a maximal power of the Garside element followed by the rest. One can print the entire element in the left-greedy normal from by setting the `IOContext`

`:greedy=>true`

; with the same `w`

as above we have:

```
julia> repr(w^-1,context=IOContext(stdout,:greedy=>true,:limit=>true))
"Δ⁻¹.232432"
```

By default, `repr`

gives `w`

back in a form which after assigning `B=BraidMonoid(W)`

can be input back into Julia:

```
julia> repr(w)
"B(1,2,3,4)"
julia> repr(w^3)
"B(1,2,1,3,2,1,4,3,2,3,4,3)"
julia> repr(w^-1)
"B(-4,-3,-2,-1)"
```

In general elements of a Garside monoid are displayed as a list of their constituting atoms.

We now describe the dual braid monoid. For that, we first define interval monoids. Given a group `W`

and a set `S`

of generators of `W`

as a monoid, we define the `S`

-length `l_S(w)`

as the minimum number of elements of `S`

needed to write `w`

. We then define left-divisors of `x`

as the `d`

such that there exists `y`

with `x=dy`

and `l_S(d)+l_S(y)=l_S(x)`

. We say that `w∈ W`

is balanced if its set of left and right-divisors coincide; in which case we denote this set by `[1,w]`

, an "interval" for the poset of `S`

-divisibility. We say that `w`

is Garside for the `S`

-length if it is balanced and `[1,w]`

is a lattice (where upper and lower bounds are lcms and gcds), which generates `W`

. Then we have the theorem:

Suppose `w`

is Garside for the `S`

-length. Then the monoid `M`

with generators `[1,w]`

and relations `xy=z`

whenever `xy=z`

holds in `W`

and `l_S(x)+l_S(y)=l_S(z)`

, is a Garside monoid, with simples `[1,w]`

and atoms `S`

. It is called the interval monoid defined by the interval `[1,w]`

.

The Artin-Tits braid monoid is an interval monoid by taking for `S`

the Coxeter generators, in which case `l_S`

is the Coxeter length, and taking for `w`

the longest element of `W`

. The dual monoid, constructed by Birman, Ko and Lee for type `A`

and by Bessis for all well-generated complex reflection groups, is obtained in a similar way, by taking this time for `w`

a Coxeter element, for `l_S`

the reflection length 'reflength' and for `S_S`

the reflections which divide `w`

for the reflection length (for Coxeter groups all reflections divide `w`

but for well-generated complex reflection groups not all reflections divide); for the dual monoid the simples are of cardinality the generalized Catalan numbers `catalan`

. An interval monoid has naturally an inverse morphism from `M`

to `W`

, called 'image' which is the quotient map from the interval monoid to `W`

which sends back simple braids to `[1,w]`

.

A last pertinent notion is *reversible* monoids. Since we store left normal forms, it is easy to compute left lcms and gcds, but hard to compute right lcms and gcds. But this becomes easy to do if the monoid has an operation 'reverse', which has the property that 'a' is a left-divisor of 'b' if and only if 'reverse(a)' is a right-divisor of 'reverse(b)'. This holds for Artin-Tits and dual braid monoids of groups generated by true reflections; Artin-Tits monoids have a `reverse`

operation which consists of reversing a word, written as a list of atoms. The dual monoid also has a `reverse`

operation defined in the same way, but this operation changes monoid: it goes from the dual monoid for the Coxeter element `w`

to the dual monoid for the Coxeter element `w⁻¹`

. The operations 'rightlcm' and 'rightgcd', and some other algorithms, have faster implementations if the monoid has a `reverse`

operation.

This module implements also functions to solve the conjugacy problem and compute centralizers in Garside groups, following the work of Franco, Gebhardt and Gonzalez-Meneses.

Two elements `w`

and `w'`

of a monoid `M`

are *conjugate* in `M`

if there exists `x∈ M`

such that `wx=xw'`

; if `M`

satisfies the Öre conditions, it has a group of fractions where this becomes `x⁻¹wx=w'`

, the usual definition of conjugacy. A special case which is even closer to conjugacy in the group is if there exists `y∈ M`

such that `w=xy`

and `w'=yx`

. This relation is not transitive in general, but we call *cyclic conjugacy* the transitive closure of this relation, a restricted form of conjugacy.

The next observation is that if `w,w'`

are conjugate in the group of fractions of the Garside monoid `M`

then they are conjugate in `M`

, since if `wx=xw'`

then there is a power `Δⁱ`

which is central and such that `xΔⁱ∈ M`

. Then `wxΔⁱ=xΔⁱ w'`

is a conjugation in `M`

.

The crucial observation for solving the conjugacy problem is to introduce `inf(w):=sup{i such that Δ⁻ⁱw∈ M}`

and `sup(w):=inf{i such that w⁻¹Δⁱ∈ M}`

, and to notice that the number of conjugates of `w`

with same `inf`

and `sup`

as `w`

is finite (since our monoids have a finite number of atoms). Further, a theorem of Birman shows that the maximum `inf`

and minimum `sup`

in a conjugacy class can be achieved simultaneously; the elements achieving this are called the super summit set of `w`

. Thus a way to determine if two elements are conjugate is to find a representative of both of them in their super summit set, and then solve conjugacy within that set. This can also be used to compute the centralizer of an element: if we consider the super summit set as the objects of a category whose morphisms are the conjugations by simple elements, the centralizer is given by the endomorphisms of the given object.

We illustrate this on an example:

```
julia> b=B(2,1,4,1,4)
214.14
julia> c=B(1,4,1,4,3)
14.143
julia> d=conjugating_elt(b,c)
(1)⁻¹21321432
julia> b^d
14.143
julia> centralizer_gens(b)
3-element Vector{GarsideElt{Perm{Int16}, BraidMonoid{Perm{Int16}, FiniteCoxeterGroup{Perm{Int16},Int64}}}}:
321432.213243
21.1
4
julia> C=conjcat(b;ss=Val(:ss))
category with 10 objects and 32 generating maps
julia> C.obj
10-element Vector{GarsideElt{Perm{Int16}, BraidMonoid{Perm{Int16}, FiniteCoxeterGroup{Perm{Int16},Int64}}}}:
1214.4
214.14
124.24
1343.1
14.124
143.13
24.214
134.14
13.134
14.143
```

There is a faster solution to the conjugacy problem given in gebgon10: for each `b∈ M`

, they define a particular simple left-divisor of `b`

, its *preferred prefix* such that the operation *slide* which cyclically conjugates `b`

by its preferred prefix, is eventually periodic, and the period is contained in the super summit set of `x`

. We say that `x`

is in its sliding circuit if some iterated slide of `x`

is equal to `x`

. The set of sliding circuits in a given conjugacy class is smaller than the super summit set, thus allows to solve the conjugacy problem faster. Continuing from the above example,

```
julia> word(W,preferred_prefix(b))
2-element Vector{Int64}:
2
1
julia> b^B(preferred_prefix(b))
1214.4
julia> b1=b^B(preferred_prefix(b))
1214.4
julia> C=conjcat(b)
category with 2 objects and 6 generating maps
julia> C.obj
2-element Vector{GarsideElt{Perm{Int16}, BraidMonoid{Perm{Int16}, FiniteCoxeterGroup{Perm{Int16},Int64}}}}:
1214.4
1343.1
```

Finally, we have implemented Hao Zheng's algorithm to extract roots in a Garside monoid:

```
julia> W=coxgroup(:A,3)
A₃
julia> B=BraidMonoid(W)
BraidMonoid(A₃)
julia> Pi=B(B.δ)^2
Δ²
julia> root(Pi,2)
Δ
julia> root(Pi,3)
1232
julia> root(Pi,4)
132
```

`Chevie.Garside.BraidMonoid`

— Method`(B::BraidMonoid)(M::DualBraidMonoid,s)`

convert to an element of `B`

the simple `s`

of `M`

.

`Chevie.Garside.BraidMonoid`

— Method`(B::BraidMonoid)(M::DualBraidMonoid,i::Integer)`

convert to an element of `B`

the `i`

-th atom of `M`

.

`Chevie.Garside.BraidMonoid`

— Method`BraidMonoid(W::CoxeterGroup)`

The ordinary monoid of the Artin group associated to `W`

`Chevie.Garside.BraidMonoid`

— Method`(B::BraidMonoid)(b::GarsideElt)`

`b`

should be a dual braid. Convert `b`

to an element of `B`

.

`Chevie.Garside.DualBraidMonoid`

— Method`DualBraidMonoid(W;c=...)`

`W`

should be a well generated complex reflection group and `c`

a Coxeter element of `W`

, which should be a `Vector{Int}`

specifying `W(c...)`

. If no `c`

is given a particular one is chosen for Coxeter groups by making the product of elements in a partition of the Coxeter diagram in two sets where in each set elements commute pairwise; for a complex reflection group the representative stored in the Coxeter class is used.

The function returns the dual braid monoid determined by `W`

and `c`

```
julia> W=coxgroup(:A,3)
A₃
julia> B=DualBraidMonoid(W)
DualBraidMonoid(A₃,c=[1, 3, 2])
julia> B(2,1,2,1,1)
12.1.1.1
julia> B(-1,-2,-3,1,1)
(25.1)⁻¹1.1
julia> W=crg(4)
G₄
julia> B=DualBraidMonoid(W)
DualBraidMonoid(G₄,c=[1, 2])
julia> left_divisors(B(B.δ))
5-element Vector{GarsideElt{Perm{Int16}, DualBraidMonoid{Perm{Int16}, PRG{Cyc{Rational{Int64}}, Int16}}}}:
.
1
2
3
δ
```

`Chevie.Garside.GarsideMonoid`

— Type`GarsideMonoid{T}`

is the abstract type of Garside monoids, where `T`

is the type of simples. Such a monoid `M`

should implement the same methods as `LocallyGarsideMonoid`

except that `isrightascent(M,a)`

is automatically defined as `isleftdescent(M,\(M,a,M.δ),i)`

.

An implementation should have fields `M.δ`

, `M.stringδ`

An interval monoid should have a field `M.orderδ`

.

`Chevie.Garside.LocallyGarsideMonoid`

— Type`LocallyGarsideMonoid{T}`

is the abstract type of locally Garside monoids, where `T`

is the type of simples. Such a monoid `M`

needs, for `a,b`

simples, to implement the functions

`one(M)`

`isleftdescent(M,a,i::Int)`

whether`M.atoms[i]≼ a`

`isrightdescent(M,a,i::Int)`

whether`a≽ M.atoms[i]`

`isrightascent(M,a,i::Int)`

whether`a*M.atoms[i]`

is simple`*(M,a,b)`

when`a*b`

is simple returns the simple`a*b`

`\(M,a,b)`

when`a≼ b`

returns the simple`a`

`/(M,a,b)`

when`a≽ b`

returns the simple`a/b`

`GroupPresentations.Presentation`

— Method`Presentation(M::GarsideMonoid)`

returns a presentation of the Garside group defined by `M`

(as given in theorem 4.1 of Dehornoy-Paris 1999).

```
julia> M=DualBraidMonoid(coxgroup(:A,3))
DualBraidMonoid(A₃,c=[1, 3, 2])
julia> p=Presentation(M)
Presentation: 6 generators, 15 relators, total length 62
```

```
julia> simplify(p)
<< presentation with 3 generators, 4 relators of total length 26>>
<< presentation with 3 generators, 3 relators of total length 16>>
julia> display_balanced(p)
1: ab=ba
2: cac=aca
3: cbc=bcb
```

`Chevie.CoxGroups.isleftdescent`

— Method`isleftdescent(M,w,i)`

returns `true`

if and only if the `i`

-th atom of the locally Garside monoid `M`

left-divides the simple `w`

.

`Chevie.CoxGroups.leftdescents`

— Method`leftdescents(b::LocallyGarsideElt)`

the list of indices of the atoms which left-divide `b`

`Chevie.Garside.Brieskorn_normal_form`

— Method`Brieskorn_normal_form(b::LocallyGarsideElt)`

Brieskorn citeBri71 has noticed that if `L(b)`

is the left descent set of `b`

(see `leftdescents`

), and if `b_(L(b))`

is the right lcm of `L(b)`

, then `b_(L(b))`

left-divides `b`

. We can now divide `b`

by `b_(L(b))`

and continue this process with the quotient. In this way, we obtain an expression `b=b_(L₁)⋯ b_(Lᵣ)`

where `Lᵢ=L(b_(Lᵢ)⋯ b_(Lᵣ))`

for all `i`

, which we call the *Brieskorn normal form* of `b`

. The function `Brieskorn_normal_form`

returns a description of this form, by returning the list of sets `L(b)`

which describe the above decomposition.

```
julia> W=coxgroup(:E,8);B=BraidMonoid(W)
BraidMonoid(E₈)
julia> w=B(2,3,4,2,3,4,5,4,2,3,4,5,6,5,4,2,3,4,5,6,7,6,5,4,2,3,4,5,6,7,8)
2342345423456542345676542345678
julia> Brieskorn_normal_form(w)
2-element Vector{Vector{Int64}}:
[2, 3, 4, 5, 6, 7]
[8]
julia> Brieskorn_normal_form(w^2)
2-element Vector{Vector{Int64}}:
[2, 3, 4, 5, 6, 7, 8]
[2, 3, 4, 5, 6]
```

`Chevie.Garside.CorranPicantinMonoid`

— Function`CorranPicantinMonoid(e,n,k=1)`

returns the interval monoid defined by G. Neaime, http://arxiv.org/abs/1707.06864, which generalizes the Corran-Picantin monoid for `G(e,e,n)`

.

In this monoid `δ`

has `image`

the element of `G(e,e,n)`

corresponding to the diagonal matrix whose diagonal entries except the first are equal to `E(e)^k`

; this monoid is isomorphic to the Corran-Picantin monoid for `G(e,e,n)`

when `gcd(k,e)=1`

.

```
julia> C=CorranPicantinMonoid(3,3)
CorranPicantinMonoid(3,3,3)
julia> word(C(C.δ))
6-element Vector{Int64}:
1
3
4
1
3
4
julia> Matrix(C,C.δ)
3×3 Matrix{Cyc{Int64}}:
ζ₃ 0 0
0 ζ₃ 0
0 0 ζ₃
julia> b=C(1,2,3,4)^3
1.2.341.2.341.2.34
julia> Matrix(C,b[3])
3×3 Matrix{Cyc{Int64}}:
0 0 ζ₃
0 ζ₃² 0
1 0 0
```

© July 2017 –- Jean Michel and Georges Neaime

`Chevie.Garside.centralizer_gens`

— Function`centralizer_gens(b[,F];ss=Val(:sc))`

a list of generators of the centralizer of `b`

. The computation is done by computing the endomorphisms of the object `b`

in the category of its sliding circuits. If an argument `ss`

is given, the computation is done in the corresponding category –- see `conjcat`

.

If an argument `F`

is given it should be an automorphism of the braid monoid, like the Frobenius of a reflection coset attached to `b.M.W`

; then the `F`

-centralizer is computed.

```
julia> W=coxgroup(:D,4)
D₄
julia> B=BraidMonoid(W)
BraidMonoid(D₄)
julia> w=B(4,4,4)
4.4.4
julia> cc=centralizer_gens(w)
8-element Vector{GarsideElt{Perm{Int16}, BraidMonoid{Perm{Int16}, FiniteCoxeterGroup{Perm{Int16},Int64}}}}:
1
(31432)⁻¹231432
(1)⁻¹34.431
(2)⁻¹34.432
(32431)⁻¹132431
4
34.43
2
julia> shrink(cc)
5-element Vector{GarsideElt{Perm{Int16}, BraidMonoid{Perm{Int16}, FiniteCoxeterGroup{Perm{Int16},Int64}}}}:
4
2
1
34.43
(3243)⁻¹13243
julia> centralizer_gens(w;ss=Val(:cyc))
Set{GarsideElt{Perm{Int16}, BraidMonoid{Perm{Int16}, FiniteCoxeterGroup{Perm{Int16},Int64}}}} with 1 element:
4
julia> F=Frobenius(spets(W,Perm(1,2,4)));
julia> centralizer_gens(w,F)
2-element Vector{GarsideElt{Perm{Int16}, BraidMonoid{Perm{Int16}, FiniteCoxeterGroup{Perm{Int16},Int64}}}}:
124
312343123
```

`Chevie.Garside.conjcat`

— Function`conjcat(b[,F];ss=Val(:sc))`

returns the conjugacy category of the summit set of `b`

of the required type.

- By default, computes the category of sliding circuits of
`b`

. - If
`ss==Val(:ss)`

, computes the super summit set. - If
`ss==Val(:cyc)`

, computes the cyclic conjugacy category. - If
`ss==Val(:inf)`

computes the category of all conjugate elements with same`Inf`

as`b`

.

If an argument `F`

is given it should be the Frobenius of a Reflection coset attached to `b.M.W`

. Then the `F`

-conjugacy category is returned.

```
julia> W=coxgroup(:A,4)
A₄
julia> w=BraidMonoid(W)(4,3,3,2,1)
43.321
julia> C=conjcat(w)
category with 2 objects and 4 generating maps
julia> C.obj
2-element Vector{GarsideElt{Perm{Int16}, BraidMonoid{Perm{Int16}, FiniteCoxeterGroup{Perm{Int16},Int64}}}}:
32143
21324
```

```
julia> xprint(C;graph=true)
category with 2 objects and 4 generating maps
32143 21343 21324 13214
32143────→ 32143────→ 21324────→ 21324────→ 32143
```

```
julia> conjcat(w;ss=Val(:ss)).obj
4-element Vector{GarsideElt{Perm{Int16}, BraidMonoid{Perm{Int16}, FiniteCoxeterGroup{Perm{Int16},Int64}}}}:
32143
13243
21432
21324
```

`Chevie.Garside.conjugating_elt`

— Functionconjugating_elt(b,b₁[,F];ss=Val(:sc))

`b`

and `b₁`

should be elements of the same Garside group. The function returns `a`

such that `b^a=b₁`

if such exists, and `nothing`

otherwise. If an argument `ss`

is given, the computation is done in the corresponding category –- see `conjcat`

. If an argument `F`

is given it should be an automorphism of the braid monoid, like the Frobenius of a reflection coset attached to `b.M.W`

; the computation is then done in the corresponding `F`

-conjugacy category.

```
julia> W=coxgroup(:D,4)
D₄
julia> B=BraidMonoid(W)
BraidMonoid(D₄)
julia> b=B(2,3,1,2,4,3)
231243
julia> b1=B(1,4,3,2,2,2)
1432.2.2
julia> conjugating_elt(b,b1)
(134312.23)⁻¹
julia> c=conjugating_elt(b,b1;ss=Val(:cyc))
232.2
julia> b^c
1432.2.2
julia> WF=spets(W,Perm(1,2,4))
³D₄
julia> F=Frobenius(WF);
julia> c=B(3,4,3,1,2,3)
343123
julia> conjugating_elt(b,c,F)
124312
julia> ^(b,B(1,2,4,3,1,2),F)
343123
```

`Chevie.Garside.endomorphisms`

— Method`endomorphisms(C::Category,o)`

returns generators of the endomorphisms of `C.obj[o]`

`Chevie.Garside.fraction`

— Method`fraction(b::GarsideElt)`

`denominator(b::GarsideElt)`

`numerator(b::GarsideElt)`

`fraction(b)`

returns a tuple `(x,y)`

of positive Garside elements with trivial `leftgcd`

and such that `b=x\y`

. For such a decomposition, `denominator(b)`

returns `x`

and `numerator(b)`

returns `y`

.

```
julia> B=BraidMonoid(coxgroup(:A,3))
BraidMonoid(A₃)
julia> b=B( 2, 1, -3, 1, 1)
(23)⁻¹321.1.1
julia> fraction(b)
(23, 321.1.1)
```

`Chevie.Garside.hurwitz`

— Method`hurwitz(l,v::AbstractVector{<:Integer})`

does successively `hurwitz(l,i)`

for each `i`

in `v`

.

`Chevie.Garside.hurwitz`

— Method`hurwitz(l,b)`

the Hurwitz action of the braid `b∈ Bₙ`

on the list `l`

of length `n`

of group elements.

`Chevie.Garside.hurwitz`

— Method`hurwitz(l,i::Integer)`

the Hurwitz action of the generator σᵢ of the braid group Bₙ on the list `l`

of length `n`

of group elements, which replaces `lᵢ,lᵢ₊₁`

by `lᵢ₊₁,lᵢ^lᵢ₊₁`

. If `i<0`

, does the action of `inv(σⱼ)`

where `j=-i`

, which replaces `lⱼ,lⱼ₊₁`

by `lⱼ₊₁^inv(lⱼ),lⱼ`

.

`Chevie.Garside.image`

— Method`image(b::GarsideElt)`

This function is defined only if `b`

is an element of an interval monoid, for instance a braid. It returns the image of `b`

in the group of which the monoid is an interval monoid. For instance it gives the projection of a braid in an Artin monoid back to the Coxeter group.

```
julia> W=coxsym(4)
𝔖 ₄
julia> b=BraidMonoid(W)(2,1,2,1,1)
121.1.1
julia> p=image(b)
(1,3)
julia> word(W,p)
3-element Vector{Int64}:
1
2
1
```

`Chevie.Garside.left_divisors`

— Functionleft_divisors(M::LocallyGarsideMonoid, s)

left_divisors(M::LocallyGarsideMonoid, s,i)

all the left-divisors of the simple element `s`

of `M`

, as a vector of vectors of simples, where the i+1-th vector of simples holds the left-divisors of length i in the atoms. If a third argument `i`

is given, returns the list of divisors of length `i`

.

```
julia> W=coxgroup(:A,3)
A₃
julia> B=BraidMonoid(W)
BraidMonoid(A₃)
julia> map(x->B.(x),left_divisors(B,W(1,3,2)))
4-element Vector{Vector{GarsideElt{Perm{Int16}, BraidMonoid{Perm{Int16}, FiniteCoxeterGroup{Perm{Int16},Int64}}}}}:
[.]
[1, 3]
[13]
[132]
julia> B=DualBraidMonoid(W)
DualBraidMonoid(A₃,c=[1, 3, 2])
julia> map(x->B.(x),left_divisors(B,W(1,3,2)))
4-element Vector{Vector{GarsideElt{Perm{Int16}, DualBraidMonoid{Perm{Int16}, FiniteCoxeterGroup{Perm{Int16},Int64}}}}}:
[.]
[1, 2, 3, 4, 5, 6]
[12, 13, 15, 25, 34, 45]
[δ]
```

`Chevie.Garside.left_divisors`

— Method`left_divisors(b::LocallyGarsideElt[, i])`

returns all left-divisors of `b`

(left-divisors of length `i`

if specified)

```
julia> B=DualBraidMonoid(coxsym(4))
DualBraidMonoid(𝔖 ₄,c=[1, 3, 2])
julia> left_divisors(B(1,5,4,3))
10-element Vector{GarsideElt{Perm{Int16}, DualBraidMonoid{Perm{Int16}, CoxSym{Int16}}}}:
.
1
1.4
1.4.2
1.4.3
5
6
15
15.4
15.4.3
julia> left_divisors(B(1,5,4,3),1)
3-element Vector{GarsideElt{Perm{Int16}, DualBraidMonoid{Perm{Int16}, CoxSym{Int16}}}}:
1
5
6
```

`Chevie.Garside.leftgcd`

— Method`leftgcd(M::LocallyGarsideMonoid,simp...)`

`leftgcdc(M::LocallyGarsideMonoid,simp...)`

`simp`

should be simples of `M`

. The function returns the left gcd `d`

of the `simp`

.

`leftgcdc`

returns `d`

followed by the tuple of complements `inv(d).*simp`

`Chevie.Garside.leftgcd`

— Method`leftgcd(a₁,…,aₙ)`

`leftgcdc(a₁,…,aₙ)`

`a₁,…,aₙ`

should be elements of the same (locally) Garside monoid. The function returns the left gcd `d`

of `a₁,…,aₙ`

.

`leftgcdc`

returns `(d,(d⁻¹a₁,…,d⁻¹aₙ))`

.

```
julia> W=coxgroup(:A,3)
A₃
julia> B=BraidMonoid(W)
BraidMonoid(A₃)
julia> leftgcdc(B(2,1,2)^2,B(3,2)^2)
(2, (121.21, 32.2))
```

`Chevie.Garside.leftlcm`

— Method`leftlcm(M::GarsideMonoid,simp...)`

`leftlcmc(M::GarsideMonoid,simp...)`

`simp`

should be simples of `M`

. The function returns the left lcm `m`

of the `simp`

.

`leftlcmc`

returns `m`

followed by the tuple of complements `m./simp`

`Chevie.Garside.leftlcm`

— Method`leftlcm(a₁,…,aₙ)`

`leftlcmc(a₁,…,aₙ)`

`a₁,…,aₙ`

should be elements of the same Garside monoid. The function returns the least common left multiple `m`

of `a₁,…,aₙ`

.

`leftlcmc`

returns '(m,(m/a₁,…,m/aₙ))`.

```
julia> B=BraidMonoid(coxgroup(:A,3))
BraidMonoid(A₃)
julia> leftlcmc(B(2,1,2)^2,B(3,2)^2)
(Δ.121, (123, 23.321))
```

`Chevie.Garside.rightascents`

— Method`rightascents(M,s)`

where `s`

is a simple return the right ascents of `s`

, that is the list of `i`

such that `s*M.atoms[i]`

is still simple.

`Chevie.Garside.rightgcd`

— Method`rightgcd(M::LocallyGarsideMonoid,simp...)`

`rightgcdc(M::LocallyGarsideMonoid,simp...)`

`simp`

should be simples of `M`

. The function returns the right gcd `d`

of the `simp`

.

`rightgcdc`

returns `d`

followed by the tuple of complements `simp./d`

`Chevie.Garside.rightgcd`

— Method`rightgcd(a₁,…,aₙ)`

`rightgcdc(a₁,…,aₙ)`

`a₁,…,aₙ`

should be elements of the same (locally) Garside monoid. The function returns the right gcd `d`

of `a₁,…,aₙ`

`rightgcdc`

returns `(d,(a₁/d,…,aₙ/d))`

.

```
julia> W=coxgroup(:A,3)
A₃
julia> B=BraidMonoid(W)
BraidMonoid(A₃)
julia> rightgcdc(B(2,1,2)^2,B(3,2)^2)
(2.2, (12.21, 23))
```

`Chevie.Garside.rightlcm`

— Method`rightlcm(M::GarsideMonoid,simp...)`

`rightlcmc(M::GarsideMonoid,simp...)`

`simp`

should be simples of `M`

. The function returns the right lcm `m`

of the `simp`

.

`rightlcmc`

returns `m`

followed by the tuple of complements `simp.\m`

`Chevie.Garside.rightlcm`

— Method`rightlcm(a₁,…,aₙ)`

`rightlcmc(a₁,…,aₙ)`

`a₁,…,aₙ`

should be elements of the same Garside monoid. The function returns the least common right multiple `m`

of `a₁,…,aₙ`

.

`rightlcmc`

returns '(m,(a₁⁻¹*m,…,aₙ⁻¹*m))`.

```
julia> B=BraidMonoid(coxgroup(:A,3))
BraidMonoid(A₃)
julia> rightlcmc(B(2,1,2)^2,B(3,2)^2)
(Δ², (321.123, 12321.321))
```

`Chevie.Garside.shrink`

— Methodshrink(l::Vector{<:GarsideElt})

The list `l`

is a list of elements of the same Garside group `G`

. This function tries to find another set of generators of the subgroup of `G`

generated by the elements of `l`

, of smaller total length (the length being counted as returned by the function `word`

). This can be use to simplify the result of `centralizer_gens`

, or other braid subgroups.

```
julia> B=BraidMonoid(coxsym(3))
BraidMonoid(𝔖 ₃)
julia> b=[B(1)^3,B(2)^3,B(-2,-1,-1,2,2,2,2,1,1,2),B(1,1,1,2)]
4-element Vector{GarsideElt{Perm{Int16}, BraidMonoid{Perm{Int16}, CoxSym{Int16}}}}:
1.1.1
2.2.2
(1.12)⁻¹2.2.2.21.12
1.1.12
julia> shrink(b)
2-element Vector{GarsideElt{Perm{Int16}, BraidMonoid{Perm{Int16}, CoxSym{Int16}}}}:
2
1
```

`Chevie.Garside.α`

— Method`α(b::LocallyGarsideElt,I)`

returns the longest prefix of b using only `b.M.atoms[I]`

```
julia> W=coxgroup(:A,4);B=BraidMonoid(W)
BraidMonoid(A₄)
julia> w0=B(longest(W))
Δ
julia> α(w0,[1,2,3])
121321
```

`Chevie.Garside.α`

— Method`α(b::LocallyGarsideElt)`

returns as a Garside element the first term in the normal form of `b`

(`b[1]`

or returns this term as a simple).

```
julia> W=coxgroup(:A,3)
A₃
julia> b=BraidMonoid(W)(2,1,2,1,1)
121.1.1
julia> α(b)
121
```

`Chevie.Garside.α2`

— Method`α2(M::LocallyGarsideMonoid,x,v)`

returns M(x)*M(v)[1],M(x)*M(v)[2] for the simples x and v

`Chevie.Garside.δad`

— Function`δad(M::GarsideMonoid,x,i=1)`

returns the image of the simple `x`

by the `i`

-th power of the automorphism induced by conjugation by `M.δ`

.

`Chevie.Garside.δad`

— Function`δad(b::GarsideElt,i=1)`

returns the image of `b`

by the `i`

-th power of the automorphism induced by conjugation by `b.M.δ`

.

`PermGroups.Groups.elements`

— Method`elements(M::LocallyGarsideMonoid,l::Integer)`

`elements(M::LocallyGarsideMonoid,v::AbstractVector{<:Integer})`

`M`

should have an additive length function (that is, a product of `l`

atoms is not equal to any product of less than `l`

atoms). `elements(M,l)`

returns the list of elements of length `l`

in `M`

.

In the second form `elements`

returns all elements of length `i`

for `i∈ v`

.

```
julia> M=BraidMonoid(coxgroup(:A,2))
BraidMonoid(A₂)
julia> elements(M,4)
12-element Vector{GarsideElt{Perm{Int16}, BraidMonoid{Perm{Int16}, FiniteCoxeterGroup{Perm{Int16},Int64}}}}:
Δ.1
Δ.2
12.21
12.2.2
1.12.2
1.1.12
1.1.1.1
21.12
21.1.1
2.21.1
2.2.21
2.2.2.2
```

`PermGroups.Groups.word`

— Method`word(b::GarsideElt)`

returns a description of `b`

as a list of the atoms of which it is a product. If `b`

is in the Garside group but not the Garside monoid, it is represented in fraction normal form where as a special convention the inverses of the atoms are represented by negating the corresponding integer.

```
julia> B=BraidMonoid(coxgroup(:A,3))
BraidMonoid(A₃)
julia> b=B(2,1,2,1,1)*inv(B(2,2))
(21)⁻¹1.12.21
julia> word(b)
7-element Vector{Int64}:
-1
-2
1
1
2
2
1
```

`PermGroups.Groups.word`

— Method`word(M::GarsideMonoid,w)`

returns a word in the atoms of `M`

representing the simple `w`

```
julia> B=BraidMonoid(coxgroup(:A,3))
BraidMonoid(A₃)
julia> word(B,B.δ)
6-element Vector{Int64}:
1
2
1
3
2
1
```

`PermGroups.Groups.words`

— Method`words(b::LocallyGarsideElt)`

returns all the decompositions in atoms of `b`

```
julia> W=coxgroup(:A,2)
A₂
julia> pi=BraidMonoid(W)(longest(W))^2
Δ²
julia> words(pi)
8-element Vector{Vector{Int64}}:
[1, 1, 2, 1, 1, 2]
[1, 2, 1, 1, 2, 1]
[1, 2, 1, 2, 1, 2]
[1, 2, 2, 1, 2, 2]
[2, 1, 1, 2, 1, 1]
[2, 1, 2, 1, 2, 1]
[2, 1, 2, 2, 1, 2]
[2, 2, 1, 2, 2, 1]
```

`Chevie.Eigenspaces`

— ModuleEigenspaces and `d`

-Harish-Chandra series

Let `Wϕ`

be a reflection coset on a vector space `V`

; that is `Φ∈GL(V)`

normalizes the reflection group `W`

. Let `Lwϕ`

be a reflection subcoset; that is `L`

is a parabolic subgroup of `W`

(the fixator of a subspace of `V`

) and `w∈ W`

is such that `wΦ`

normalizes `L`

. There are several interesting cases where the *relative group* $N_W(Lwϕ)/L$, or a subgroup of it normalizing some further data attached to `L`

, is itself a reflection group.

A first example is the case where `ϕ=1`

and `w=1`

, `W`

is the Weyl group of a finite reductive group $𝐆^F$ and the Levi subgroup $𝐋^F$ corresponding to `L`

has a cuspidal unipotent character. Then $N_W(L)/L$ is a Coxeter group acting on the space `X(Z𝐋)⊗ℝ`

. A combinatorial characterization of such parabolic subgroups of Coxeter groups is that they are normalized by the longest element of larger parabolic subgroups (see 5.7.1 Lusztig1976).

A second example is when `L`

is trivial and `wϕ`

is a * ζ-regular element*, that is the

`ζ`

-eigenspace $V_ζ$ of `wϕ`

contains a vector outside all the reflecting hyperplanes of `W`

. Then $N_W(Lwϕ)/L=C_W(wϕ)$ is a reflection group in its action on $V_ζ$.A similar but more general example is when $V_ζ$ is the `ζ`

-eigenspace of some element of the reflection coset `Wϕ`

, and is of maximal dimension among such `ζ`

-eigenspaces. Then the set of elements of `Wϕ`

which act by `ζ`

on $V_ζ$ is a certain subcoset `Lwϕ`

, and $N_W(Lwϕ)/L$ is a reflection group in its action on $V_ζ$ (see 2.5 Lehrer-Springer1999).

Finally, a still more general example, but which only occurs for Weyl groups or Spetsial reflection groups, is when `𝐋`

is a `ζ`

-split Levi subgroup (which means that the corresponding subcoset `Lwϕ`

is formed of all the elements which act by `ζ`

on some subspace `V_ζ`

of `V`

), and `λ`

is a `d`

-cuspidal unipotent character of `𝐋`

(which means that the multiplicity of `ζ`

as a root of the degree of `λ`

is the same as the multiplicity of `ζ`

as a root of the generic order of the semi-simple part of `𝐆`

); then $N_W(Lwϕ,λ)/L$ is a complex reflection group in its action on `V_ζ`

.

Further, in the above cases the relative group describes the decomposition of a Lusztig induction.

When $𝐆^F$ is a finite reductive group, and `λ`

a cuspidal unipotent character of the Levi subgroup $𝐋^F$, then the $𝐆^F$-endomorphism algebra of the Harish-Chandra induced representation $R_𝐋^𝐆(λ)$ is a Hecke algebra attached to the group $N_W(L)/L$, thus the dimension of the characters of this group describe the multiplicities in the Harish-Chandra induced.

Similarly, when `𝐋`

is a `ζ`

-split Levi subgroup, and `λ`

is a `d`

-cuspidal unipotent character of `𝐋`

then (conjecturally) the $𝐆^F$-endomorphism algebra of the Lusztig induced $R_𝐋^𝐆(λ)$ is a cyclotomic Hecke algebra for to the group $N_W(Lwϕ,λ)/L$. The constituents of $R_𝐋^𝐆(λ)$ are called a `ζ`

-Harish-Chandra series. In the case of rational groups or cosets, corresponding to finite reductive groups, the conjugacy class of `Lwϕ`

depends only on the order `d`

of `ζ`

, so one also talks of `d`

-Harish-Chandra series. These series correspond to `ℓ`

-blocks where `l`

is a prime divisor of `Φ_d(q)`

which does not divide any other cyclotomic factor of the order of $𝐆^F$.

The functions `relative_degrees, regular_eigenvalues, eigenspace_projector, position_regular_class, split_levis, cuspidal`

in this module allow to explore these situations.

`Chevie.Eigenspaces.eigenspace_projector`

— Function`eigenspace_projector(WF,w,ζ::Root1=1)`

Let `WF`

be a reflection group or a reflection coset, let `w`

be an element of `WF`

and let `ζ`

be a root of unity. The function returns the unique `w`

-invariant projector on the `ζ`

-eigenspace of `w`

.

The eigenvalue `ζ`

can also be specified by giving an integer `d`

(which then specifies `ζ=E(d)`

) or a fraction `a//b`

which then specifies `ζ=E(b,a)`

. If omitted, `ζ`

is taken to be `1`

.

```
julia> W=coxgroup(:A,3)
A₃
julia> w=W(1:3...)
(1,12,3,2)(4,11,10,5)(6,9,8,7)
julia> p=eigenspace_projector(W,w,1//4)
3×3 Matrix{Cyc{Rational{Int64}}}:
(1+ζ₄)/4 ζ₄/2 (-1+ζ₄)/4
(1-ζ₄)/4 1//2 (1+ζ₄)/4
(-1-ζ₄)/4 -ζ₄/2 (1-ζ₄)/4
julia> GenLinearAlgebra.rank(p)
1
```

`Chevie.Eigenspaces.position_regular_class`

— Method`position_regular_class(WF,ζ::Root1=1)`

Let `WF`

be a reflection group or a reflection coset and `ζ`

be a root of unity such that some element of `WF`

has a non-trivial `ζ`

-eigenspace. The function returns the index of a conjugacy class of `WF`

whose `ζ`

-eigenspace is maximal (amongst all `ζ`

-eigenspaces of elements of `W`

). If not element of `WF`

has a non-trivial `ζ`

-eigenspace the function returns `nothing`

.

The eigenvalue `ζ`

can also be specified by giving an integer `d`

(which then specifies `ζ=E(d)`

) or a fraction `a//b`

which then specifies `ζ=E(b,a)`

. If omitted, `ζ`

is taken to be `1`

.

```
julia> W=coxgroup(:E,8)
E₈
julia> position_regular_class(W,30)
65
julia> W=complex_reflection_group(6)
G₆
julia> L=twistings(W,[2])[4]
G₆₍₂₎=G₃‚₁‚₁[ζ₄]Φ′₄
julia> position_regular_class(L,7//12)
2
```

`Chevie.Eigenspaces.regular_eigenvalues`

— Method`regular_eigenvalues(W)`

Let `W`

be a reflection group or a reflection coset. A root of unity `ζ`

is a *regular eigenvalue* for `W`

if some element of `W`

has a `ζ`

-eigenvector which lies outside of the reflecting hyperplanes. The function returns the list of regular eigenvalues for `W`

.

```
julia> regular_eigenvalues(coxgroup(:G,2))
6-element Vector{Root1}:
1
-1
ζ₃
ζ₃²
ζ₆
ζ₆⁵
julia> W=complex_reflection_group(6)
G₆
julia> L=twistings(W,[2])[4]
G₆₍₂₎=G₃‚₁‚₁[ζ₄]Φ′₄
julia> regular_eigenvalues(L)
3-element Vector{Root1}:
ζ₄
ζ₁₂⁷
ζ₁₂¹¹
```

`Chevie.Eigenspaces.relative_degrees`

— Method`relative_degrees(WF,ζ::Root1=1)`

Let `WF`

be a reflection group or a reflection coset and `ζ`

be a root of unity. Then if $V_ζ$ is the `ζ`

-eigenspace of some element of `WF`

, and is of maximal dimension among such `ζ`

-eigenspaces (and if `WF`

is a coset `W`

is the group of `WF`

) then $N_W(V_ζ)/C_W(V_ζ)$ is a reflection group in its action on $V_ζ$. The function `relative_degrees`

returns the reflection degrees of this complex reflection group, which are a subset of those of `W`

. These degrees are computed by an invariant-theoretic formula: if `(d₁,ε₁),…,(dₙ,εₙ)`

are the generalized degrees of `WF`

(see `degrees`

) they are the `dᵢ`

such that `ζ^{dᵢ}=εᵢ`

.

The eigenvalue `ζ`

can also be specified by giving an integer `d`

(which then specifies `ζ=E(d)`

) or a fraction `a//b`

which then specifies `ζ=E(b,a)`

. If omitted, `ζ`

is taken to be `1`

.

```
julia> W=coxgroup(:E,8)
E₈
julia> relative_degrees(W,4) # the degrees of G₃₂
4-element Vector{Int64}:
8
12
20
24
```

`Chevie.Eigenspaces.relative_root`

— Method`relative_root(W,L,i)`

return 'action' of refls(W,i)∉ L on X(Z_L) a namedtuple with root, coroot, eigenvalue, index=i and parentMap

`Chevie.Eigenspaces.split_levis`

— Function`split_levis(WF,ζ::Root1=1[,ad])`

Let `WF`

be a reflection group or a reflection coset. If `W`

is a reflection group it is treated as the trivial coset 'Spets(W)'. A *Levi* is a subcoset of the form `W₁F₁`

where `W₁`

is a *parabolic subgroup* of `W`

, that is the centralizer of some subspace of `V`

, and `F₁∈ WF`

.

Let `ζ`

be a root of unity. `split_levis`

returns a list of representatives of conjugacy classes of `ζ`

-split Levis of `W`

. A `ζ`

-split Levi is a subcoset of `WF`

formed of all the elements which act by `ζ`

on a given subspace `V_ζ`

. If the additional argument `ad`

is given, it returns only those subcosets such that the common `ζ`

-eigenspace of their elements is of dimension `ad`

. These notions make sense and thus are implemented for any complex reflection group.

In terms of algebraic groups, an `F`

-stable Levi subgroup of the reductive group `𝐆`

is `ζ`

-split if and only if it is the centralizer of the `Φ`

-part of its center, where `Φ`

is a cyclotomic polynomial with `ζ`

as a root. When `ζ=1`

, we get the notion of a *split* Levi, which is the same as a Levi sugroup of an `F`

-stable parabolic subgroup of `𝐆`

.

`ζ`

can also be specified by giving an integer `d`

(which then specifies `ζ=E(d)`

) or a fraction `a//b`

which then specifies `ζ=E(b,a)`

. If omitted, `ζ`

is taken to be `1`

.

```
julia> W=coxgroup(:A,3)
A₃
julia> split_levis(W,4)
2-element Vector{Spets{FiniteCoxeterSubGroup{Perm{Int16},Int64}}}:
A₃
A₃₍₎=Φ₂Φ₄
julia> W=spets(coxgroup(:D,4),Perm(1,2,4))
³D₄
julia> split_levis(W,3)
3-element Vector{Spets{FiniteCoxeterSubGroup{Perm{Int16},Int64}}}:
³D₄
³D₄₍₁₃₎=A₂Φ₃
³D₄₍₎=Φ₃²
julia> W=coxgroup(:E,8)
E₈
julia> split_levis(W,4,2)
3-element Vector{Spets{FiniteCoxeterSubGroup{Perm{Int16},Int64}}}:
E₈₍₃₂₄₅₎=D₄₍₁₃₂₄₎Φ₄²
E₈₍₅₇₂₃₎=(A₁A₁)×(A₁A₁)Φ₄²
E₈₍₃₁₅₆₎=²(A₂A₂)₍₁₄₂₃₎Φ₄²
julia> split_levis(complex_reflection_group(5))
4-element Vector{Spets{PRSG{Cyc{Rational{Int64}}, Int16}}}:
G₅
G₅₍₁₎=G₃‚₁‚₁Φ₁
G₅₍₂₎=G₃‚₁‚₁Φ₁
G₅₍₎=Φ₁²
```

`Chevie.Weyl.standard_parabolic`

— Method`standard_parabolic(W::PermRootGroup, H)`

Let `H`

be a reflection subgroup of `W`

. Returns an element `w∈ W`

such that `H^w`

is a standard parabolic subgroup of `W`

(or nothing if `H`

is not parabolic or not conjugate to a standard parabolic).

`Chevie.Sscoset`

— Module#Quasi-Semisimple elements of non-connected reductive groups

We also use Coxeter cosets to represented non-connected reductive groups of the form `𝐆 ⋊ σ`

where `𝐆`

is a connected reductive group and `σ`

is an algebraic automorphism of `𝐆`

; more specifically to represent the coset `𝐆 .σ`

. We may always choose `σ∈ 𝐆 ⋅σ`

*quasi-semisimple*, which means that `σ`

preserves a pair `𝐓 ⊂ 𝐁`

of a maximal torus and a Borel subgroup of `𝐆`

, and further *quasi-central*, which means that the Weyl group of `C_𝐆 (σ)`

is `W^σ`

. Then `σ`

defines an automorphism `F_0`

of the root datum `(X(𝐓 ), Φ, Y(𝐓 ), Φ^∨)`

, thus a Coxeter coset. We refer to Digne-Michel2018 for details.

We have extended the functions for semi-simple elements to work with quasi-semisimple elements `tσ∈ 𝐓 ⋅σ`

. Here, as in Digne-Michel2018, `σ`

is a quasi-central automorphism uniquely defined by a diagram automorphism of `(W,S)`

, taking `σ`

symplectic in type `A₂ₙ`

.

Here are some examples:

```
julia> WF=rootdatum(:u,6)
u₆
```

We can see `WF`

as the coset `GL₆⋅σ`

where `σ`

is the composed of transpose, inverse and the longest element of `W`

.

```
julia> l=quasi_isolated_reps(WF)
4-element Vector{SemisimpleElement{Root1}}:
<1,1,1,1,1,1>
<ζ₄,ζ₄,ζ₄,ζ₄³,ζ₄³,ζ₄³>
<ζ₄,ζ₄,1,1,ζ₄³,ζ₄³>
<ζ₄,1,1,1,1,ζ₄³>
```

we define an element `tσ∈ 𝐓 ⋅σ`

to be quasi-isolated if the Weyl group of `C_𝐆 (tσ)`

is not in any proper parabolic subgroup of `W^σ`

. This generalizes the definition for connected groups. The above shows the elements `t`

where `tσ`

runs over representatives of quasi-isolated quasi-semisimple classes of `𝐆 ⋅σ`

. The given representatives have been chosen `σ`

-stable.

```
julia> centralizer.(Ref(WF),l)
4-element Vector{ExtendedCox{Perm{Int16}, FiniteCoxeterGroup{Perm{Int16},Rational{Int64}}}}:
C₃₍₃₂₁₎
²A₃₍₃₁₂₎
(A₁A₁)₍₁₃₎×A₁₍₂₎
B₂Φ₁
```

in the above example, the groups `C_𝐆 (tσ)`

are computed and displayed as extended Coxeter groups (following the same convention as for centralisers in connected reductive groups).

We define an element `tσ∈ 𝐓 ⋅σ`

to be isolated if the Weyl group of `C_𝐆 (tσ)⁰`

is not in any proper parabolic subgroup of `W^σ`

. This generalizes the definition for connected groups.

```
julia> isisolated.(Ref(WF),l)
4-element BitVector:
1
1
1
0
```

`Chevie.Semisimple.isisolated`

— Method`isisolated(WF::Spets,t::SemisimpleElement{Root1})`

`WF`

should be a Coxeter coset representing an algebraic coset `𝐆 ⋅σ`

, where `𝐆`

is a connected reductive group (represented by `W=Group(WF)`

), and `σ`

is a quasi-central automorphism of `𝐆`

defined by `WF`

. The element `t`

should be a semisimple element of `𝐆`

. The function returns a boolean describing whether `tσ`

is isolated, that is whether the Weyl group of `C_𝐆 (tσ)⁰`

is not in any proper parabolic subgroup of `W^σ`

.

```
julia> WF=rootdatum(:u,6)
u₆
julia> l=quasi_isolated_reps(WF)
4-element Vector{SemisimpleElement{Root1}}:
<1,1,1,1,1,1>
<ζ₄,ζ₄,ζ₄,ζ₄³,ζ₄³,ζ₄³>
<ζ₄,ζ₄,1,1,ζ₄³,ζ₄³>
<ζ₄,1,1,1,1,ζ₄³>
julia> isisolated.(Ref(WF),l)
4-element BitVector:
1
1
1
0
```

`Chevie.Semisimple.quasi_isolated_reps`

— Function`quasi_isolated_reps(WF::Spets,p=0)`

`WF`

should be a Coxeter coset representing an algebraic coset `𝐆 ⋅σ`

, where `𝐆`

is a connected reductive group (represented by `W=Group(WF)`

), and `σ`

is a quasi-central automorphism of `𝐆`

defined by `WF`

. The function returns a list of semisimple elements of `𝐆`

such that `tσ`

, when `t`

runs over this list, are representatives of the conjugacy classes of quasi-isolated quasisemisimple elements of `𝐆 ⋅σ`

(an element `tσ∈ 𝐓 ⋅σ`

is quasi-isolated if the Weyl group of `C_𝐆 (tσ)`

is not in any proper parabolic subgroup of `W^σ`

). If a second argument `p`

is given, it lists only those representatives which exist in characteristic `p`

.

```
julia> WF=rootdatum("2E6sc")
²E₆sc
julia> quasi_isolated_reps(WF)
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,1>
julia> quasi_isolated_reps(WF,2)
2-element Vector{SemisimpleElement{Root1}}:
<1,1,1,1,1,1>
<1,ζ₃²,1,ζ₃,1,1>
julia> quasi_isolated_reps(WF,3)
4-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>
```

`PermGroups.Groups.centralizer`

— Method`centralizer(WF::Spets,t::SemisimpleElement{Root1})`

`WF`

should be a Coxeter coset representing an algebraic coset `𝐆 ⋅σ`

, where `𝐆`

is a connected reductive group (represented by 'W:=Group(WF)'), and `σ`

is a quasi-central automorphism of `𝐆`

defined by `WF`

. The element `t`

should be a semisimple element of `𝐆`

. The function returns an extended reflection group describing `C_𝐆 (tσ)`

, with the reflection group part representing `C_𝐆 ⁰(tσ)`

, and the diagram automorphism part being those induced by `C_𝐆 (tσ)/C_𝐆 (tσ)⁰`

on `C_𝐆 (tσ)⁰`

.

```
julia> WF=rootdatum(:u,6)
u₆
julia> s=ss(Group(WF),[1//4,0,0,0,0,3//4])
SemisimpleElement{Root1}: <ζ₄,1,1,1,1,ζ₄³>
julia> centralizer(WF,s)
B₂Φ₁
julia> centralizer(WF,one(s))
C₃₍₃₂₁₎
```

`Chevie.Symbols`

— ModuleThe combinatorial objects in this module are *partitions*, *β-sets* and *symbols*.

A partition is a non-increasing list of positive integers `p₁≥p₂≥…pₙ≥0`

, represented as a `Vector{Int}`

, which is *normalized* if it has no trailing zeroes.

A *β-set* is a strictly increasing `Vector`

of nonnegative integers, up to *shift*, the equivalence relation generated by the *elementary shifts* `[b₁,…,bₙ]∼[0,1+b₁,…,1+bₙ]`

. An equivalence class has exactly one member which does not contain `0`

: it is called a normalized β-set.

To a normalized partition `p₁≥p₂≥…pₙ>0`

is associated a β-set, whose normalized representative is `pₙ,pₙ₋₁+1,…,p₁+n-1`

. Conversely, to each β-set `b₁<b₂<…<bₙ`

is associated the partition `bₙ-n+1≥…≥b₂-1≥b₁`

, which may have some trailing zeros if starting from a non-normalized representative.

As a generalisation of `β`

-sets, Lusztig1977 has introduced `2`

-symbols and more general `e`

-symbols were introduced in Malle1995. An `e`

-symbol is a vector `S=[S₁,…,Sₑ]`

of β-sets, taken modulo the equivalence relation generated by the simultaneous elementary shift of all β-sets, and by cyclic permutations of `S`

; in the particular case where `e=2`

, `S`

is thus an unordered pair of β-sets. `S`

is a *normalized symbol* if `0`

is not in the intersection of the `Sᵢ`

; equivalent normalized symbols are equivalent by cyclic permutation. The *content* of `S`

is `mod(c,e)`

where `c=sum(length.(S))`

; it is an invariant of the symbol, as well as the *rank*, defined for an `e`

-symbol as `sum(sum,S)-div((c-1)*(c-e+1),2*e)`

. Invariant by shift but not cyclic permutation is the *shape* `s.-minimum(s)`

where `s=length.(S)`

.

When `e=2`

we choose representatives of the symbols `[S₁,S₂]`

such that `length(S₁)≥length(S₂)`

, so the shape is `[d,0]`

for some `d≥0`

called the *defect* of the symbol; the content is equal to `mod(d,2)`

. For symbols `[S₁,S₂]`

with `length(S₁)==length(S₂)`

we choose representatives such that `P₁≤P₂`

lexicographically where `P₁,P₂`

are the partitions associated to `S₁,S₂`

.

Partitions and pairs of partitions parametrize characters of the Weyl groups of classical types, and tuples of partitions parametrize characters of imprimitive complex reflection groups. 2-Symbols parametrize unipotent characters of classical Chevalley groups, and more general `e`

-symbols parametrize unipotent characters of Spetses associated to spetsial imprimitive complex reflection groups. The rank of a symbol is equal to the semi-simple rank of the corresponding Chevalley group or Spets.

Symbols of rank `n`

and defect `0`

parametrize characters of the Weyl group of type `Dₙ`

, and symbols of rank `n`

and defect divisible by `4`

parameterize unipotent characters of split orthogonal groups of dimension `2n`

. Symbols of rank `n`

and defect`≡2 (mod 4)`

parameterize unipotent characters of non-split orthogonal groups of dimension `2n`

. Symbols of rank `n`

and defect `1`

parametrize characters of the Weyl group of type `Bₙ`

, and symbols of rank `n`

and odd defect parametrize unipotent characters of symplectic groups of dimension `2n`

or orthogonal groups of dimension `2n+1`

.

`e`

-symbols of rank `n`

and content `1`

parameterize unipotent characters of `G(e,1,n)`

. Those of content `0`

parameterize unipotent characters of `G(e,e,n)`

. The principal series (in bijection with characters of the reflection group) is parametrized by symbols of shape `[1,0,…,0]`

for `G(e,1,n)`

and `[0,…,0]`

for `G(e,e,n)`

.

Finally, in this module we also provides a function `XSP`

which returns the "symbols" (pairs of lists of increasing positive integers satisfying some conditions) $X̃^{ρ-s,s}_{n,d}$ defined by Lusztig and Spaltenstein which parametrize local systems on unipotent classes for classical reductive groups.

`Chevie.Symbols.EnnolaSymbol`

— Method`EnnolaSymbol(S)`

Ennola of `e`

-symbol `S`

(of content `1`

or `0`

) The order of Ennola (order of center of reflection group) is computed automatically: it is `e`

for content `1`

and `gcd(e,rank(S))`

for content `0`

.

`Chevie.Symbols.XSP`

— Function`XSP(ρ,s,n,even=false)`

returns the union of the Lusztig-Spaltenstein 1985 $X̃^{ρ-s,s}_{n,d}$ for all `d`

even when `even=true`

, all `d`

odd otherwise; these symbols parametrize local systems on unipotent conjugacy classes for classical groups. In Lusztig2004, 13.2 the notation is ${}^ρ X^s_{n,d}$. The result is a list of lists, each one corresponding to a similarity class (which correspond to a given conjugacy class for the support). If `s==0`

, only positive defects are considered.

`XSP(2,1,n)`

gives L-S symbols for Sp₂ₙ`XSP(4,2,n)`

gives L-S symbols for Sp₂ₙ in char.2`XSP(2,0,n)`

gives L-S symbols for SO₂ₙ₊₁ [defect odd]`XSP(2,0,n,true)`

gives L-S symbols for SO₂ₙ [defect even]`XSP(4,0,n,true)`

gives L-S symbols for SO₂ₙ in char 2

each item is a `NamedTuple`

giving some information on the local system. It has fields

`symbol`

the Lusztig-Spaltenstein symbol`dimBu`

for the support`u`

of the local system`Au`

describes the character of`A(u)`

for the local system as a list:`true`

->sgn,`false`

->Id`sp`

parameter (double partition) of the generalized Springer correspondent (a character of the relative Weyl group)

`Chevie.Symbols.defectsymbol`

— Method`defectsymbol(s)'

For an `e`

-symbol `[S₁,S₂,…,Sₑ]`

returns `length(S₁)-length(S₂)`

.

```
julia> defectsymbol([[1,5,6],[1,2]])
1
```

`Chevie.Symbols.defshape`

— Method`defshape(s::Vector{Int})`

Malle-defect of symbols of shape s. This is an invariant by shift but not under cyclic permutations.

`Chevie.Symbols.degree_fegsymbol`

— Method`degree_fegsymbol(s)`

the degree of the fake degree of the character parameterized by the symbol `s`

.

```
julia> degree_fegsymbol([[1,5,6],[1,2]])
88
```

`Chevie.Symbols.degree_gendeg_symbol`

— Method`degree_gendeg_symbol(S)`

the degree of the generic degree of the unipotent character parameterized by the symbol `S`

.

```
julia> degree_gendeg_symbol([[1,5,6],[1,2]])
91
```

`Chevie.Symbols.fegsymbol`

— Function`fegsymbol(S,p=0)`

returns as a `CycPol`

the fake degree of the character of symbol `S`

.

```
julia> fegsymbol([[1,5,6],[1,2]])
q¹⁶Φ₅Φ₇Φ₈Φ₉Φ₁₀Φ₁₁Φ₁₄Φ₁₆Φ₁₈Φ₂₀Φ₂₂
```

If `S`

is an `e`

-symbol, when given a second argument `p`

dividing `e`

, and a first argument of shape `(0,…,0)`

representing the restriction of the character to `G(e,e,r)`

, works for the coset `G(e,e,r).s₁ᵖ`

.

`Chevie.Symbols.gendeg_symbol`

— Method`gendeg_symbol(S)`

returns as a `CycPol`

the generic degree of the unipotent character parameterized by `S`

.

```
julia> gendeg_symbol([[1,2],[1,5,6]])
q¹³Φ₅Φ₆Φ₇Φ₈²Φ₉Φ₁₀Φ₁₁Φ₁₄Φ₁₆Φ₁₈Φ₂₀Φ₂₂/2
```

for an `e`

-symbol of rank `r`

, content `c`

and Malle-defect `d`

the Spets is

- G(e,1,r) (c==1, d==0)
- G(e,e,r) (c==0, d==0)
- ²G(e,e,r) (c==0, d==1) (e,r even. This includes ²Dₙ, ²B₂, ²G₂)

`Chevie.Symbols.lesssymbols`

— Method`lesssymbols(x,y)`

`<`

for symbols

A symbol is smaller than another if the shape is lexicographically smaller, or the shape is the same and the the symbol is lexicographically bigger

`Chevie.Symbols.partβ`

— Method`partβ(β)`

partition defined by β-set `β`

```
julia> partβ([0,4,5])
2-element Vector{Int64}:
3
3
```

`Chevie.Symbols.ranksymbol`

— Method`ranksymbol(S)`

rank of symbol `S`

.

```
julia> ranksymbol([[1,5,6],[1,2]])
11
```

`Chevie.Symbols.shapesSymbols`

— Function`shapesSymbols(e,r,c=1,def=0)`

possible shapes for `e`

-symbols of rank `r`

, content `c`

, Malle-defect `def`

"

`Chevie.Symbols.shiftβ`

— Function`shiftβ( β, n)`

shift the β-set `β`

by `n`

```
julia> shiftβ([2,3],2)
4-element Vector{Int64}:
0
1
4
5
julia> shiftβ([0,1,4,5],-2)
2-element Vector{Int64}:
2
3
```

`Chevie.Symbols.string_partition_tuple`

— Function`string_partition_tuple(tuple)`

converts the partition tuple `tuple`

to a string where the partitions are separated by a dot.

```
julia> d=partition_tuples(3,2)
10-element Vector{Vector{Vector{Int64}}}:
[[1, 1, 1], []]
[[1, 1], [1]]
[[1], [1, 1]]
[[], [1, 1, 1]]
[[2, 1], []]
[[1], [2]]
[[2], [1]]
[[], [2, 1]]
[[3], []]
[[], [3]]
julia> string_partition_tuple.(d)
10-element Vector{String}:
"111."
"11.1"
"1.11"
".111"
"21."
"1.2"
"2.1"
".21"
"3."
".3"
```

`Chevie.Symbols.stringsymbol`

— Method`stringsymbol(io=stdout,S)`

string for symbol `S`

`Chevie.Symbols.symbol_partition_tuple`

— Method`symbol_partition_tuple(p, s)`

symbol of shape `s`

for partition tuple `p`

.

In the general case, `s`

is a `Vector{Int}`

of same length as `p`

and the `i`

-th element of the result is the β-set for `pᵢ`

shifted to be of length `sᵢ`

(the minimal integer which makes this possible is added to `s`

).

When `s`

is a positive integer it is interpreted as `[s,0,0,…]`

and a negative integer is interpreted as `[0,-s,-s,…]`

so when `p`

is a double partition one gets the symbol of defect `s`

associated to `p`

; as other uses the unipotent symbol for a character of the principal series of `G(e,1,r)`

parameterized by an `e`

-tuple `p`

of partitions is `symbol_partition_tuple(p,1)`

and for `G(e,e,r)`

the similar computation is `symbol_partition_tuple(p,0)`

(the function handles coded periodic `p`

for `G(e,e,r)`

).

```
julia> symbol_partition_tuple([[2,1],[1]],1)
2-element Vector{Vector{Int64}}:
[1, 3]
[1]
julia> symbol_partition_tuple([[2,1],[1]],0)
2-element Vector{Vector{Int64}}:
[1, 3]
[0, 2]
julia> symbol_partition_tuple([[2,1],[1]],-1)
2-element Vector{Vector{Int64}}:
[1, 3]
[0, 1, 3]
```

`Chevie.Symbols.symbols`

— Function`symbols(e,r,c=1,def=0)`

The list of `e`

-symbols of rank `r`

, content `c`

and Malle-defect `def`

An `e`

-symbol is a symbol of length `e`

. The content of an `e`

-symbol `S`

is `sum(length,S)%e`

. The symbols for unipotent characters of:

`G(d,1,r)`

are`symbols(d,r)`

`G(e,e,r)`

are`symbols(e,r,0)`

.`G(e,e,r).s₁ᵗ`

where`s₁`

is the first generator of`G(e,1,r)`

and`t|e`

are`symbols(e,r,0,t)`

```
julia> stringsymbol.(symbols(3,2)) # unipotent characters of G(3,1,2)
14-element Vector{String}:
"(12,0,0)"
"(02,1,0)"
"(02,0,1)"
"(012,12,01)"
"(01,1,1)"
"(012,01,12)"
"(2,,)"
"(01,2,0)"
"(01,0,2)"
"(1,012,012)"
"(,02,01)"
"(,01,02)"
"(0,,012)"
"(0,012,)"
julia> stringsymbol.(symbols(3,3,0)) # unipotent characters of G(3,3,3)
12-element Vector{String}:
"(1+)"
"(1E(3))"
"(1E(3,2))"
"(01,12,02)"
"(01,02,12)"
"(012,012,123)"
"(0,1,2)"
"(0,2,1)"
"(01,01,13)"
"(0,0,3)"
"(012,,)"
"(012,012,)"
```

`Chevie.Symbols.symbolsshape`

— Method`symbolsshape(r,s)`

symbols of rank `r`

and shape `s`

`Chevie.Symbols.valuation_fegsymbol`

— Method`valuation_fegsymbol(s)`

the valuation of the fake degree of the character parameterized by the symbol `s`

.

```
julia> valuation_fegsymbol([[1,5,6],[1,2]])
16
```

`Chevie.Symbols.valuation_gendeg_symbol`

— Method`valuation_gendeg_symbol(S)`

the valuation of the generic degree of the unipotent character parameterized by the symbol `S`

.

```
julia> valuation_gendeg_symbol([[1,5,6],[1,2]])
13
```

`Chevie.Symbols.βset`

— Function`βset(p)`

normalized β-set of partition `p`

```
julia> βset([3,3,1])
3-element Vector{Int64}:
1
4
5
```

`Chevie.Util`

— ModuleThis module contains various utility functions used in the rest of the code. Maybe some of them exist in some Julia module I am not aware of; please tell me.

`Chevie.Util.cart2lin`

— Method`cart2lin([l₁,…,lₙ],[i₁,…,iₙ])`

is GAP3 PositionCartesian returns findfirst(==([i1,…,iₙ]),cartesian(1:l₁,…,1:lₙ)) very fast with 2 Tuple arguments

`Chevie.Util.cartesian`

— Method`cartesian(a::AbstractVector...)`

A variation on ``Iterators.product`

which gives the same result as GAP's `Cartesian`

. `reverse`

is done twice to get the same order as GAP.

`Chevie.Util.cut`

— Method`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]
```

`Chevie.Util.lin2cart`

— Method`lin2cart([l],i)`

is GAP3 CartesianAt returns cartesian(map(j->1:j,l))[i]

`Chevie.Util.showtable`

— Method`showtable(io, table::AbstractMatrix; options )`

General routine to format a table. The following options can be passed as properties of the `io`

or as keywords.

`row_labels`

labels for rows (default`axes(table,1)`

)`rows_label`

label for first column of row labels (default none)`col_labels`

labels for other columns (default none)`rowseps`

line numbers after which to put a separator`rows`

show only these rows (default all rows)`cols`

show only these columns (default all columns)`TeX`

give LaTeX output (useful in Jupyter or Pluto)`column_repartition`

display in vertical pieces of sizes indicated (useful for`TeX`

: otherwise take in account`displaysize(io,2)`

)- align alignment of columns (in "lcr"; default 'c':centered)
- dotzero replace '0' by '.' in table (default false)

```
julia> m=[1 2 3 4;5 6 7 8;9 1 2 3;4 5 6 7];
julia> showtable(stdout,m)
1│1 2 3 4
2│5 6 7 8
3│9 1 2 3
4│4 5 6 7
julia> labels=["x","y","z","t"];
julia> showtable(stdout,m;cols=2:4,col_labels=labels,rowseps=[0,2,4])
│y z t
─┼──────
1│2 3 4
2│6 7 8
─┼──────
3│1 2 3
4│5 6 7
─┴──────
```

`Chevie.Util.unicodeTeX`

— Methodstrip TeX formatting from a string, using unicode characters to approximate

`Chevie.Util.@forward`

— Macro`@forward T.f f1,f2,...`

is a macro which delegates definitions. The above generates

```
f1(a::T,args...)=f1(a.f,args...)
f2(a::T,args...)=f2(a.f,args...)
...
```

`Chevie.dSeries`

— Module`d`

-Harish-Chandra series describe unipotent `l`

-blocks of a finite reductive group $𝐆(𝔽_q)$ for $l|Φ_d(q)$ (at least, when `l`

is not too small which means mostly not a bad prime for `𝐆`

). Some of the facts stated below are still partly conjectural, we do not try to distinguish precisely what has been established and what is still conjectural.

If `(𝐋,λ)`

is a `d`

-cuspidal pair then the constituents of the Lusztig induced $R_𝐋^𝐆(λ)$ are called a `d`

-Harish-Chandra series; they form the unipotent part of an `l`

-block of $𝐆^F$. It is conjectured (and proven in some cases) that the $𝐆^F$-endomorphism algebra of the `l`

-adic cohomology of the variety `𝐗`

which defines the Lusztig induction is a `d`

-cyclotomic Hecke algebra $H_𝐆(𝐋,λ)$ for the group $W_𝐆(𝐋,λ):=N_𝐆(𝐋,λ)/𝐋$, which is a complex reflection group –- here `d`

-cyclotomic means that the parameters of $H_𝐆(𝐋,λ)$ are monomials in `q`

and that $H_𝐆(𝐋,λ)$ specializes to the algebra of $W_𝐆(𝐋,λ)$ for $q↦ζ_d$.

It follows that the decomposition of the Lusztig induction is of the form $R_𝐋^𝐆(λ)=∑_{ϕ∈Irr(W_𝐆(𝐋,λ))}(-1)^{nᵩ} ϕ(1)γᵩ,$ where `γᵩ`

is a unipotent character of `𝐆^F`

attached to `ϕ`

and where `nᵩ`

is the degree $H^{nᵩ}_c(𝐗)$ where `γᵩ`

occurss; and further for any `ϕ`

we have $R_𝐋^𝐆(λ)(1)= (-1)^{nᵩ} γᵩ(1)Sᵩ$ where `Sᵩ`

is the Schur element of the character of $H_𝐆(𝐋,λ)$ which deforms to `ϕ`

. The function |Series| allows to explore a `d`

-Harish-Chandra series.

```
julia> W=rootdatum("3D4")
³D₄
julia> l=cuspidal_data(W,3)
2-element Vector{@NamedTuple{levi::Spets{FiniteCoxeterSubGroup{Perm{Int16},Int64}}, cuspidal::Int64, d::Root1}}:
(levi = ³D₄, cuspidal = 8, d = ζ₃)
(levi = ³D₄₍₎=Φ₃², cuspidal = 1, d = ζ₃)
julia> Series(W,l[2]...)
ζ₃-series R^³D₄_{³D₄₍₎=Φ₃²}(λ==Id) H_G(L,λ)==hecke(G₄,Vector{Mvp{Cyc{Int64}, Int64}}[[ζ₃q², ζ₃, ζ₃q]])
│ γᵩ φ ε family #
─┼────────────────────────
1│ φ₁‚₀ φ₁‚₀ 1 1
2│ φ₁‚₆ φ₁‚₄ 1 2
3│ φ₂‚₂ φ₁‚₈ -1 5
6│ φ″₁‚₃ φ₂‚₅ 1 4
5│ φ′₁‚₃ φ₂‚₃ -1 3
7│ φ₂‚₁ φ₂‚₁ -1 5
4│³D₄[1] φ₃‚₂ 1 5
```

Above we explore the 3-series corresponding to $R_𝐓^𝐆(Id)$ where `𝐆`

is the triality group and `𝐓`

is the torus of type `(q²+q+1)²`

. The group $W_𝐆(𝐓)$ is the complex reflection group `G₄`

. The displays shows in the column 'γᵩ' the name of the unipotent characters constituents of $R_𝐓^𝐆(Id)$, and in the first column the number of these characters in the list of unipotent characters. In the column 'φ' the name of the character of $W_𝐆(𝐓)$ corresponding to the unipotent character `γᵩ`

is shown; in the column 'ε' we show the sign $(-1)^{nᵩ}$. Finally in the last column we show in which family of unipotent characters is `γᵩ`

.

The theory of `d`

-Harish-Chandra series can be generalized to spetsial complex reflection groups using some axioms. We show below an example.

```
julia> W=complex_reflection_group(4)
G₄
julia> l=cuspidal_data(W,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 = ζ₃)
julia> Series(W,l[5]...)
ζ₃-series R^G₄_{G₄₍₎=Φ₁Φ′₃}(λ==Id) W_G(L,λ)==Z₆
│ γᵩ φ(mod 3) ε parameter family #
─┼─────────────────────────────────────
1│ φ₁‚₀ 1 1 ζ₃q² 1
5│ φ₂‚₃ ζ₆ 1 -ζ₃q 2
2│ φ₁‚₄ ζ₃ -1 ζ₃ 4
8│ Z₃:2 -1 -1 -ζ₃²q 2
9│Z₃:11 ζ₃² -1 ζ₃² 4
4│ φ₂‚₅ ζ₆⁵ -1 -ζ₃ 4
```

Above we explore the `3`

-series corresponding to the trivial character of the torus of type `(q-1)(q-ζ₃)`

. For cyclic groups $W_𝐆(𝐋,λ)$ we display the parameters in the table since they are associated to characters of $W_𝐆(𝐋,λ)$. Finally the mention '(mod 3)' which appears in the 'φ' column means that in this case the axioms leave an ambiguity in the correspondence between unipotent characters `γᵩ`

and characters `ϕ`

(as well as with parameters): the correspondence is known only up to a translation by 3 (in this case, the same as a global multiplication of all `ϕ`

by `-1`

).

Finally, we should note that if the reflection group or coset `W`

is not defined over the integers, what counts is not cyclotomic polynomials but factors of them over the field of definition of `W`

. In this case, one should not give as argument an integer `d`

representing $ζ_d$ but specify a root of unity. For instance, in the above case we get a different answer with:

```
julia> cuspidal_data(W,E(3,2))
5-element Vector{@NamedTuple{levi::Spets{PRSG{Cyc{Rational{Int64}}, Int16}}, cuspidal::Int64, d::Root1}}:
(levi = G₄, cuspidal = 2, d = ζ₃²)
(levi = G₄, cuspidal = 5, d = ζ₃²)
(levi = G₄, cuspidal = 7, d = ζ₃²)
(levi = G₄, cuspidal = 10, d = ζ₃²)
(levi = G₄₍₎=Φ₁Φ″₃, cuspidal = 1, d = ζ₃²)
```

`Chevie.dSeries.Series`

— Method`Series(W, L, cuspidal, d)`

If the reflection coset or group `W`

corresponds to the algebraic group `𝐆`

and `cuspidal`

to the `d`

-cuspidal unipotent character `λ`

of `𝐋`

, constructs the `d`

-series corresponding to $R_𝐋^𝐆(λ)$. The result `s`

it is a record with the following fields and functions:

`s.spets`

: the reflection group or coset `W`

.

`s.levi`

: the subcoset `L`

.

`s.cuspidal`

: the index of `λ`

in `UnipotentCharacters(L)`

.

`s.d`

: the value of `d`

(a `Root1`

).

`relative_group(s)`

: the group $W_𝐆(𝐋,λ)$.

`dSeries.RLG(s)`

: the `UnipotentCharacter`

given by $R_𝐋^𝐆(λ)$.

`dSeries.eps(s)`

: for each character `φ`

of `relative_group(s)`

the sign $(-1)^{n_φ}$ in the cohomology of the variety defining `RLG(s)`

of the corresponding constituent `γᵩ`

of `RLG(s)`

.

`degree(s)`

: the generic degree of `RLG(s)`

, as a `CycPol`

.

`charnumbers(s)`

: the indices in `UnipotentCharacters(W)`

of the constituents of `RLG(s)`

.

`hecke(s)`

: the hecke algebra $H_𝐆(𝐋,λ)$.

The function `Series`

has another form:

`Series(<W> [,<d> [,<ad>]];k...)`

where it returns a vector of `Series`

corresponding to the cuspidal data described by the arguments and the keywords (see the help for `cuspidal_data`

).

```
julia> W=complex_reflection_group(4)
G₄
julia> Series(W,3;proper=true)
1-element Vector{Series}:
ζ₃-series R^G₄_{G₄₍₎=Φ₁Φ′₃}(λ==Id) W_G(L,λ)==Z₆
julia> s=Series(W,3,1)[1]
ζ₃-series R^G₄_{G₄₍₎=Φ₁Φ′₃}(λ==Id) W_G(L,λ)==Z₆
│ γᵩ φ(mod 3) ε parameter family #
─┼─────────────────────────────────────
1│ φ₁‚₀ 1 1 ζ₃q² 1
5│ φ₂‚₃ ζ₆ 1 -ζ₃q 2
2│ φ₁‚₄ ζ₃ -1 ζ₃ 4
8│ Z₃:2 -1 -1 -ζ₃²q 2
9│Z₃:11 ζ₃² -1 ζ₃² 4
4│ φ₂‚₅ ζ₆⁵ -1 -ζ₃ 4
julia> s.spets
G₄
julia> s.levi
G₄₍₎=Φ₁Φ′₃
julia> s.cuspidal
1
julia> s.d
Root1: ζ₃
julia> hecke(s)
hecke(G₆‚₁‚₁,Vector{Mvp{Cyc{Int64}, Int64}}[[ζ₃q², -ζ₃q, ζ₃, -ζ₃²q, ζ₃², -ζ₃]])
julia> degree(s)
ζ₃Φ₁Φ₂²Φ″₃Φ₄Φ₆
julia> dSeries.RLG(s)
[G₄]:<φ₁‚₀>-<φ₁‚₄>-<φ₂‚₅>+<φ₂‚₃>-<Z₃:2>-<Z₃:11>
julia> charnumbers(s)
6-element Vector{Int64}:
1
5
2
8
9
4
julia> dSeries.eps(s)
6-element Vector{Int64}:
1
1
-1
-1
-1
-1
julia> relative_group(s)
G₆‚₁‚₁
```

julia-repl

`Chevie.dSeries.FitParameter`

— Method`FitParameter(sch,m)`

given: sch: schur elements for H(ℤ/e) given as CycPols m: a list of length e of Rationals, exponents of params

finds all permutations σ of 1:e such that the parameters pₖ=E(e,σₖ-1)q^mₖ gives sch by the formula schᵢ=∏_{j≠i}(1-pᵢ/pⱼ). Since multiplying the pₖ by a scalar leaves invariant the sch, σ is known only modulo a translation.

The result is a list of pairs [v1,v2] telling that globally σ(v1)=v2, where the v1 are sort(collectby(sch,eachindex(sch)),by=minimum)

`Chevie.dSeries.ennola`

— Method`ennola(W)`

Let `W`

be an irreducible spetsial reflection group or coset, and `z`

the generator of the center of `W`

, viewed as a root of unity. A property checked case-by case is that, for a unipotent character `γ`

with polynomial generic degree `deg γ(q)`

of the spets attached to `W`

(this spets is a finite reductive group, for `W`

a Weyl group, in which case `z=-1`

if `-1`

is in `W`

), `deg γ(zq)`

is equal to `±deg γ'(q)`

for another unipotent character `γ'`

; `±γ'`

is called the Ennola transform of `γ`

. The function returns the permutation-with-signs done by `ennola`

on the unipotent degrees (as a permutation-with signs of `1:length(UnipotentCharacters(W))`

). The argument `W`

must be irreducible.

The permutation-with-signs is not uniquely determined by the degrees since two of them may be equal, but is uniquely determined by some additional axioms that we do not recall here.

```
julia> dSeries.ennola(rootdatum("3D4"))
SPerm{Int64}: (3,-4)(5,-5)(6,-6)(7,-8)
julia> dSeries.ennola(complex_reflection_group(14))
SPerm{Int64}: (2,43,-14,16,41,34)(3,35,40,18,-11,42)(4,-37,25,-17,-26,-36)(5,-6,-79)(7,-7)(8,-74)(9,-73)(10,-52,13,31,-50,29)(12,53,15,32,-51,-30)(19,71,70,21,67,68,20,69,72)(22,-39,27,-33,-28,-38)(23,24,-66,-23,-24,66)(44,46,49,-44,-46,-49)(45,48,47,-45,-48,-47)(54,-63,-55,-57,62,-56)(58,-65,-59,-61,64,-60)(75,-77)(76,-76)(78,-78)
```

The last example shows that it may happen that the order of `z`

-Ennola (here 18) is greater than the order of `z`

(here 6); this is related to the presence of irrationalities in the character table of the spetsial Hecke algebra of `W`

.

`Chevie.Gt.ClassTypes`

— Type`ClassTypes(G[,p])`

`G`

should be a root datum or a twisted root datum representing a finite reductive group $𝐆 ^F$ and `p`

should be a prime. The function returns the class types of `G`

in characteristic `p`

(in good characteristic if `p`

is omitted). Two elements of $𝐆 ^F$ have the same class type if their centralizers are conjugate. If `su`

is the Jordan decomposition of an element `x`

, the class type of `x`

is determined by the class type of its semisimple part `s`

and the unipotent class of `u`

in $C_𝐆 (s)$.

The function `ClassTypes`

is presently only implemented for simply connected groups, where $C_𝐆 (s)$ is connected. This section is a bit experimental and may change in the future.

`ClassTypes`

returns a `struct`

which contains a list of classtypes for semisimple elements, which are represented by `subspets`

and contain additionnaly information on the unipotent classes of $C_𝐆 (s)$.

Let us give some examples:

```
julia> t=ClassTypes(rootdatum(:sl,3))
ClassTypes(A₂,good characteristic)
C_G(s)│ |C_G(s)|
──────────┼──────────
A₂₍₎=Φ₁² │ Φ₁²
A₂₍₎=Φ₁Φ₂ │ Φ₁Φ₂
A₂₍₎=Φ₃ │ Φ₃
A₂₍₁₎=A₁Φ₁│ qΦ₁²Φ₂
A₂ │q³Φ₁²Φ₂Φ₃
```

By default, only information about semisimple centralizer types is returned: the type, and its generic order.

```
julia> xdisplay(t;unip=true)
ClassTypes(A₂,good characteristic)
C_G(s)│ u |C_G(su)|
──────────┼────────────────
A₂₍₎=Φ₁² │ 1 Φ₁²
A₂₍₎=Φ₁Φ₂ │ 1 Φ₁Φ₂
A₂₍₎=Φ₃ │ 1 Φ₃
A₂₍₁₎=A₁Φ₁│ 11 qΦ₁²Φ₂
│ 2 qΦ₁
A₂ │ 111 q³Φ₁²Φ₂Φ₃
│ 21 q³Φ₁
│ 3 3q²
│ 3_ζ₃ 3q²
│3_ζ₃² 3q²
```

Here we have displayed information on unipotent classes, with their centralizer.

```
julia> xdisplay(t;nClasses=true)
ClassTypes(A₂,good characteristic)
C_G(s)│ nClasses |C_G(s)|
──────────┼──────────────────────────
A₂₍₎=.Φ₁² │(q²-5q+2q₃+4)/6 Φ₁²
A₂₍₎=.Φ₁Φ₂│ (q²-q)/2 Φ₁Φ₂
A₂₍₎=.Φ₃ │ (q²+q-q₃+1)/3 Φ₃
A₂₍₁₎=A₁Φ₁│ (q-q₃-1) qΦ₁²Φ₂
A₂ │ q₃ q³Φ₁²Φ₂Φ₃
```

Here we have added information on how many semisimple conjugacy classes of `𝐆 ^F`

have a given type. The answer in general involves variables of the form `qₐ`

which represent `gcd(q-1,a)`

.

Finally an example in bad characteristic:

```
julia> t=ClassTypes(coxgroup(:G,2),2);xdisplay(t;nClasses=true)
ClassTypes(G₂,char. 2)
C_G(s)│ nClasses |C_G(s)|
──────────┼───────────────────────────────
G₂₍₎=.Φ₁² │(q²-8q+2q₃+10)/12 Φ₁²
G₂₍₎=.Φ₁Φ₂│ (q²-2q)/4 Φ₁Φ₂
G₂₍₎=.Φ₁Φ₂│ (q²-2q)/4 Φ₁Φ₂
G₂₍₎=.Φ₆ │ (q²-q-q₃+1)/6 Φ₆
G₂₍₎=.Φ₃ │ (q²+q-q₃+1)/6 Φ₃
G₂₍₎=.Φ₂² │ (q²-4q+2q₃-2)/12 Φ₂²
G₂₍₁₎=A₁Φ₂│ (q-q₃+1)/2 qΦ₁Φ₂²
G₂₍₁₎=A₁Φ₁│ (q-q₃-1)/2 qΦ₁²Φ₂
G₂₍₂₎=Ã₁Φ₂│ q/2 qΦ₁Φ₂²
G₂₍₂₎=Ã₁Φ₁│ (q-2)/2 qΦ₁²Φ₂
G₂ │ 1 q⁶Φ₁²Φ₂²Φ₃Φ₆
G₂₍₁₅₎=²A₂│ (q₃-1)/2 q³Φ₁Φ₂²Φ₆
G₂₍₁₅₎=A₂ │ (q₃-1)/2 q³Φ₁²Φ₂Φ₃
```

We notice that if `q`

is a power of `2`

such that `q≡2 (mod 3)`

, so that `q₃=1`

, some class types do not exist. We can see what happens by giving a specific value to `q₃`

:

```
julia> xdisplay(t(;q_3=1);nClasses=true)
ClassTypes(G₂,char. 2) q₃=1
C_G(s)│ nClasses |C_G(s)|
──────────┼───────────────────────────
G₂₍₎=Φ₁² │(q²-8q+12)/12 Φ₁²
G₂₍₎=Φ₁Φ₂ │ (q²-2q)/4 Φ₁Φ₂
G₂₍₎=Φ₁Φ₂ │ (q²-2q)/4 Φ₁Φ₂
G₂₍₎=Φ₆ │ (q²-q)/6 Φ₆
G₂₍₎=Φ₃ │ (q²+q)/6 Φ₃
G₂₍₎=Φ₂² │ (q²-4q)/12 Φ₂²
G₂₍₁₎=A₁Φ₁│ (q-2)/2 qΦ₁²Φ₂
G₂₍₁₎=A₁Φ₂│ q/2 qΦ₁Φ₂²
G₂₍₂₎=Ã₁Φ₁│ (q-2)/2 qΦ₁²Φ₂
G₂₍₂₎=Ã₁Φ₂│ q/2 qΦ₁Φ₂²
G₂ │ 1 q⁶Φ₁²Φ₂²Φ₃Φ₆
```

`Chevie.Gt.closed_subsystems`

— Method`closed_subsystems(W)`

`W`

should be a Weyl group. The function returns the Poset of closed subsystems of the root system of `W`

. Each closed subsystem is represented by the list of indices of its simple roots. If `W`

is the Weyl group of a reductive group `𝐆`

, then closed subsystem correspond to reductive subgroups of maximal rank. And all such groups are obtained this way, apart from some exceptions in characteristics 2 and 3 (see Malle-Testerman 2011 Proposition 13.4).

```
julia> W=coxgroup(:G,2)
G₂
julia> closed_subsystems(W)
1 2<1 4<4<∅
1 2<1 5<1<∅
1 2<2 6<6<∅
1 2<3 5<5<∅
1 4<1
1 5<6
1 5<5
2 6<2<∅
3 5<3<∅
```

`Chevie.Ucl`

— ModuleThis module gives information about the unipotent conjugacy classes of a connected reductive group over an algebraically closed field `k`

, and various invariants attached to them. The unipotent classes depend on the characteristic of `k`

; their classification differs when the characteristic is not *good* (that is, when it divides one of the coefficients of the highest root). In good characteristic, the unipotent classes are in bijection with nilpotent orbits on the Lie algebra.

We give the following information for a unipotent element `u`

of each class:

the centralizer $C_𝐆 (u)$, that we describe by the reductive part of $C_𝐆 (u)^0$, by the group of components $A(u):=C_𝐆 (u)/C_𝐆 (u)^0$, and by the dimension of its radical.

in good characteristic, the Dynkin-Richardson diagram.

the Springer correspondence, attaching characters of the Weyl group or relative Weyl groups to each character of

`A(u)`

.

The Dynkin-Richarson diagram is attached to a nilpotent element $e$ of the Lie algebra $𝔤$. By the Jacobson-Morozov theorem there exists an $𝔰𝔩₂$ subalgebra of $𝔤$ containing $e$ as the element $\begin{pmatrix}1&0\\0&1 \end{pmatrix}$. Let $𝐒$ be the torus $\begin{pmatrix}h&0\\0&h^{-1} \end{pmatrix}$ of $SL₂$ and let $𝐓$ be a maximal torus containing $𝐒$, so that $𝐒$ is the image of a one-parameter subgroup $σ∈ Y(𝐓)$. Consider the root decomposition $𝔤=∑_{α∈Σ}𝔤_α$ given by $𝐓$; then $α↦⟨σ,α⟩$ defines a linear form on $Σ$, determined by its value on simple roots. It is possible to choose a system of simple roots $Π$ so that $⟨σ,α⟩≥ 0$ for $α∈Π$, and then $⟨σ,α⟩∈{0,1,2}$ for any $α∈Π$. The Dynkin diagram of $Π$ decorated by these values $0,1,2$ is called the Dynkin-Richardson diagram of $e$, and in good characteristic is a complete invariant of its $𝔤$-orbit.

Let $ℬ$ be the variety of all Borel subgroups and let $ℬᵤ$ be the subvariety of Borel subgroups containing the unipotent element `u`

. Then $dim C_𝐆(u)=rank 𝐆 + 2 dim ℬ_u$ and in good characteristic this dimension can be computed from the Dynkin-Richardson diagram: the dimension of the class of `u`

is the number of roots `α`

such that $⟨σ,α⟩∉{0,1}$.

We describe now the Springer correspondence. Indecomposable locally constant $𝐆$-equivariant sheaves on $C$, called *local systems*, are parameterized by irreducible characters of $A(u)$. The *ordinary* Springer correspondence is a bijection between irreducible characters of the Weyl group and a large subset of the local systems which contains all trivial local systems (those parameterized by the trivial character of $A(u)$ for each $u$). More generally, the *generalized* Springer correspondence associates to each local system a (unique up to $𝐆$-conjugacy) *cuspidal pair* of a Levi subgroup $𝐋$ of $𝐆$ and a *cuspidal* local system on an unipotent class of $𝐋$, such that the set of local systems associated to a given cuspidal pair is parameterized by the characters of the relative Weyl group $W_𝐆 (𝐋):=N_𝐆 (𝐋)/𝐋$. There are only few cuspidal pairs.

The Springer correspondence gives information on the character values of a finite reductive groups as follows: assume that $k$ is the algebraic closure of a finite field $𝔽_q$ and that $F$ is the Frobenius attached to an $𝔽_q$-structure of $𝐆$. Let $C$ be an $F$-stable unipotent class and let $u∈ C^F$; we call $C$ the *geometric class* of $u$ and the $𝐆^F$-classes inside $C^F$ are parameterized by the $F$-conjugacy classes of $A(u)$, denoted $H¹(F,A(u))$ (most of the time we can find $u$ such that $F$ acts trivially on $A(u)$ and $H¹(F,A(u))$ is then just the conjugacy classes). To an $F$-stable character $φ$ of $A(u)$ we associate the *characteristic function* of the corresponding local system (actually associated to an extension $φ̃$ of $φ$ to $A(u).F$); it is a class function $Y_{u,φ}$ on $𝐆^F$ which can be normalized so that: $Y_{u,φ}(u₁)=φ̃(cF)$ if $u₁$ is geometrically conjugate to $u$ and its $𝐆^F$-class is parameterized by the $F$-conjugacy class $cF$ of $A(u)$, otherwise $Y_{u,φ}(u₁)=0$. If the pair $u,φ$ corresponds via the Springer correspondence to the character $χ$ of $W_𝐆(𝐋)$, then $Y_{u,φ}$ is also denoted $Yᵪ$. There is another important class of functions indexed by local systems: to a local system on class $C$ is attached an intersection cohomology complex, which is a complex of sheaves supported on the closure $C̄$. To such a complex of sheaves is associated its *characteristic function*, a class function of $𝐆^F$ obtained by taking the alternating trace of the Frobenius acting on the stalks of the cohomology sheaves. If $Y_ψ$ is the characteristic function of a local system, the characteristic function of the corresponding intersection cohomology complex is denoted by $X_ψ$. This function is supported on $C̄$, and Lusztig has shown that $X_ψ=∑ᵩ P_{ψ,χ} Yᵪ$ where $P_{ψ,χ}$ are integer polynomials in $q$ and $Yᵪ$ are attached to local systems on classes lying in $C̄$.

Lusztig and Shoji have given an algorithm to compute the matrix $P_{ψ,χ}$, which is implemented in Chevie. The relationship with characters of $𝐆(𝔽_q)$, taking to simplify the ordinary Springer correspondence, is that the restriction to the unipotent elements of the almost character $R_χ$ is equal to $q^{bᵪ} Xᵪ$, where $bᵪ$ is $dim ℬᵤ$ for an element `u`

of the class `C`

such that the support of `χ`

is $C̄$. The restriction of the Deligne-Lusztig characters $R_w$ to the unipotents are called the *Green functions* and can also be computed by Chevie. The values of all unipotent characters on unipotent elements can also be computed in principle by applying Lusztig's Fourier transform matrix (see the section on the Fourier matrix) but there is a difficulty in that the $Xᵪ$ must be first multiplied by some roots of unity which are not known in all cases (and when known may depend on the congruence class of $q$ modulo some small primes).

We illustrate these computations on some examples:

```
julia> UnipotentClasses(rootdatum(:sl,4))
UnipotentClasses(sl₄)
1111<211<22<31<4
u│D-R dBu B-C C(u) A₃(A₃₍₎=Φ₁³) A₁(A₃₍₁₃₎=A₁×A₁Φ₁)/-1 .(A₃)/ζ₄
────┼──────────────────────────────────────────────────────────────────────
4 │222 0 222 q³.Z₄ 1:4 -1:2 ζ₄:Id
31 │202 1 22. q⁴.A₁₍₎=Φ₁ Id:31
22 │020 2 2.2 q⁴.A₁.Z₂ 2:22 11:11
211 │101 3 2.. q⁵.A₂₍₁₎=A₁Φ₁ Id:211
1111│000 6 ... A₃ Id:1111
u│.(A₃)/ζ₄³
────┼──────────
4 │ ζ₄³:Id
31 │
22 │
211 │
1111│
```

The first column in the table gives the name of the unipotent class, which here is a partition describing the Jordan form. The partial order on unipotent classes given by Zariski closure is given before the table. The column `D-R`

, displayed only in good characteristic, gives the Dynkin-Richardson diagram for each class; the column `dBu`

gives the dimension of the variety $ℬ ᵤ$. The column `B-C`

gives the Bala-Carter classification of $u$, that is in the case of $sl₄$ it displays $u$ as a regular unipotent in a Levi subgroup by giving the Dynkin-Richardson diagram of a regular unipotent (all 2's) at entries corresponding to the Levi and `.`

at entries which do not correspond to the Levi. The column `C(u)`

describes the group $C_𝐆(u)$: a power $qᵈ$ describes that the unipotent radical of $C_𝐆(u)$ has dimension $d$ (thus $qᵈ$ rational points); then follows a description of the reductive part of the neutral component of $C_𝐆(u)$, given by the name of its root datum. Then if $C_𝐆(u)$ is not connected, the description of $A(u)$ is given using another vocabulary: a cyclic group of order 4 is given as `Z4`

, and a symmetric group on 3 points would be given as `S3`

.

For instance, the first class `4`

has $C_𝐆(u)^0$ unipotent of dimension `3`

and $A(u)$ equal to `Z4`

, the cyclic group of order 4. The class `22`

has $C_G(u)$ with unipotent radical of dimension `4`

, reductive part of type `A1`

and $A(u)$ is `Z2`

, that is the cyclic group of order 2. The other classes have $C_𝐆(u)$ connected. For the class `31`

the reductive part of $C_G(u)$ is a torus of rank 1.

Then there is one column for each *Springer series*, giving for each class the pairs 'a:b' where 'a' is the name of the character of $A(u)$ describing the local system involved and 'b' is the name of the character of the (relative) Weyl group corresponding by the Springer correspondence. At the top of the column is written the name of the relative Weyl group, and in brackets the name of the Levi affording a cuspidal local system; next, separated by a `/`

is a description of the central character associated to the Springer series (omitted if this central character is trivial): all local systems in a given Springer series have same restriction to the center of $𝐆$. To find what the picture becomes for another algebraic group in the same isogeny class, for instance the adjoint group, one simply discards the Springer series whose central character becomes trivial on the center of $𝐆$; and each group $A(u)$ has to be quotiented by the common kernel of the remaining characters. Here is the table for the adjoint group:

```
julia> UnipotentClasses(coxgroup(:A,3))
UnipotentClasses(A₃)
1111<211<22<31<4
u│D-R dBu B-C C(u) A₃(A₃₍₎=Φ₁³)
────┼───────────────────────────────────────
4 │222 0 222 q³ Id:4
31 │202 1 22. q⁴.A₁₍₎=Φ₁ Id:31
22 │020 2 2.2 q⁴.A₁ Id:22
211 │101 3 2.. q⁵.A₂₍₁₎=A₁Φ₁ Id:211
1111│000 6 ... A₃ Id:1111
```

Here is another example:

```
julia> UnipotentClasses(coxgroup(:G,2))
UnipotentClasses(G₂)
1<A₁<Ã₁<G₂(a₁)<G₂
u│D-R dBu B-C C(u) G₂(G₂₍₎=Φ₁²) .(G₂)
──────┼─────────────────────────────────────────
G₂ │ 22 0 22 q² Id:φ₁‚₀
G₂(a₁)│ 20 1 20 q⁴.S₃ 21:φ′₁‚₃ 3:φ₂‚₁ 111:Id
Ã₁ │ 01 2 .2 q³.A₁ Id:φ₂‚₂
A₁ │ 10 3 2. q⁵.A₁ Id:φ″₁‚₃
1 │ 00 6 .. G₂ Id:φ₁‚₆
```

which illustrates that on class `G₂(a₁)`

there are two local systems in the principal series of the Springer correspondence, and a further cuspidal local system. Also, from the `B-C`

column, we see that that class is not in a proper Levi, in which case the Bala-Carter diagram coincides with the Dynkin-Richardson diagram.

The characteristics 2 and 3 are not good for `G2`

. To get the unipotent classes and the Springer correspondence in bad characteristic, one gives a second argument to the function `UnipotentClasses`

:

```
julia> UnipotentClasses(coxgroup(:G,2),3)
UnipotentClasses(G₂,3)
1<A₁,(Ã₁)₃<Ã₁<G₂(a₁)<G₂
u│dBu B-C C(u) G₂(G₂₍₎=Φ₁²) .(G₂) .(G₂) .(G₂)
──────┼──────────────────────────────────────────────
G₂ │ 0 22 q².Z₃ 1:φ₁‚₀ ζ₃:Id ζ₃²:Id
G₂(a₁)│ 1 20 q⁴.Z₂ 2:φ₂‚₁ 11:Id
Ã₁ │ 2 .2 q⁶ Id:φ₂‚₂
A₁ │ 3 2. q⁵.A₁ Id:φ″₁‚₃
(Ã₁)₃ │ 3 ?? q⁵.A₁ Id:φ′₁‚₃
1 │ 6 .. G₂ Id:φ₁‚₆
```

The function `ICCTable`

gives the transition matrix between the functions $Xᵪ$ and $Y_ψ$.

```
julia> uc=UnipotentClasses(coxgroup(:G,2));
julia> t=ICCTable(uc)
Coefficients of Xᵪ on Yᵩ for series L=G₂₍₎=Φ₁² W_G(L)=G₂
│G₂ G₂(a₁)⁽²¹⁾ G₂(a₁) Ã₁ A₁ 1
──────┼──────────────────────────────
Xφ₁‚₀ │ 1 . 1 1 1 1
Xφ′₁‚₃│ . 1 . 1 . q²
Xφ₂‚₁ │ . . 1 1 1 Φ₈
Xφ₂‚₂ │ . . . 1 1 Φ₄
Xφ″₁‚₃│ . . . . 1 1
Xφ₁‚₆ │ . . . . . 1
```

Here the row labels and the column labels show the two ways of indexing local systems: the row labels give the character of the relative Weyl group and the column labels give the class and the name of the local system as a character of `A(u)`

: for instance, `G2(a1)`

is the trivial local system of the class `G2(a1)`

, while `G2(a1)(21)`

is the local system on that class corresponding to the 2-dimensional character of $A(u)=A₂$.

`Chevie.Ucl.GreenTable`

— Method`GreenTable(uc;classes=false)`

Keeping the same notations as in the description of 'XTable', this function returns a table of the functions $Q_{wF}$, attached to elements $wF∈ W_𝐆 (𝐋)⋅F$ where $W_𝐆 (𝐋)$ are the relative weyl groups attached to cuspidal local systems. These functions are defined by $Q_{wF}=∑_{u,ϕ} ϕ̃(wF) X̃_{u,ϕ}$. An point to note is that in the principal Springer series, when `𝐓`

is a maximal torus, the function $Q_{wF}$ coincides with the Deligne-Lusztig character $R^𝐆 _{𝐓_W}(1)$. As for 'XTable', by default the table gives the values of the functions on local systems. If `classes=true`

is given, then it gives the values of the functions $Q_{wF}$ on conjugacy classes.

```
julia> W=coxgroup(:G,2)
G₂
julia> GreenTable(UnipotentClasses(W))
Values of Green functions Q_wF on local systems φ
Qᴵ_wF|φ│ 1 A₁ Ã₁ G₂(a₁)⁽¹¹¹⁾ G₂(a₁)⁽²¹⁾ G₂(a₁) G₂
──────────┼───────────────────────────────────────────────────────────
Q_A₀^G₂ │ Φ₂²Φ₃Φ₆ Φ₂Φ₃ (2q+1)Φ₂ . q 2q+1 1
Q_Ã₁^G₂ │-Φ₁Φ₂Φ₃Φ₆ -Φ₁Φ₃ Φ₂ . q 1 1
Q_A₁^G₂ │-Φ₁Φ₂Φ₃Φ₆ Φ₂Φ₆ -Φ₁ . -q 1 1
Q_G₂^G₂ │ Φ₁²Φ₂²Φ₃ -Φ₁Φ₂² -Φ₁Φ₂ . -q Φ₂ 1
Q_A₂^G₂ │ Φ₁²Φ₂²Φ₆ Φ₁²Φ₂ -Φ₁Φ₂ . q -Φ₁ 1
Q_A₁+Ã₁^G₂│ Φ₁²Φ₃Φ₆ -Φ₁Φ₆ (2q-1)Φ₁ . -q -2q+1 1
Q_^. │ . . . q² . . .
```

The functions $Q_{wF}$ depend only on the conjugacy class of `wF`

, so in the first column the indices of 'Q' are the names of the conjugacy classes of $W_𝐆(𝐋)$. The exponents are the names of the groups $W_𝐆(𝐋)$.

```
julia> GreenTable(UnipotentClasses(W);classes=true)
Values of Green functions Q_wF on unipotent classes
Qᴵ_wF|class│ 1 A₁ Ã₁ G₂(a₁) G₂(a₁)₍₂₁₎ G₂(a₁)₍₃₎ G₂
───────────┼─────────────────────────────────────────────────────────
Q_A₀^G₂ │ Φ₂²Φ₃Φ₆ Φ₂Φ₃ (2q+1)Φ₂ 4q+1 2q+1 Φ₂ 1
Q_Ã₁^G₂ │-Φ₁Φ₂Φ₃Φ₆ -Φ₁Φ₃ Φ₂ 2q+1 1 -Φ₁ 1
Q_A₁^G₂ │-Φ₁Φ₂Φ₃Φ₆ Φ₂Φ₆ -Φ₁ -2q+1 1 Φ₂ 1
Q_G₂^G₂ │ Φ₁²Φ₂²Φ₃ -Φ₁Φ₂² -Φ₁Φ₂ -Φ₁ Φ₂ 2q+1 1
Q_A₂^G₂ │ Φ₁²Φ₂²Φ₆ Φ₁²Φ₂ -Φ₁Φ₂ Φ₂ -Φ₁ -2q+1 1
Q_A₁+Ã₁^G₂ │ Φ₁²Φ₃Φ₆ -Φ₁Φ₆ (2q-1)Φ₁ -4q+1 -2q+1 -Φ₁ 1
Q_^. │ . . . q² -q² q² .
julia> GreenTable(UnipotentClasses(rootdatum(:sl,4)))
Values of Green functions Q_wF on local systems φ
Qᴵ_wF|φ│ 1111 211 22⁽¹¹⁾ 22 31 4 4^(ζ₄) 4⁽⁻¹⁾ 4^(ζ₄³)
────────┼───────────────────────────────────────────────────────────────────
Q₁₁₁₁^A₃│ Φ₂²Φ₃Φ₄ (3q²+2q+1)Φ₂ . (2q+1)Φ₂ 3q+1 1 . . .
Q₂₁₁^A₃ │-Φ₁Φ₂Φ₃Φ₄ -q³+q²+q+1 . Φ₂ Φ₂ 1 . . .
Q₂₂^A₃ │ Φ₁²Φ₃Φ₄ -Φ₁Φ₄ . 2q²-q+1 -Φ₁ 1 . . .
Q₃₁^A₃ │ Φ₁²Φ₂²Φ₄ -Φ₁Φ₂ . -Φ₁Φ₂ 1 1 . . .
Q₄^A₃ │ -Φ₁³Φ₂Φ₃ Φ₁²Φ₂ . -Φ₁ -Φ₁ 1 . . .
Q₁₁^A₁ │ . . q²Φ₂ . . . . q .
Q₂^A₁ │ . . -q²Φ₁ . . . . q .
Q_^. │ . . . . . . q³⁄₂ . .
Q_^. │ . . . . . . . . q³⁄₂
```

`Chevie.Ucl.ICCTable`

— Type`ICCTable(uc,seriesNo=1;q=Pol())`

This function gives the table of decompositions of the functions $X_ι$ in terms of the functions $Y_ι$. Here `ι`

is a `𝐆`

-equivariant local system on the class `C`

of a unipotent element `u`

. Such a local system is parametrized by the pair `(u,ϕ)`

of `u`

and a character of the group of components `A(u)`

of $C_𝐆 (u)$. The function $Y_ι$ is the characteristic function of this local system and $X_ι$ is the characteristic function of the corresponding intersection cohomology complex on `C̄`

. The Springer correspondence says that the local systems can also be indexed by characters of a relative Weyl group. Since the coefficient of `Xᵪ`

on `Yᵩ`

is `0`

if `χ`

and `φ`

are not characters of the same relative Weyl group (are not in the same Springer series), the table is for one Springer series, specified by the argument 'seriesNo' (this defaults to 'seriesNo=1' which is the principal series). The decomposition multiplicities are graded, and are given as polynomials in one variable (specified by the argument `q`

; if not given `Pol()`

is assumed).

```
julia> uc=UnipotentClasses(coxgroup(:A,3));t=ICCTable(uc)
Coefficients of Xᵪ on Yᵩ for series L=A₃₍₎=Φ₁³ W_G(L)=A₃
│4 31 22 211 1111
─────┼─────────────────
X4 │1 1 1 1 1
X31 │. 1 1 Φ₂ Φ₃
X22 │. . 1 1 Φ₄
X211 │. . . 1 Φ₃
X1111│. . . . 1
```

In the above the multiplicities are given as products of cyclotomic polynomials to display them more compactly. However the format of such a table can be controlled more precisely.

For instance, one can ask to not display the entries as products of cyclotomic polynomials and not display the zeroes as '.'

```
julia> xdisplay(t;cycpol=false,dotzero=false)
Coefficients of Xᵪ on Yᵩ for A3
│4 31 22 211 1111
─────┼───────────────────
X4 │1 1 1 1 1
X31 │0 1 1 q+1 q²+q+1
X22 │0 0 1 1 q²+1
X211 │0 0 0 1 q²+q+1
X1111│0 0 0 0 1
```

Since `show`

uses the function `format`

for tables, all the options of this function are also available. We can use this to restrict the entries displayed to a given sublist of the rows and columns (here the indices correspond to the number in Chevie of the corresponding character of the relative Weyl group of the given Springer series):

```
julia> uc=UnipotentClasses(coxgroup(:F,4));
julia> t=ICCTable(uc);
julia> sh=[13,24,22,18,14,9,11,19];
julia> xdisplay(t,rows=sh,cols=sh)
Coefficients of Xᵪ on Yᵩ for series L=F₄₍₎=Φ₁⁴ W_G(L)=F₄
│A₁+Ã₁ A₂ Ã₂ A₂+Ã₁ Ã₂+A₁ B₂⁽¹¹⁾ B₂ C₃(a₁)⁽¹¹⁾
──────┼─────────────────────────────────────────────
Xφ₉‚₁₀│ 1 . . . . . . .
Xφ″₈‚₉│ 1 1 . . . . . .
Xφ′₈‚₉│ 1 . 1 . . . . .
Xφ″₄‚₇│ 1 1 . 1 . . . .
Xφ′₆‚₆│ Φ₄ 1 1 1 1 . . .
Xφ₄‚₈ │ q² . . . . 1 . .
Xφ″₉‚₆│ Φ₄ Φ₄ . 1 . . 1 .
Xφ′₄‚₇│ q² . Φ₄ . 1 . . 1
```

The function 'ICCTable' returns an object with various pieces of information which can help further computations.

`.scalar`

: this contains the table of multiplicities `Pᵪᵩ`

of the `Xᵪ`

on the `Yᵩ`

. One should pay attention that by default, the table is not displayed in the same order as the stored |.scalar|, which is in order in Chevie of the characters in the relative Weyl group; the table is transposed, then lines and rows are sorted by `dimBu,class no,index of character in A(u)`

while displayed.

`.group`

: The group `W`

.

`.relgroup`

: The relative Weyl group for the Springer series.

`.series`

: The index of the Springer series given for `W`

.

`.dimBu`

: The list of $dimℬᵤ$ for each local system `(u,φ)`

in the series.

`:L`

: The matrix of (unnormalized) scalar products of the functions $Yᵩ$ with themselves, that is the $(φ,χ)$ entry is $∑_{g∈𝐆(𝔽_q)} Yᵩ(g) Yᵪ(g)$. This is thus a symmetric, block-diagonal matrix where the diagonal blocks correspond to geometric unipotent conjugacy classes. This matrix is obtained as a by-product of Lusztig's algorithm to compute $Pᵩᵪ$.

`Chevie.Ucl.UnipotentClass`

— TypeA `struct UnipotentClass`

representing the class `C`

of a unipotent element `u`

of the reductive group `𝐆`

with Weyl group `W`

, contains always the following information

`.name`

The name of`C`

`.parameter`

A parameter describing`C`

. Sometimes the same as`.name`

; a partition describing the Jordan form, for classical groups.`.dimBu`

The dimension of the variety of Borel subgroups containing`u`

.

For some types there is a field `.mizuno`

or `.shoji`

giving alternate names used in the literature.

A `UnipotentClass`

contains also some of the following information (all of it for some types and some characteristics but sometimes much less)

`.dynkin`

the Dynkin-Richardson diagram of`C`

(a vector giving a weight 0, 1 or 2 to the simple roots).`.dimred`

the dimension of the reductive part of`C_G(u)`

.`.red`

a`CoxeterCoset`

recording the type of the reductive part of`C_G(u)`

, with the twisting induced by the Frobenius if any.`.Au`

the group`A_G(u)=C_G(u)/C^0_G(u)`

.`.balacarter`

encodes the Bala-Carter classification of`C`

, which says that`u`

is distinguished in a Levi`L`

(the Richardson class in a parabolic`P_L`

) as a vector listing the indices of the simple roots in`L`

, with those not in`P_L`

negated.`.rep`

a list of indices for roots such that if`U=UnipotentGroup(W)`

then`prod(U,u.rep)`

is a representative of`C`

.`.dimunip`

the dimension of the unipotent part of`C_G(u)`

.`.AuAction`

an`ExtendedCoxeterGroup`

recording the action of`A_G(u)`

on`red`

.

`Chevie.Ucl.UnipotentClasses`

— Type`UnipotentClasses(W[,p])`

`W`

should be a `CoxeterGroup`

record for a Weyl group or `RootDatum`

describing a reductive algebraic group `𝐆`

. The function returns a record containing information about the unipotent classes of `𝐆`

in characteristic `p`

(if omitted, `p`

is assumed to be any good characteristic for `𝐆`

). This contains the following fields:

`group`

: a pointer to `W`

`p`

: the characteristic of the field for which the unipotent classes were computed. It is `0`

for any good characteristic.

`orderclasses`

: a list describing the Hasse diagram of the partial order induced on unipotent classes by the closure relation. That is `.orderclasses[i]`

is the list of `j`

such that $C̄ⱼ⊋ C̄ᵢ$ and there is no class $Cₖ$ such that $C̄ⱼ⊋ C̄ₖ⊋ C̄ᵢ$.

`classes`

: a list of records holding information for each unipotent class (see below).

`springerseries`

: a list of records, each of which describes a Springer series of `𝐆`

.

The records describing individual unipotent classes have the following fields:

`name`

: the name of the unipotent class.

`parameter`

: a parameter describing the class (for example, a partition describing the Jordan form, for classical groups).

`Au`

: the group `A(u)`

.

`dynkin`

: present in good characteristic; contains the Dynkin-Richardson diagram, given as a list of 0,1,2 describing the coefficient on the corresponding simple root.

`red`

: the reductive part of $C_𝐆(u)$.

`dimBu`

: the dimension of the variety `𝓑ᵤ`

.

The records for classes contain additional fields for certain groups: for instance, the names given to classes by Mizuno in `E₆, E₇, E₈`

or by Shoji in `F₄`

. See the help for `UnipotentClass`

for more details.

The records describing individual Springer series have the following fields:

`levi`

:the indices of the reflections corresponding to the Levi subgroup `𝐋`

where lives the cuspidal local system `ι`

from which the Springer series is induced.

`relgroup`

: The relative Weyl group $N_𝐆(𝐋,ι)/𝐋$. The first series is the principal series for which `.levi=[]`

and `.relgroup=W`

.

`locsys`

: a list of length `nconjugacy_classes(.relgroup)`

, holding in `i`

-th position a pair describing which local system corresponds to the `i`

-th character of $N_𝐆(𝐋,ι)$. The first element of the pair is the index of the concerned unipotent class `u`

, and the second is the index of the corresponding character of `A(u)`

.

`Z`

: the central character associated to the Springer series, specified by its value on the generators of the center.

```
julia> W=rootdatum(:sl,4)
sl₄
julia> uc=UnipotentClasses(W);
julia> uc.classes
5-element Vector{UnipotentClass}:
UnipotentClass(1111)
UnipotentClass(211)
UnipotentClass(22)
UnipotentClass(31)
UnipotentClass(4)
```

The `show`

function for unipotent classes accepts all the options of `formatTable`

and of `charnames`

. Giving the option `mizuno`

(resp. `shoji`

) uses the names given by Mizuno (resp. Shoji) for unipotent classes. Moreover, there is also an option `fourier`

which gives the Springer correspondence tensored with the sign character of each relative Weyl group, which is the correspondence obtained via a Fourier-Deligne transform (here we assume that `p`

is very good, so that there is a nondegenerate invariant bilinear form on the Lie algebra, and also one can identify nilpotent orbits with unipotent classes).

Here is how to display the non-cuspidal part of the Springer correspondence of the unipotent classes of `E₆`

using the notations of Mizuno for the classes and those of Frame for the characters of the Weyl group and of Spaltenstein for the characters of `G₂`

(this is convenient for checking our data with the original paper of Spaltenstein):

```
julia> uc=UnipotentClasses(rootdatum(:E6sc));
julia> xdisplay(uc;cols=[5,6,7],spaltenstein=true,frame=true,mizuno=true,
order=false)
UnipotentClasses(E₆sc)
u│ E₆(E₆₍₎) G₂(E₆₍₁₃₅₆₎=A₂×A₂)/ζ₃ G₂(E₆₍₁₃₅₆₎=A₂×A₂)/ζ₃²
──────┼──────────────────────────────────────────────────────────────────
E₆ │ 1:1ₚ ζ₃:1 ζ₃²:1
E₆(a₁)│ 1:6ₚ ζ₃:ε_c ζ₃²:ε_c
D₅ │ Id:20ₚ
A₅+A₁ │ -1:15ₚ 1:30ₚ ζ₃:θ′ ζ₃²:θ′
A₅ │ 1:15_q ζ₃:θ″ ζ₃²:θ″
D₅(a₁)│ Id:64ₚ
A₄+A₁ │ Id:60ₚ
D₄ │ Id:24ₚ
A₄ │ Id:81ₚ
D₄(a₁)│111:20ₛ 3:80ₛ 21:90ₛ
A₃+A₁ │ Id:60ₛ
2A₂+A₁│ 1:10ₛ ζ₃:εₗ ζ₃²:εₗ
A₃ │ Id:81ₚ′
A₂+2A₁│ Id:60ₚ′
2A₂ │ 1:24ₚ′ ζ₃:ε ζ₃²:ε
A₂+A₁ │ Id:64ₚ′
A₂ │ 11:15ₚ′ 2:30ₚ′
3A₁ │ Id:15_q′
2A₁ │ Id:20ₚ′
A₁ │ Id:6ₚ′
1 │ Id:1ₚ′
```

`Chevie.Ucl.XTable`

— Method`XTable(uc;classes=false)`

This function presents in a different way the information obtained from `ICCTable`

. Let $X̃_{u,ϕ}=q^{1/2(codim C-dim Z(𝐋 ))}X_{u,ϕ}$ where `C`

is the class of `u`

and `Z(𝐋 )`

is the center of Levi subgroup on which lives the cuspidal local system attached to the local system `(u,ϕ)`

.

Then `XTable`

gives the decomposition of the functions $X̃_{u,ϕ}$ on local systems, by default. If `classes==true`

, it gives the values of the functions $X̃_{u,ϕ}$ on unipotent classes.

```
julia> W=coxgroup(:G,2)
G₂
julia> XTable(UnipotentClasses(W))
Values of character sheaves X̃ᵪ on local systems φ
X̃ᵪ|φ│ 1 A₁ Ã₁ G₂(a₁)⁽¹¹¹⁾ G₂(a₁)⁽²¹⁾ G₂(a₁) G₂
──────────┼────────────────────────────────────────────
X_φ₁‚₀^G₂ │ 1 1 1 . . 1 1
X_φ₁‚₆^G₂ │ q⁶ . . . . . .
X_φ′₁‚₃^G₂│ q³ . q . q . .
X_φ″₁‚₃^G₂│ q³ q³ . . . . .
X_φ₂‚₁^G₂ │ qΦ₈ q q . . q .
X_φ₂‚₂^G₂ │q²Φ₄ q² q² . . . .
X_Id^. │ . . . q² . . .
```

The functions `X̃`

in the first column are decorated by putting as an exponent the relative groups $W_𝐆 (𝐋)$.

```
julia> XTable(UnipotentClasses(W);classes=true)
Values of character sheaves X̃ᵪ on unipotent classes
X̃ᵪ|class│ 1 A₁ Ã₁ G₂(a₁) G₂(a₁)₍₂₁₎ G₂(a₁)₍₃₎ G₂
──────────┼──────────────────────────────────────────
X_φ₁‚₀^G₂ │ 1 1 1 1 1 1 1
X_φ₁‚₆^G₂ │ q⁶ . . . . . .
X_φ′₁‚₃^G₂│ q³ . q 2q . -q .
X_φ″₁‚₃^G₂│ q³ q³ . . . . .
X_φ₂‚₁^G₂ │ qΦ₈ q q q q q .
X_φ₂‚₂^G₂ │q²Φ₄ q² q² . . . .
X_Id^. │ . . . q² -q² q² .
julia> XTable(UnipotentClasses(W,2))
Values of character sheaves X̃ᵪ on local systems φ
X̃ᵪ|φ│ 1 A₁ Ã₁ G₂(a₁)⁽¹¹¹⁾ G₂(a₁)⁽²¹⁾ G₂(a₁) G₂⁽¹¹⁾ G₂
──────────┼───────────────────────────────────────────────────
X_φ₁‚₀^G₂ │ 1 1 1 . . 1 . 1
X_φ₁‚₆^G₂ │ q⁶ . . . . . . .
X_φ′₁‚₃^G₂│ q³ . q . q . . .
X_φ″₁‚₃^G₂│ q³ q³ . . . . . .
X_φ₂‚₁^G₂ │ qΦ₈ q q . . q . .
X_φ₂‚₂^G₂ │q²Φ₄ q² q² . . . . .
X_Id^. │ . . . q² . . . .
X_Id^. │ . . . . . . q .
julia> XTable(UnipotentClasses(rootdatum(:sl,4)))
Values of character sheaves X̃ᵪ on local systems φ
X̃ᵪ|φ│1111 211 22⁽¹¹⁾ 22 31 4 4^(ζ₄) 4⁽⁻¹⁾ 4^(ζ₄³)
────────┼─────────────────────────────────────────────
X₁₁₁₁^A₃│ q⁶ . . . . . . . .
X₂₁₁^A₃ │q³Φ₃ q³ . . . . . . .
X₂₂^A₃ │q²Φ₄ q² . q² . . . . .
X₃₁^A₃ │ qΦ₃ qΦ₂ . q q . . . .
X₄^A₃ │ 1 1 . 1 1 1 . . .
X₁₁^A₁ │ . . q³ . . . . . .
X₂^A₁ │ . . q² . . . . q .
X_Id^. │ . . . . . . q³⁄₂ . .
X_Id^. │ . . . . . . . . q³⁄₂
```

A side effect of calling `XTable`

with `classes=true`

is to compute the cardinal of the unipotent conjugacy classes:

```
julia> t=XTable(UnipotentClasses(coxgroup(:G,2));classes=true);
julia> CycPol.(t.cardClass)
7-element Vector{CycPol{Cyc{Rational{Int64}}}}:
1
Φ₁Φ₂Φ₃Φ₆
q²Φ₁Φ₂Φ₃Φ₆
q²Φ₁²Φ₂²Φ₃Φ₆/6
q²Φ₁²Φ₂²Φ₃Φ₆/2
q²Φ₁²Φ₂²Φ₃Φ₆/3
q⁴Φ₁²Φ₂²Φ₃Φ₆
```

`Chevie.Ucl.UnipotentValues`

— Method`UnipotentValues(uc,classes=false)`

This function returns a table of the values of unipotent characters on local systems (by default) or on unipotent classes (if `classes=true`

).

```
julia> W=coxgroup(:G,2)
G₂
julia> UnipotentValues(UnipotentClasses(W);classes=true)
Values of unipotent characters for G₂ on unipotent classes
│ 1 A₁ Ã₁ G₂(a₁) G₂(a₁)₍₂₁₎ G₂(a₁)₍₃₎ G₂
───────┼──────────────────────────────────────────────────────────────
φ₁‚₀ │ 1 1 1 1 1 1 1
φ₁‚₆ │ q⁶ . . . . . .
φ′₁‚₃ │ qΦ₃Φ₆/3 -qΦ₁Φ₂/3 q (q+5)q/3 -qΦ₁/3 qΦ₁/3 .
φ″₁‚₃ │ qΦ₃Φ₆/3 (2q²+1)q/3 . qΦ₁/3 -qΦ₁/3 (q+2)q/3 .
φ₂‚₁ │ qΦ₂²Φ₃/6 (2q+1)qΦ₂/6 qΦ₂/2 (q+5)q/6 -qΦ₁/6 qΦ₁/6 .
φ₂‚₂ │ qΦ₂²Φ₆/2 qΦ₂/2 qΦ₂/2 -qΦ₁/2 qΦ₂/2 -qΦ₁/2 .
G₂[-1] │ qΦ₁²Φ₃/2 -qΦ₁/2 -qΦ₁/2 -qΦ₁/2 qΦ₂/2 -qΦ₁/2 .
G₂[1] │ qΦ₁²Φ₆/6 (2q-1)qΦ₁/6 -qΦ₁/2 (q+5)q/6 -qΦ₁/6 qΦ₁/6 .
G₂[ζ₃] │qΦ₁²Φ₂²/3 -qΦ₁Φ₂/3 . qΦ₁/3 -qΦ₁/3 (q+2)q/3 .
G₂[ζ₃²]│qΦ₁²Φ₂²/3 -qΦ₁Φ₂/3 . qΦ₁/3 -qΦ₁/3 (q+2)q/3 .
julia> UnipotentValues(UnipotentClasses(W,3);classes=true)
Values of unipotent characters for G₂ on unipotent classes
│ 1 A₁ Ã₁ G₂(a₁) G₂(a₁)₍₂₎ G₂ G₂_(ζ₃)
───────┼──────────────────────────────────────────────────────────────────────
φ₁‚₀ │ 1 1 1 1 1 1 1
φ₁‚₆ │ q⁶ . . . . . .
φ′₁‚₃ │ qΦ₃Φ₆/3 -qΦ₁Φ₂/3 q/3 qΦ₂/3 -qΦ₁/3 -2q/3 q/3
φ″₁‚₃ │ qΦ₃Φ₆/3 (2q²+1)q/3 q/3 qΦ₂/3 -qΦ₁/3 -2q/3 q/3
φ₂‚₁ │ qΦ₂²Φ₃/6 (2q+1)qΦ₂/6 (3q+1)q/6 qΦ₂/6 -qΦ₁/6 2q/3 -q/3
φ₂‚₂ │ qΦ₂²Φ₆/2 qΦ₂/2 qΦ₂/2 -qΦ₁/2 qΦ₂/2 . .
G₂[-1] │ qΦ₁²Φ₃/2 -qΦ₁/2 -qΦ₁/2 -qΦ₁/2 qΦ₂/2 . .
G₂[1] │ qΦ₁²Φ₆/6 (2q-1)qΦ₁/6 (-3q+1)q/6 qΦ₂/6 -qΦ₁/6 2q/3 -q/3
G₂[ζ₃] │qΦ₁²Φ₂²/3 -qΦ₁Φ₂/3 q/3 qΦ₂/3 -qΦ₁/3 q/3 (-ζ₃+2ζ₃²)q/3
G₂[ζ₃²]│qΦ₁²Φ₂²/3 -qΦ₁Φ₂/3 q/3 qΦ₂/3 -qΦ₁/3 q/3 (2ζ₃-ζ₃²)q/3
│ G₂_(ζ₃²) (Ã₁)₃
───────┼──────────────────────────
φ₁‚₀ │ 1 1
φ₁‚₆ │ . .
φ′₁‚₃ │ q/3 (2q²+1)q/3
φ″₁‚₃ │ q/3 -qΦ₁Φ₂/3
φ₂‚₁ │ -q/3 (2q+1)qΦ₂/6
φ₂‚₂ │ . qΦ₂/2
G₂[-1] │ . -qΦ₁/2
G₂[1] │ -q/3 (2q-1)qΦ₁/6
G₂[ζ₃] │ (2ζ₃-ζ₃²)q/3 -qΦ₁Φ₂/3
G₂[ζ₃²]│(-ζ₃+2ζ₃²)q/3 -qΦ₁Φ₂/3
```

`Chevie.Ucl.distinguished_parabolics`

— Method`distinguished_parabolics(W)`

the list of distinguished parabolic subgroups of `W`

in the sense of Richardson, each given as the list of the corresponding indices. The distinguished unipotent conjugacy classes of `W`

consist of the dense unipotent orbit in the unipotent radical of such a parabolic.

```
julia> W=coxgroup(:F,4)
F₄
julia> distinguished_parabolics(W)
4-element Vector{Vector{Int64}}:
[]
[3]
[1, 3]
[1, 3, 4]
```

`Chevie.Ucl.induced_linear_form`

— Method`induced_linear_form(W, K, h)`

This routine can be used to find the Richardson-Dynkin diagram of the class in the algebraic group `𝐆`

which contains a given unipotent class of a reductive subgroup of maximum rank `𝐒`

of `𝐆`

.

It takes a linear form on the roots of `K`

, defined by its value on the simple roots (these values can define a Dynkin-Richardson diagram); then extends this linear form to the roots of `𝐆`

by `0`

on the orthogonal of the roots of `K`

; and finally conjugates the resulting form by an element of the Weyl group so that it takes positive values on the simple roots.

```
julia> W=coxgroup(:F,4)
F₄
julia> H=reflection_subgroup(W,[1,3])
F₄₍₁₃₎=A₁×Ã₁Φ₁²
julia> induced_linear_form(W,H,[2,2])
4-element Vector{Int64}:
0
1
0
0
julia> uc=UnipotentClasses(W);
julia> uc.classes[4].prop
Dict{Symbol, Any} with 8 entries:
:dynkin => [0, 1, 0, 0]
:dimred => 6
:red => A₁×A₁
:Au => .
:balacarter => [1, 3]
:rep => [1, 3]
:dimunip => 18
:AuAction => A₁×A₁
julia> uc.classes[4]
UnipotentClass(A₁+Ã₁)
```

The example above shows that the class containing the regular class of the Levi subgroup of type `A₁× Ã₁`

is the class |A1+~A1|.

`Chevie.Ucl.special_pieces`

— Method'special_pieces(<uc>)'

The special pieces forme a partition of the unipotent variety of a reductive group `𝐆`

which was defined the first time in Spaltenstein1982 chap. III as the fibers of `d^2`

, where `d`

is a "duality map". Another definition is as the set of classes in the Zariski closure of a special class and not in the Zariski closure of any smaller special class, where a special class in the support of the image of a special character by the Springer correspondence.

Each piece is a union of unipotent conjugacy classes so is represented in Chevie as a list of class numbers. Thus the list of special pieces is returned as a list of lists of class numbers. The list is sorted by increasing piece dimension, while each piece is sorted by decreasing class dimension, so the special class is listed first.

```
julia> W=coxgroup(:G,2)
G₂
julia> special_pieces(UnipotentClasses(W))
3-element Vector{Vector{Int64}}:
[1]
[4, 3, 2]
[5]
julia> special_pieces(UnipotentClasses(W,3))
3-element Vector{Vector{Int64}}:
[1]
[4, 3, 2, 6]
[5]
```

The example above shows that the special pieces are different in characteristic 3.