Chevie.Uch — Module

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

To construct T one could equivalently do

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

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

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

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

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

julia> v*v
6

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

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

julia> UnipotentCharacters(complex_reflection_group(4))
UnipotentCharacters(G₄)
┌─────┬────────────────────────────────────────┐
│γ    │n₀            Deg(γ)    Feg Fr(γ)  label│
├─────┌─────────────────────────────────────────
│φ₁‚₀ │ 1                 1      1     1       │
│φ₁‚₄ │ 2  -√-3q⁎Ί″₃Ί₄Ί″₆/6     q⁎     1   1∧ζ₆│
│φ₁‚₈ │ 3   √-3q⁎Ί′₃Ί₄Ί′₆/6     q⁞     1 -1∧ζ₃²│
│φ₂‚₅ │ 4         q⁎Ί₂²Ί₆/2   q⁵Ί₄     1  1∧ζ₃²│
│φ₂‚₃ │ 5 -ζ₃√-3qΊ″₃Ί₄Ί′₆/3   q³Ί₄     1  1∧ζ₃²│
│φ₂‚₁ │ 6 ζ₃²√-3qΊ′₃Ί₄Ί″₆/3    qΩ₄     1   1∧ζ₃│
│φ₃‚₂ │ 7            q²Ί₃Ί₆ q²Ί₃Ί₆     1       │
│Z₃:2 │ 8     -√-3qΩ₁Ω₂Ω₄/3      0   ζ₃² ζ₃∧ζ₃²│
│Z₃:11│ 9    -√-3qΩ₁Ω₂Ω₄/3      0   ζ₃² ζ₃∧ζ₆⁵│
│G₄   │10        -q⁎Ί₁²Ί₃/2      0    -1  ζ₆∧-1│
└─────┮────────────────────────────────────────┘
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 names of the unipotent characters. The possible columns are numbered as follows:

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

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

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

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

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

julia> xdisplay(uc;cols=[1,4])
UnipotentCharacters(B₂)
┌───┬───────────┐
│γ  │n₀   Symbol│
├───┌────────────
│11.│ 1   (12,0)│
│1.1│ 2   (02,1)│
│.11│ 3 (012,12)│
│2. │ 4     (2,)│
│.2 │ 5   (01,2)│
│B₂ │ 6   (012,)│
└───┮───────────┘
Base.show — 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 — Method

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

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

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.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 CycPols. It is faster than CycPol.(degrees(uc)).

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

julia> CycPoldegrees(UnipotentCharacters(W))
10-element Vector{CycPol{Rational{Int64}}}:
 1
 q⁶
 qΩ₃Ω₆/3
 qΩ₃Ω₆/3
 qΊ₂²Ί₃/6
 qΊ₂²Ί₆/2
 qΊ₁²Ί₃/2
 qΊ₁²Ί₆/6
 qΊ₁²Ί₂²/3
 qΊ₁²Ί₂²/3
Chevie.Uch.FixRelativeType — Method

fix 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 — Module

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

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.Algebras — Module

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

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

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

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

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

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

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

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

julia> Algebras.injection(A)(X(1,2,3))
e_+e₄+e₃₄+e₂₃₄+e₁₂₃₄+e₂₁₂₃₄+e₃₂₁₂₃₄+e₄₃₂₁₂₃₄
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]
Chevie.Fact — Module

Factoring 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.Format — Module

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

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

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

We have versions of display functions which use implicitely rio:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Chevie.Format.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.Format.joindigits — Function

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

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

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

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

julia> joindigits([1,10,3,5],"[]";sep="-")
"[1-10-3-5]"
Chevie.Format.ordinal — Method

ordinal(n::Integer)

string for an ordinal number respecting english syntax.

julia> ordinal(201)
"201st"

julia> ordinal(202)
"202nd"

julia> ordinal(203)
"203rd"

julia> ordinal(204)
"204th"
Chevie.Format.rio — Function

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

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

Chevie.Format.showtable — Method

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

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

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

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

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

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

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

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

Chevie.Format.xrepr — Method

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

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 similarly giving the dual roots Ί^⊂ Y=Y(𝐓).

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

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

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

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

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

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

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

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

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

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

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

Semisimple elements

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

julia> diagram(W)
       ————5————
      /         \
Ã₄   1———2———3———4
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.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, which is represented as a group of permutations of the set of simple roots enriched by the lowest root of each irreducible component. The definition we take of the fundamental group of a (not necessarily semisimple) reductive group is (P∩ Y(𝐓))/Q where P is the coweight lattice (the dual lattice in Y(𝐓)⊗ ℚ of the root lattice) and Q is the coroot latice. The bijection between elements of P/Q and diagram automorphisms is explained in the context of non-irreducible groups for example in §3.B Bonnafé2005.

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

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

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

julia> fundamental_group(W)
Group(Perm{Int16}[])
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]
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 C=transpose(cartan(W)). The property specifying the :chosenAdaptedBasis is that the Hermite normal form of C*chosenAdaptedBasis is almost in Smith normal form (it is diagonal but the diagonal entries may be permuted compared to the Smith normal form; the non-trivial entries are in the positions corresponding to the generators of the fundamental group as indicated by :decompositions).

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

  :AdjointFundamentalGroup => [(1,12,2), (4,14)]
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₂
gl₃

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

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

Let ℋ be the Iwahori-Hecke algebra of a Coxeter system (W,S), with quadratic relations (Tₛ-uₛ₀)(Tₛ-uₛ₁)=0 for s∈ S. If -uₛ₀uₛ₁ has a square root wₛ, we can scale the basis Tₛ to get a new basis tₛ=-Tₛ/wₛ with quadratic relations (tₛ-vₛ)(tₛ+vₛ⁻¹)=0 where vₛ=wₛ/uₛ₁. The most general case when Kazhdan-Lusztig bases and polynomials can be defined is when the parameters vₛ belong to a totally ordered abelian group Γ for multiplication, see Lusztig1983. We set Γ⁺= {γ∈ Γ∣γ>0} and Γ⁻={γ⁻¹∣γ∈ Γ⁺}={γ∈ Γ∣γ<0}.

Thus we assume ℋ defined over the ring â„€[Γ], the group algebra of Γ over â„€, and the quadratic relations of ℋ associate to each s∈ S a vₛ∈ Γ⁺ such that (tₛ-vₛ)(tₛ+vₛ⁻¹)=0. We also set qₛ=vₛ² and define the basis Tₛ=vₛtₛ with quadratic relations (Tₛ-qₛ)(Tₛ+1)=0; for w∈ W with reduced expression w=s₁
sₙ we define $q_w∈ Γ⁺$ by $q_w^Âœ=v_{s₁}
v_{sₙ}$ and let $q_w=(q_w^Âœ)²$; we have $T_w=q_w^Âœt_w$.

We define the bar involution on ℋ by linearity: on â„€[Γ] we define it by $\overline{∑_{γ∈ Γ}a_γγ}= ∑_{γ∈ Γ} a_γ γ⁻¹$ and we extend it to ℋ by $\overline T_s=T_s^{-1}$ (equivalently $\overline t_s=t_s^{-1}$). Then the Kazhdan-Lusztig basis $C^′_w$ is defined as the only basis of ℋ stable by the bar involution and congruent to $t_w$ modulo $∑_{w∈ W}Γ⁻.t_w$.

The basis $C^′_w$ can be computed as follows. We define elements $R_{x,y}$ of â„€[Γ] by $T_y⁻¹=∑_x \overline{R_{x,y⁻¹}} q_x⁻¹T_x$. We then define inductively the Kazhdan-Lusztig polynomials (in this general context we should say the Kazhdan-Lusztig elements of â„€[Γ], which belong to the subalgebra of â„€[Γ] generated by the qₛ) by $P_{x,w}=τ_{≀(q_w/q_x)^Âœ} (∑_{x<y≀w}R_{x,y}P_{y,w})$ where τ is the truncation: $τ_≀\nu ∑_{γ∈ Γ} a_γγ= ∑_{γ≀\nu}a_γγ$; the induction is thus on decreasing x for the Bruhat order and starts at $P_{w,w}=1$. We have then $C^′_w=∑_y q_w^{-1/2} P_{y,w}T_y$.

The Chevie code for the Kazhdan-Lusztig bases C, D, C', D', was originally written by Andrew Mathas around 1994, who also contributed to the design of bases of Iwahori-Hecke algebras and implemented some other bases, such as the Murphy basis. Our code evolved from that code. The code for the case of unequal parameters was written around 1999 by F.Digne and J.Michel. The Kazhdan-Lusztig bases are computed starting from the C′ basis.

When the â„€[Γ] is a Laurent polynomial ring the bar operation is taking the inverse of the variables, and truncation is keeping terms of degree smaller or equal to that of Îœ. It is possible to use arbitrary groups Γ as long as methods bar:$∑_{γ∈ Γ} a_γγ↊ ∑_{γ∈ Γ} a_γγ⁻¹$, positive_part : $∑_{γ∈ Γ} a_γγ↊ ∑_{γ≥ 1} a_γγ$ and negative_part: $∑_{γ∈ Γ} a_γγ ↩ ∑_{γ≀ 1} a_γγ$ have been defined on â„€[Γ]. These operations will be used internally by the programs to compute Kazhdan-Lusztig bases.

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

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

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

see also the functions elements, character, representation and Wgraph for left cells. The operations length, in (which refer to elements) and == (which compares Duflo involutions) are also defined for left cells. When character(c) has been computed, then c.a also has been bound which holds the common value of Lusztig's a-function for the elements of c and the irreducible constituents of character(c).

finally, benchmarks

julia> function test_kl(W)
         q=Pol(); H=hecke(W,q^2,rootpara=q)
         C=Cpbasis(H); T=Tbasis(H)
         [T(C(w)) for w in elements(W)]
       end
test_kl (generic function with 1 method)

julia> @btime test_kl(coxgroup(:F,4));  #julia 1.8
1.332 s (13934392 allocations: 2.27 GiB)

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

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

Another benchmark:

function test_kl2(W)
  el=elements(W)
  [KLPol(W,x,y) for x in el, y in el]
end

test_kl2 (generic function with 1 method)

julia>@btime test_kl2(coxgroup(:F,4)); # julia 1.9
4.307 s (42294917 allocations: 5.24 GiB)

in GAP3 the following function takes 42s for F4

test_kl2:=function(W)local el;
  el:=Elements(W);
  List(el,x->List(el,y->KazhdanLusztigPolynomial(W,x,y)));
end;
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
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 — Module

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

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

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

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

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

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

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

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

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

julia> NF(root(3),root(5)) # here the stabilizer needs 2 generators
NF(60,-11₆₀,-1₆₀)
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₅)
Chevie.Cosets — Module

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

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

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

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

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

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

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

Spets

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

julia> W=complex_reflection_group(14)
G₁₄

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

julia> RF=spets(R,W(1)) # should be ²G₅(√6)
G₁₄₍₂₄₎=²G₅
julia> diagram(RF)
ϕ acts as (1,2) on the component below
③ ══③ G₅
1   2
julia> degrees(RF)
2-element Vector{Tuple{Int64, Cyc{Int64}}}:
 (6, 1)
 (12, -1)

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

julia> twistings(W,[2,4])
2-element Vector{Spets{FiniteCoxeterSubGroup{Perm{Int16},Int64}}}:
 B₂₍₂₄₎=A₁×A₁
 B₂₍₂₄₎=(A₁A₁)
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 — Method

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

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

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

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

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

julia> spets("4G333")
G₃‚₃‚₃₍₂‚₁₂‚₁₁‚₁₆‚₅₃‚₁₀‚₄₃‚₃₆₎=G₃‚₃‚₃₍₁‚₂‚₃‚₃₂‚₁₆‚₃₆‚₃₀‚₁₀₎
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, 2I2, 3D4, 3D4sc, 3gpin8, CE6, CE7, E6, E6sc, E7, E7sc, E8, F4, G2, cso, csp, gl, gpin, gpin-, halfspin, pgl, pso, pso-, psp, psu, ree, sl, slmod, so, so-, sp, spin, spin-, su, suzuki, tgl, triality, u

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

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

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

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

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

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

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

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

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

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

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

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

Examples

julia> W=coxsym(4)
𝔖 ₄

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

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

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

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

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

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

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


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

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

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 returnsnothingforone(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]
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 — Module

Characters and conjugacy classes of complex reflection groups.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  • For G₂₇:

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

  • For G₂₉:

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

  • For G₃₁:

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

  • For G₃₃:

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

  • For G₃₄:

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

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

  • For G₅:

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

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

  • For G₇:

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

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

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

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

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

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

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

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

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

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

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

Chevie.Chars.CharTable — Type

CharTable 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 is an object with various entries describing properties of the irreducible characters of W. This object prints at the Repl or in Pluto or Jupyter as a table synthesizing most information.

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

julia> charinfo(coxgroup(:G,2)).charparams
6-element Vector{Vector{Vector{Int64}}}:
 [[1, 0]]
 [[1, 6]]
 [[1, 3, 1]]
 [[1, 3, 2]]
 [[2, 1]]
 [[2, 2]]
julia> charinfo(coxgroup(:G,2))
┌──┬──────────────────────────────────────────────────────────┐
│n0│ name ext b B a A spaltenstein lusztig              symbol│
├──┌───────────────────────────────────────────────────────────
│1 │ φ₁‚₀  Id 0 0 0 0            1       1       (0,0,0,0,0,2)│
│2 │ φ₁‚₆ det 6 6 6 6            ε       ε (01,01,01,01,01,12)│
│3 │φ′₁‚₃     3 3 1 5           εₗ      ε′            (0,0,1+)│
│4 │φ″₁‚₃     3 3 1 5          ε_c      ε″            (0,0,1-)│
│5 │ φ₂‚₁  Λ¹ 1 5 1 5           Ξ′      Ξ′       (0,0,0,0,1,1)│
│6 │ φ₂‚₂     2 4 1 5           Ξ″      Ξ″       (0,0,0,1,0,1)│
└──┮──────────────────────────────────────────────────────────┘

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

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

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

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

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

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

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

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

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

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

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

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

julia> charinfo(complex_reflection_group(24))
┌──┬─────────────────────┐
│n0│ name ext  b  B  a  A│
├──┌──────────────────────
│1 │ φ₁‚₀  Id  0  0  0  0│
│2 │φ₁‚₂₁ det 21 21 21 21│
│3 │ φ₃‚₈      8 18  8 20│
│4 │ φ₃‚₁  Λ¹  1 11  1 13│
│5 │φ₃‚₁₀  Λ² 10 20  8 20│
│6 │ φ₃‚₃      3 13  1 13│
│7 │ φ₆‚₂      2 12  1 13│
│8 │ φ₆‚₉      9 19  8 20│
│9 │ φ₇‚₆      6 18  6 18│
│10│ φ₇‚₃      3 15  3 15│
│11│ φ₈‚₄      4 16  4 17│
│12│ φ₈‚₅      5 17  4 17│
└──┮─────────────────────┘
hgal=(11,12)
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 is an object with various entries describing properties of the conjugacy classes of W. This object prints at the Repl or in Pluto or Jupyter as a table synthesizing most information.

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

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

The table contains the columns:

  • name, corresponding to the field .classnames: strings describing the conjugacy classes, made out of the information in :classparams.
  • length, corresponding to the field .classes, is the number of elements in the conjugacy class.
  • order, corresponding to the field .orders, is the order of elements in the conjugacy class.
  • word, corresponding to the field .classtext, describes a word in the generators for the representatives of each conjugacy class. Each word is a list of integers where the generator W(i) is represented by the integer i. For finite Coxeter groups, it is the same as word.(Ref(W),classreps(W)), and each such representative is of minimal length in its conjugacy class and is a "very good" element in the sense of GeckMichel1997.
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 "using GAP"
Induction table from Group((1,2),(3,4)) to Group((1,2),(2,3),(3,4))
┌───┬───────────────┐
│   │X.1 X.2 X.3 X.4│
├───┌────────────────
│X.1│  .   1   .   .│
│X.2│  .   1   1   1│
│X.3│  1   1   .   .│
│X.4│  1   .   1   1│
│X.5│  1   .   .   .│
└───┮───────────────┘
julia> g=coxgroup(:G,2)
G₂

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

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

IO attributes can be transmitted to the table format method

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

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

induction_table also works for spets (reflection cosets).

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
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.Murphy — Module

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

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

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

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

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

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

Chevie.Murphy.SpechtModules — Constant

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

Chevie.Families — Module

Families of unipotent characters

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

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

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

julia> uc=UnipotentCharacters(W);

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

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

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

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

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.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)) # needs "using GAP"
Family(drinfeld_double(coxsym(3)),8)
Drinfeld double D(coxsym(3))
┌───────┬────────────────────────────────────────────────────┐
│label  │eigen                                               │
├───────┌─────────────────────────────────────────────────────
│(1,1)  │    1  1//6  1//3 1//6 -1//2 -1//2  1//3  1//3  1//3│
│(1,X.2)│    1  1//3  2//3 1//3     .     . -1//3 -1//3 -1//3│
│(1,X.3)│    1  1//6  1//3 1//6  1//2  1//2  1//3  1//3  1//3│
│(21,1) │    1 -1//2     . 1//2  1//2 -1//2     .     .     .│
│(21,-1)│   -1 -1//2     . 1//2 -1//2  1//2     .     .     .│
│(3,1)  │    1  1//3 -1//3 1//3     .     .  2//3 -1//3 -1//3│
│(3,ζ₃) │   ζ₃  1//3 -1//3 1//3     .     . -1//3 -1//3  2//3│
│(3,ζ₃²)│  ζ₃²  1//3 -1//3 1//3     .     . -1//3  2//3 -1//3│
└───────┮────────────────────────────────────────────────────┘

julia> drinfeld_double(coxsym(3);lu=true)
Family(Ldrinfeld_double(coxsym(3)),8)
Lusztig′sDrinfeld double D(coxsym(3))
┌───────┬────────────────────────────────────────────────────┐
│label  │eigen                                               │
├───────┌─────────────────────────────────────────────────────
│(1,1)  │    1  1//6  1//3 1//6 -1//2 -1//2  1//3  1//3  1//3│
│(1,X.2)│    1  1//3  2//3 1//3     .     . -1//3 -1//3 -1//3│
│(1,X.3)│    1  1//6  1//3 1//6  1//2  1//2  1//3  1//3  1//3│
│(21,1) │    1 -1//2     . 1//2  1//2 -1//2     .     .     .│
│(21,-1)│   -1 -1//2     . 1//2 -1//2  1//2     .     .     .│
│(3,1)  │    1  1//3 -1//3 1//3     .     .  2//3 -1//3 -1//3│
│(3,ζ₃) │   ζ₃  1//3 -1//3 1//3     .     . -1//3  2//3 -1//3│
│(3,ζ₃²)│  ζ₃²  1//3 -1//3 1//3     .     . -1//3 -1//3  2//3│
└───────┮────────────────────────────────────────────────────┘
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.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áµ¢)isdual to báµ¢ for the linear form (báµ¢,bⱌ)=Cáµ¢,ⱌ,σ₍ₛ₎`.

julia> W=complex_reflection_group(4)
G₄

julia> uc=UnipotentCharacters(W);f=uc.families[4];

julia> A=fusion_algebra(fourier(f),1)
Fusion Algebra dim.5

julia> b=basis(A)
5-element Vector{AlgebraElt{Chevie.Families.FusionAlgebra, Int64}}:
 B₁
 B₂
 B₃
 B₄
 B₅

julia> b*permutedims(b)
5×5 Matrix{AlgebraElt{Chevie.Families.FusionAlgebra, Int64}}:
 B₁  B₂      B₃      B₄        B₅
 B₂  -B₄+B₅  B₁+B₄   B₂-B₃     B₃
 B₃  B₁+B₄   -B₄+B₅  -B₂+B₃    B₂
 B₄  B₂-B₃   -B₂+B₃  B₁+B₄-B₅  -B₄
 B₅  B₃      B₂      -B₄       B₁

julia> CharTable(A)
CharTable(Fusion Algebra dim.5)
┌─┬─────────────────┐
│ │1    2    3  4  5│
├─┌──────────────────
│1│1  √-3 -√-3  2 -1│
│2│1    1    1  .  1│
│3│1   -1   -1  .  1│
│4│1    .    . -1 -1│
│5│1 -√-3  √-3  2 -1│
└─┮─────────────────┘
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
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(conj(0011),[4, 3, 2])
conj(imprimitive family)
┌─────┬──────────────────────────────┐
│label│eigen      1        2        3│
├─────┌───────────────────────────────
│1    │   ζ₃ -√-3/3   -√-3/3    √-3/3│
│2    │    1 -√-3/3 -ζ₃√-3/3 ζ₃²√-3/3│
│3    │    1  √-3/3 ζ₃²√-3/3 -ζ₃√-3/3│
└─────┮──────────────────────────────┘
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 — Module

Factoring 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 — Module

This module implements Hecke algebras associated to finite complex reflection groups and arbitrary Coxeter groups (these algebras are called Iwahori-Hecke algebras in this last case), and also implements the character tables, Schur elements and representations of Hecke algebras for finite groups. For Iwahori-Hecke algebras and G(d,1,1) this module also implements the standard T basis; see the module KLfor Kazhdan-Lusztig bases.

Let (W,S) be a Coxeter system and let mₛₜ be the order of st for s,t∈ S. Let R be a commutative ring with 1 and for s∈ S let uₛ₀,uₛ₁∈ R be elements which depend only on the conjugacy class of s in W (this is the same as requiring that uₛᵢ=uₜᵢ whenever mₛₜ is odd). The Iwahori-Hecke algebra of W over R with parameters uₛᵢ is a deformation of the group algebra of W over R defined as follows: it is the unitary associative R-algebra generated by elements Tₛ, s∈ S subject to the relations:

$(Tₛ-uₛ₀)(Tₛ-uₛ₁)=0$ for all s∈ S (the quadratic relations)

$TₛTₜTₛ
= TₜTₛTₜ
$ with mₛₜ factors on each side (the braid relations)

If uₛ₀=1 and uₛ₁=-1 for all s then the quadratic relations become Tₛ²=1 and the deformation of the group algebra is trivial.

Since the generators Tₛ satisfy the braid relations, H is in fact a quotient of the group algebra of the braid group associated with W. The braid relations also imply that for any reduced expression s_1⋯ s_m of w ∈ W the product Tₛ_1⋯ Tₛ_m has the same value, that we denote T_w. We have T_1=1; if one of the uₛᵢ is invertible, the {T_w}_{w∈ W} form an R-basis of the Iwahori-Hecke algebra which specializes to the canonical basis of the group algebra R[W] for uₛ₀↩1 and uₛ₁↩-1.

When one of the uₛᵢ is invertible, the structure constants (the decomposion of a product T_vT_w) in the T_w basis are obtained as follows. Choose a reduced expression for v, say v=s_1 ⋯ s_k and apply inductively the formula:

$T_sT_w=T_{sw}$ if l(sw)=l(w)+1

$T_sT_w=-uₛ₀uₛ₁T_{sw}+(uₛ₀+uₛ₁)T_w$ if l(sw)=l(w)-1.

If one of uₛ₀ or uₛ₁ is invertible in R, for example uₛ₁, then by changing the generators to T′ₛ=-Tₛ/uₛ₁, and setting qₛ=-uₛ₀/uₛ₁, the braid relations do no change (since when mₛₜ is odd we have uₛᵢ=uₜᵢ) but the quadratic relations become (T′ₛ-qₛ)(T′ₛ+1)=0. This normalisation is the most common form considered in the literature. Another common form in the context of Kazhdan-Lusztig theory, is uₛ₀=√qₛ and uₛ₁=-√qₛ⁻¹. The form provided, with two parameters per generator, is often useful, for instance when constructing the Jones polynomial. If for all s we have uₛ₀=q, uₛ₁=-1 then we call the corresponding algebra the "one-parameter" or "Spetsial" Iwahori-Hecke algebra associated with W.

For some Iwahori-Hecke algebras the character table, and in general Kazhdan-Lusztig bases, require a square root of -uₛ₀uₛ₁. These square roots can be specified with the keyword rootpara when constructing the algebra; after this the function rootpara(H) will return the chosen roots. If not specified, we try to extract roots automatically when needed; rootpara(H) informs on the choices made. Note that some mathematical results require an explicit choice of one of the two possible roots which cannot be automatically made thus require a keyword initialisation.

There is a universal choice for R and uₛᵢ: Let uₛᵢ:s∈ S,i∈[0,1] be indeterminates such that uₛᵢ=uₜᵢ whenever mₛₜ is odd, and let A=â„€[uₛᵢ] be the corresponding polynomial ring. Then the Hecke algebra H of W over A with parameters uₛᵢ is called the generic Iwahori-Hecke algebra of W. Any Hecke algebra H₁ with parameters vₛᵢ can be obtained by specialization from H, since there is a unique ring homomorphism f:A → R such that f(uₛᵢ)=vₛᵢ for all i. Then via f we can identify H₁ to $R⊗ _A H$.

Certain invariants of the irreducible characters of the one-parameter Hecke algebra play a special role in the representation theory of the underlying finite Coxeter groups, namely the a- and A-invariants. For basic properties of Iwahori-Hecke algebras and their relevance to the representation theory of finite groups of Lie type, see for example Curtis and Reiner 1987 Sections~67 and 68.

In the following example, we compute the multiplication table for the 0-Iwahori–Hecke algebra associated with the Coxeter group of type A_2.

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

julia> H=hecke(W,0)            # One-parameter algebra with `q=0`
hecke(A₂,0)

julia> T=Tbasis(H);            # Create the `T` basis

julia> b=T.(elements(W))       # the basis
6-element Vector{HeckeTElt{HeckeAlgebra{Int64, Perm{Int16}, FiniteCoxeterGroup{Perm{Int16},Int64}}, Int64, Perm{Int16}}}:
 T.
 T₁
 T₂
 T₁₂
 T₂₁
 T₁₂₁

julia> b*permutedims(b)       # multiplication table
6×6 Matrix{HeckeTElt{HeckeAlgebra{Int64, Perm{Int16}, FiniteCoxeterGroup{Perm{Int16},Int64}}, Int64, Perm{Int16}}}:
 T.    T₁     T₂     T₁₂    T₂₁    T₁₂₁
 T₁    -T₁    T₁₂    -T₁₂   T₁₂₁   -T₁₂₁
 T₂    T₂₁    -T₂    T₁₂₁   -T₂₁   -T₁₂₁
 T₁₂   T₁₂₁   -T₁₂   -T₁₂₁  -T₁₂₁  T₁₂₁
 T₂₁   -T₂₁   T₁₂₁   -T₁₂₁  -T₁₂₁  T₁₂₁
 T₁₂₁  -T₁₂₁  -T₁₂₁  T₁₂₁   T₁₂₁   -T₁₂₁

Thus, we work with algebras with arbitrary parameters. We will see that this also works on the level of characters and representations.

For general complex reflection groups, the picture is similar. The Hecke algebras are deformations of the group algebras, generalizing those for real reflection groups.

The definition is as a quotient of the algebra of the braid group. We assume now that W is a finite reflection group in the complex vector space V. The braid group associated is the fundamental group Π₁ of the space  $(V-\bigcup_{H\in\mathcal H} H)/W$, where $\mathcal H$ is the set of reflecting hyperplanes of W. This group is generated by braid reflections, elements which by the natural map from the braid group to the reflection group project to distinguished reflections. The braid reflections which project to a given W-orbit of reflections are conjugate. Let 𝐬 be a representative of such a conjugacy class of braid reflections, let e be the order of the image of 𝐬 in W, and let $u_{𝐬,0},
,u_{𝐬,e-1}$ be indeterminates. The generic Hecke algebra of W is the $â„€[u_{𝐬,i}^{± 1}]_{𝐬,i}$-algebra quotient of the braid group algebra by the relations $(𝐬-u_{𝐬,0})
(𝐬-u_{𝐬,e-1})=0$, and an arbitrary Hecke algebra for W is an algebra obtained from this generic algebra by specializing some of the parameters.

The generic Hecke algebras are explicitely described by a presentation of the braid group. The braid group can be presented by homogeneous relations in the braid reflections, called braid relations, described in Broué-Malle-Rouquier 1998 and Bessis-Michel 2003 (some of which were obtained using the VKCURVE GAP3-package, also ported to Julia). Furthermore, these presentations are such that the reflection group is presented by the same relations, plus relations describing the order of the generating reflections, called the order relations. Thus the Hecke algebra has a presentation similar to that of W, with the same braid relations but the order relations replaced by a deformed version.

If S⊂ W is the set of distinguished reflections of W which lift to generating braid reflections in the braid group, for each conjugacy class of an s of order e we take indeterminates uₛ₀,
,uₛₑ₋₁. Then the generic Hecke algebra is the $â„€[uₛᵢ^{±1}]ₛᵢ$-algebra H with generators T_s for each s∈ S presented by the braid relations and the deformed order relations $(T_s-u_{s,0})
(T_s-u_{s,e-1})=0$.

Ariki, Koike and Malle have computed the character table of some of these algebras, including those for all 2-dimensional reflection groups, see Broué-Malle 1993 and Malle 1996; our data has models of all representation and character tables for real reflection groups; it contains the same for imprimitive groups and for primitive groups of dimension 2 and 3 (these last representations have been computed in Malle-Michel 2010) and contains also models and character tables computed by Michel for G₂₉ and G₃₃; it contains also partial lists of representations and partial character tables for the remaining groups G₃₁,G₃₂ and G₃₄, computed by Malle and Michel for G₃₂ and by Michel for the other two algebras.

The quotient of the Hecke algebra obtained by the specialisation $u_{𝐬,i}↩ ζₑⁱ$ is isomorphic to the group algebra of W. It was conjectured for 20 years that over a splitting ring the Hecke algebra is itself isomorphic to the group algebra of W over the same ring. This was called the freeness conjecture since the main problem is to show that the Hecke algebra is free of dimension |W|. This has finally been proved in 2019 thanks to the work of many people including Marin, Pfeiffer, Chavli and Tsuchioka for exceptional groups. Along the way it has been proven that there exists a set {b_w}_{w∈ W} of elements of the Braid group such that b_1=1 and b_w maps to w by the natural quotient map, such that their images T_w form a basis of the Hecke algebra.

It is conjectured that such a basis T_w can be chosen such that additionnaly the linear form t defined by t(T_w)=0 if w≠ 1 and t(1)=1 is a symmetrizing form for the symmetric algebra H. This is well known for all real reflection groups and has been proved in Malle-Mathas 1998 for imprimitive reflection groups and in Malle-Michel 2010 for some primitive groups of dimension 2 and 3. Chlouveraki and Chavli have handled some other 2-dimensional cases. For each irreducible character φ of H we define the Schur element Sᵩ associated to φ by the condition that for any element T of H we have t(T)=∑ᵩ φ(T)/Sᵩ. It can be shown that the Schur elements are Laurent polynomials, and they do not depend on the choice of a basis having the above property. Malle has computed these Schur elements, assuming the above conjecture; they are in the Chevie data.

See the function hecke for various ways of specifying the parameters of a Hecke algebra. Look also at the docstrings of central_monomials, char_values, class_polynomials, schur_elements, isrepresentation, factorized_schur_elements, and at the methods for Hecke algebras of CharTable, representations, reflrep.

Taking apart Hecke elements is done with the functions getindex, setindex!, keys, values, iterate.

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

julia> T=Tbasis(H);

julia> h=T(1,2)^2
qT₂₁+(q-1)T₁₂₁

julia> length(h) # h has 2 terms
2

julia> h[W(2,1)] # coefficient of W(2,1)
Pol{Int64}: q

julia> collect(h) # pairs perm=>coeff
2-element Vector{Any}:
  (1,2,6)(3,4,5) => q
 (1,5)(2,4)(3,6) => q-1

julia> collect(values(h)) # the coefficients
2-element Vector{Pol{Int64}}:
 q
 q-1

julia> collect(keys(h)) # the corresponding Perms
2-element Vector{Perm{Int16}}:
 (1,2,6)(3,4,5)
 (1,5)(2,4)(3,6)

julia> h[W(2,1)]=Pol(3)
Pol{Int64}: 3

julia> h
3T₂₁+(q-1)T₁₂₁

finally, benchmarks on julia 1.8

julia> function test_w0(n)
         W=coxgroup(:A,n)
         Tbasis(hecke(W,Pol(:q)))(longest(W))^2
       end
test_w0 (generic function with 1 method)

julia> @btime test_w0(7);
   97.210 ms (1776476 allocations: 127.52 MiB)

in GAP3 the analogous function takes 920ms

test_w0:=function(n)local W,T,H;
  W:=CoxeterGroup("A",n);H:=Hecke(W,X(Rationals));T:=Basis(H,"T");
  return T(LongestCoxeterWord(W))^2;
end;
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 — Type

A FactSchur representing a Schur element of the form M∏ᵩφ(Mᵩ) (see factorized_schur_element) is a struct with a field factor which holds the monomial M, and a field vcyc which holds a list of NamedTuples describing each factor Mᵩ in the product. An element of vcyc representing a term φ(Mᵩ) is itself a NamedTuple with fields monomial holding Mᵩ (as an Mvp with a single term), and a field pol holding a CycPol (see CycPol) representing φ.

A few operations are implemented for FactSchur, like *, lcm. They can be evaluated partially or completely keeping as much as possible the factored form.

julia> @Mvp x,y; W=crg(4); H=hecke(W,[[1,x,y]])
hecke(G₄,Vector{Mvp{Int64, Int64}}[[1, x, y]])

julia> p=factorized_schur_element(H,[[2,5]])
-x⁻¹y(xy+1)(x-1)Ω₆(xy⁻¹)(y-1)

julia> q=p(;x=E(3)) # partial evaluation
ζ₃²√-3y⁻¹Ί₁Ί₂Ί′₆²(y)

julia> q(;y=2//1)
-9√-3/2

In contrast, the next operation expands p to an Mvp:

julia> HeckeAlgebras.expand(p)
Mvp{Cyc{Rational{Int64}},Rational{Int64}}: -x³y+x³+x²y²-2x²+x²y⁻¹-xy³+2xy-xy⁻¹+y³-2y²+1+x⁻¹y²-x⁻¹y
Chevie.HeckeAlgebras.HeckeCoset — Type

HeckeCosets are Hϕ where H is an Iwahori-Hecke algebra of some Coxeter group W on which the automorphism ϕ of some Spets Wϕ acts by ϕ(T_w)=T_{ϕ(w)}. For Weyl groups, this corresponds to the action of the Frobenius automorphism on the commuting algebra of the induced of the trivial representation from the rational points of some F-stable Borel subgroup to 𝐆 ^F.

julia> WF=rootdatum(:u,3)
u₃

julia> HF=hecke(WF,Pol(:v)^2;rootpara=Pol())
hecke(u₃,v²,rootpara=v)

julia> CharTable(HF)
CharTable(hecke(u₃,v²,rootpara=v))
┌───┬──────────┐
│   │ 111 21  3│
├───┌───────────
│111│  -1  1 -1│
│21 │-2v³  .  v│
│3  │  v⁶  1 v²│
└───┮──────────┘

Thanks to the work of Xuhua He and Sian Nie, 'class_polynomials' also make sense for these cosets. This is used to compute such character tables.

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

This is my attempt to port the Chevie package from GAP3 to Julia. I started this project at the end of 2018 and it is still in flux so some function names or interfaces may still change. Pull requests and issues are welcome.

I have implemented the GAP functionality (infrastructure) needed to make Chevie work. I have already registered most of this infrastructure as separate packages; the following packages are loaded and re-exported so that their functionality is automatically available when you use Chevie. In other words, Chevie is a meta-package for the following packages:

Have a look at the documentation of the above packages to see how to use their features.

I have implemented some other infrastructure which currently resides in Chevie but may eventually become separate packages:

  • factorizing polynomials over finite fields (module FFfac)
  • factorizing polynomials over the rationals (module Fact)
  • Number fields which are subfields of the Cyclotomics (module Nf)

For permutation groups I have often replaced GAP's sophisticated algorithms with naive but easy-to-write methods suitable only for small groups (sufficient for the rest of the package but perhaps not for your needs). Otherwise the infrastructure code is often competitive with GAP, despite using much less code (often 100 lines of Julia replace 1000 lines of C); and I am sure it could be optimised better than I did. Comments on code and design are welcome. For functions that are too inefficient or difficult to implement (such as character tables of arbitrary groups), Chevie uses the GAP package as an extension. This means that if you have the GAP package installed, Chevie will automatically call GAP to implement these functions.

Functions in the Chevie.jl package are often 10 times faster than the equivalent functions in GAP3/Chevie (after the maddeningly long compilation time on the first run –- Julia's TTFP).

The Chevie package currently contains about 95% of the GAP3 Chevie functionality. If you are a user of GAP3/Chevie, the gap function can help you to find the equivalent functionality in Chevie.jl to a Gap3 function: it takes a string and gives you Julia translations of functions in Gap3 that match that string.

julia> gap("words")
CharRepresentationWords  =>  traces_words_mats
CoxeterWords(W[,l])      =>  word.(Ref(W),elements(W[,l]))
GarsideWords             =>  elements

You can then access online help for the functions you have found.

The port to Julia is not complete in the sense that 80% of the code is the data library from Chevie, which was automatically ported by a transpiler so its code is "strange". When the need to maintain the GAP3 and Julia versions simultaneously subsides, I will do a proper translation of the data library, which should give an additional speed boost.

Installing

This is a registered package that can be installed/upgraded in the standard way. For Julia newbies, we will remind you what this is. To install, do this at the REPL command line:

  • enter package mode with ]
  • do the command
(@v1.10) pkg> add Chevie
  • exit package mode with backspace and then do
julia> using Chevie

and you are set up. For first help, type "?Chevie".

To update later to the latest version, do

(@v1.10) pkg> update

Chevie.jl requires julia 1.10 or later.

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.

Chevie.EvalPolRoot — Method

EvalPolRoot(pol, x, n, p) compute pol(p*x^(1/n))

The point of this routine is to avoid unnecessary root extractions during evaluation (e.g., if pol has no terms of odd degree and n=2, then no root extraction is necessary).

this was in lib/util.g but is used only here

Chevie.hooksβ — Method

hooksβ(S,s) the list of all hooks of area less than or equal to s in the Young diagram of the partition with βlist S.

Chevie.stripsβ — Method

stripsβ(S,s) returns as a list of lists of Hooks all broken border strips (union of disjoint hooks) of area less than or equal to s in the Young diagram of the partition with βlist S.

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₃₃
     /^\
② ——② ——② ——② 
1   2   4   5     423423=342342
Chevie.PermRoot — Module

Let V be a vector space over a subfield K of the complex numbers (in Julia the elements of K will be usually represented by Rationals or Cycs).

A complex reflection is an element s∈ GL(V) of finite order whose fixed point set is a hyperplane, the reflecting hyperplane Hₛ of s.

Most of the time we abbreviate "complex reflection" to reflection; in some literature "reflection" is reserved for s of order 2 and otherwise pseudo-reflection is used.

A reflection s has a unique eigenvalue ζₛ not equal to 1, which is a root of unity; if K is a subfield of the real numbers, ζₛ is necessarily equal to -1 and s is of order 2. An eigenvector r∈ V of s for the eigenvalue ζₛ is called a root of s and a linear form rᵛ on V of kernel Hₛ is called a coroot of s. If r and rᵛ are normalized so that rᵛ(r)=1-ζ, then s is the map on V defined by s(x)=x-rᵛ(x)r. Such a normalized root and coroot for s are unique up to scaling the root and inversely scaling the coroot.

A finite complex reflection group W is a finite group generated by complex reflections. Since whenever W contains a reflection s it contains its powers, W is always generated by reflections s such that ζₛ==E(d) where d is the order of s; we can also assume that s is not a power of another reflection with larger order d. Such a reflection is called a distinguished reflection of W; it is a canonical generator of the cyclic subgroup of W centralizing Hₛ. The generators of the complex reflection groups we construct are always distinguished reflections; the set of distinguished reflections are in bijection with the reflecting hyperplanes. In a real reflection group all reflections are distinguished.

It is much more efficient to compute with permutation groups than with matrix groups; hence we use for computing with a finite complex reflection group W a permutation representation on a W-invariant set of root and coroot vectors for reflections of W; that is, a set R of pairs (r,rᵛ)∈ V×Vᵛ invariant by W and such that every distinguished reflection in W is determined by some pair in R (see reflectionMatrix). Using a W-invariant set implies that there may be several pairs determining the same reflection, which differ by roots of unity. This generalizes the usual construction for Coxeter groups (the case K=ℝ) where to each reflection of W is associated two roots, one positive and one negative.

A complex reflection group is irreducible if the representation V is irreducible. For irreducible complex reflection groups, there are at least as many roots for a given reflection as the order of the center of W.

The following methods are always defined for finite complex reflection groups:

  • gens(W): the (distinguished) reflections which generate W, given as permutations of the roots. reflrep(W) gives them as matrices.

  • roots(W): the list of roots of W.

  • coroots(W): the list of coroots, in the same order as the roots.

  • refls(W): a list of distinguished reflections of W, as permutations. This list is of same length as the roots, and its i-th element is the distinguished reflection for the i-th root, so it will have repetitions. unique_refls(W) returns a sublist of 1:length(roots(W)) such that the distinguished reflections around the corresponding roots reach one time only each distinguished reflection of W.

The lists roots, coroots and refls starts with the "generating" ones (those corresponding to gens(W)).

  • simpleroots(W): the generating roots as a matrix.

  • simplecoroots(W): the generating coroots as a matrix.

  • reflections(W) gives a list without repetitions of all reflections of W (not only the distinguished ones), as objects of type Reflection. These objects contain more information on each reflection.

The finite irreducible complex reflection groups have been completely classified by Shephard and Todd, see ShephardTodd1954. They consist of one infinite family G(de,e,r) depending on 3 parameters (which includes the infinite families of Weyl groups), and 34 exceptional groups which have been given by Shephard and Todd names which range from G₄ to G₃₇. These exceptional groups include the exceptional Weyl groups, e.g., coxgroup(:E,8) is the same as G₃₇.

We provide functions to build any finite reflection group, either by giving a list of roots and coroots defining the generating reflections (see PRG), or in terms of the classification (see complex_reflection_group). In the context e.g. of Weyl groups, one wants to describe the particular root system chosen in term of the traditional classification of crystallographic root systems. This is done via calls to the function coxeter_group (see the module Weyl). There is not yet a general theory on how to construct a nice set of roots for a non-real reflection group; the roots chosen here where obtained case-by-case; however, they satisfy several important properties:

  • The generating reflections satisfy braid relations which present the braid group associated to W (see diagram).

  • The field of definition of W is the field K generated by the traces of the elements of W acting on V. It is a theorem that W may be realized as a reflection group over K.

  • The Cartan matrix rᵛ(r') where r and r' runs over the roots and coroots for the generating reflections has entries in the ring ℀ₖ of integers of K, and the other roots (resp. coroots) are linear combinations with coefficients in ℀ₖ of a linearly independent subset of them.

It turns out that all representations of W are defined over the field of definition K (see. Benard1976 and D.~Bessis' thesis). This has been known for a long time in the case K=ℚ, the case of Weyl groups, whose representations are all integral.

julia> W=complex_reflection_group(4)
G₄

julia> gens(W) # as permutations of the 24 roots
2-element Vector{Perm{Int16}}:
 (1,3,9)(2,4,7)(5,10,18)(6,11,16)(8,12,19)(13,15,20)(14,17,21)(22,23,24)
 (1,5,13)(2,6,10)(3,7,14)(4,8,15)(9,16,22)(11,12,17)(18,19,23)(20,21,24)

julia> length(unique(refls(W)))
4

julia> length(refls(W)) # 24=4*(number of roots of unity in ℚ (ζ₃))
24

julia> reflrep(W) # the generators as matrices
2-element Vector{Matrix{Cyc{Rational{Int64}}}}:
 [1 0; 0 ζ₃]
 [√-3/3 -ζ₃²√-3/3; (-3+√-3)/3 -ζ₃√-3/3]

For almost all irreducible complex reflection groups, the generating matrices for W we give have coefficients in the field of definition K. Further, the set of matrices for all elements of W is globally invariant under the Galois group of K/ℚ, thus the Galois action induces automorphisms of W. The exceptions are G₂₂, G₂₇ where the matrices are in a degree two extension of K (this is needed to have a globally invariant model, see MarinMichel2010) and some dihedral groups, as well as H₃ and H₄, where the matrices given (the usual Coxeter reflection representation over K) are not globally invariant (but one can get invariant ones by chevieget(:H4,:InvariantModel)).

julia> braid_relations(W) # as tuples of equal words in the generators
1-element Vector{Tuple{Vector{Int64}, Vector{Int64}}}:
 ([1, 2, 1], [2, 1, 2])

julia> diagram(W) # the same in pictures
③ ——③ G₄
1   2

julia> cartan(W)
2×2 Matrix{Cyc{Rational{Int64}}}:
 ζ₃²√-3     ζ₃²
   -ζ₃²  ζ₃²√-3

julia> simpleroots(W)
2×2 Matrix{Cyc{Rational{Int64}}}:
    0  ζ₃²√-3
 2ζ₃²     ζ₃²

julia> simplecoroots(W)
2×2 Matrix{Cyc{Rational{Int64}}}:
     0      1
 √-3/3  √-3/3

Let SV be the symmetric algebra of V. The invariants of W in SV are called the polynomial invariants of W. If n=dim V, they are generated as a polynomial ring by n homogeneous algebraically independent polynomials f₁,
,fₙ. The polynomials fáµ¢ are not uniquely determined but their degrees are. The fáµ¢ are called the basic invariants of W, and their degrees the reflection degrees of W; the function degrees(W) returns these invariants.

Let I be the ideal generated by the homogeneous invariants of positive degree in SV. Then SV/I is isomorphic to the regular representation of W as a W-module. It is thus a graded (by the degree of elements of SV) version of the regular representation of W. The polynomial which gives the graded multiplicity of a character φ of W in the graded module SV/I is called the fake degree of φ. The function fakedegrees returns these polynomials.

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

julia> fakedegrees(W,Pol(:x))
7-element Vector{Pol{Int64}}:
 1
 x⁎
 x⁞
 x⁷+x⁵
 x⁵+x³
 x³+x
 x⁶+x⁎+x²
Chevie.PermRoot.PRG — Method

PRG(roots,coroots) complex reflection group with given roots and coroots

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.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 Mvps by the function ^.

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

julia> @Mvp x,y,z

julia> i=invariants(W);

julia> map(f->f(x,y),i)
2-element Vector{Mvp{Int64, Int64}}:
 -2x²+2xy-2y²
 6x²y-6xy²

julia> W=complex_reflection_group(24)
G₂₄

julia> p=invariants(W)[1](x,y,z)
Mvp{Rational{Int64}}: (14//1)x⁎+(-12//1)x²y²+(-42//1)x²yz+(21//2)x²z²+(18//7)y⁎+(-6//1)y³z+(-9//2)y²z²+(-21//8)z⁎

julia> map(v->^(v,reflrep(W,1);vars=[:x,:y,:z]),(x,y,z))
((1//2)x+(3√-7/14)y, (-√-7/2)x+(-1//2)y, z)

julia> p^reflrep(W,1)-p
Mvp{Cyc{Rational{Int64}}}: 0
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.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)

returns the rank of W, 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

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::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.semisimplerank — Method

semisimpleRank(W::ComplexReflectionGroup)

returns the semisimple rank of W, which is the dimension of the space where it effectively acts. If W is a reflection group on the space V, and V₁ is the subspace generated by roots(W), then semisimplerank(W) is the dimension of V₁. The reflection group W is called essential if V₁=V.

julia> W=reflection_subgroup(coxgroup(:A,3),[1,3])
A₃₍₁₃₎=A₁×A₁Ω₁

julia> semisimplerank(W)
2

julia> rank(W)
3
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 — Method

Let W be an irreducible CRG, generated by distinguished reflections S. type_irred classifies W (returns a type record) using:

  • r=semisimplerank(W)
  • s=length(W)/factorial(r)
  • D=all distinguished reflections of W=orbit of S, which gives
  • o=the maximum order of a reflection=max_{s∈ S}o(s)
  • h=the Coxeter number=sum_{s∈ D}o(s)

G(de,e,r) has s=(de)ʳ/e, o=max(2,d), h=ed(r-1)+d-Ύ_{d,1}

(r,s,o) are sufficient to determine a G(de,e,r) excepted for ambiguity G(2e,e,2)/G(4e,4e,2), which is resolved by h (excepted for e=1, when the two solutions are isomorphic).

(r,s,o) are also sufficient to distinguish primitive groups except in the cases (which are resolved by h): G9/G(24,6,2) G12/G(12,6,2)/G(24,24,2) G13/G(24,12,2)/G(48,48,2) G22/G(60,30,2)/G(120,120,2) G7/G14/G(24,8,2) G8/G(12,3,2) G15/G(48,16,2) G17/G(120,24,2) G21/G(120,40,2)

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 for a well-generated complex reflection group if w divides for the reflection length a Coxeter element.

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

julia> reflength(W,longest(W))
2

julia> reflength(W,W(1,2,3,4))
4
Chevie.Urad — Module

This module contains functions for computing with unipotent elements of reductive groups; specifically to compute with elements of the unipotent radical of a Borel subgroup of a connected algebraic reductive group; these functions were initially written by Olivier Dudas in GAP3, partly inspired by older C code of Jean Michel.

The unipotent radical of a Borel subgroup is the product in any order of the root subgroups associated to the positive roots. We fix an order, which gives a canonical form to display elements and to compare them.

The computations use the Steinberg relations between root subgroups, which come from the choice of a Chevalley basis of the Lie algebra. The reference we follow is Carter1972, chapters 4 to 6.

We start with a root datum specified by a Weyl group W and build a struct UnipotentGroup which contains information about the maximal unipotent subgroup of the corresponding reductive group, that is the unipotent radical of the Borel subgroup determined by the positive roots.

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

julia> U=UnipotentGroup(W)
UnipotentGroup(E₆)

Now, if α=roots(W,2), we construct the element u_α(4) of the root subgroup u_α:

julia> U(2=>4)
u2(4)

If we do not specify the coefficient we make by default u_α(1), so we have also:

julia> U(2)^4
u2(4)

We can make more complicated elements:

julia> U(2=>4)*U(4=>5)
u2(4)u4(5)

julia> U(2=>4,4=>5)
u2(4)u4(5)

If the roots are not in order the element is normalized:

julia> U(4=>5,2=>4)
u2(4)u4(5)u8(-20)

It is possible to display the decomposition of the roots in simple roots instead of their index:

julia> xdisplay(U(4=>5,2=>4);root=true)
u₀₁₀₀₀₀(4)u₀₀₀₁₀₀(5)u₀₁₀₁₀₀(-20)

The coefficients in the root subgroups can be elements of arbitrary rings. Here is an example using Mvp's:

julia> W=coxgroup(:E,8);U=UnipotentGroup(W)
UnipotentGroup(E₈)

julia> u=U(map(i->i=>Z(2)*Mvp(Symbol("x",Char(i+0x2080))),1:8)...)
u1(x₁)u2(x₂)u3(x₃)u4(x₄)u5(x₅)u6(x₆)u7(x₇)u8(x₈)
julia> cut(xrepr(u^16;limit=true,root=true),before="u",width=60)
u₂₂₃₄₃₂₁₀(x₁²x₂²x₃³x₄x₅³x₆²x₇)
u₁₂₃₄₃₂₁₁(x₁x₂²x₃³x₄x₅³x₆²x₇x₈)
u₁₂₂₄₃₂₂₁(x₁x₂²x₃²x₄x₅³x₆²x₇²x₈)
u₁₂₂₃₃₃₂₁(x₁x₂²x₃²x₄³x₅³x₆³x₇²x₈)
u₂₂₃₄₃₂₁₁(x₁²x₂²x₃³x₄x₅³x₆²x₇x₈)
u₁₂₂₄₃₃₂₁(x₁x₂²x₃²x₄x₅³x₆³x₇²x₈)
u₁₂₂₄₄₃₂₁(x₁x₂²x₃²x₄x₅x₆³x₇²x₈)
u₂₂₃₄₃₃₂₁(x₁²x₂²x₃³x₄x₅³x₆³x₇²x₈)
u₁₂₃₄₄₃₂₁(x₁x₂²x₃³x₄x₅x₆³x₇²x₈)
u₂₂₃₄₄₃₂₁(x₁²x₂²x₃³x₄x₅x₆³x₇²x₈)
u₂₃₃₅₄₃₂₁(x₁²x₂³x₃³x₄⁵x₅x₆³x₇²x₈)
u₂₂₄₅₄₃₂₁(x₁²x₂²x₃x₄⁵x₅x₆³x₇²x₈)
u₂₃₄₆₅₄₃₂(x₁²x₂³x₃x₄⁶x₅⁵x₆x₇³x₈²)
julia> u^32
()

The above computation shows that in characteristic 2 the exponent of the unipotent group of E₈ is 32. More precisely, squaring doubles the height of the involved roots, so in the above u¹⁶ involves only roots of height 16 or more.

Various actions are defined on unipotent elements. Elements of the Weyl group act (through certain representatives) as long as no root subgroup is in their inversion set:

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

julia> U=UnipotentGroup(W);@Mvp x,y

julia> u=U(1=>x,3=>y)
u1(x)u3(y)

julia> u^W(2,1)
u4(y)u5(x)
julia> u^W(1)
ERROR: u1(x)u3(y) should have no coefficient on root 1

Semisimple elements act by conjugation:

julia> s=SemisimpleElement(W,[E(3),2])
SemisimpleElement{Cyc{Int64}}: <ζ₃,2>

julia> u^s
u1(ζ₃x)u3(2ζ₃y)

As well as unipotent elements:

julia> u^U(2)
u1(x)u3(x+y)u4(-x-2y)u5(x+3y)u6(x²+3xy+3y²)
Chevie.Urad.UnipotentGroup — Type

A struct UnipotentGroup represents the unipotent radical 𝐔 of a Borel subgroup of a reductive group G.

See Carter1972, section 4.2 for details on the following. A Chevalley basis of the Lie algebra of 𝐔 is a basis eᵣ, where each eᵣ is in the corresponding root subspace, such that [eᵣ,eₛ]=Nᵣₛ e_{r+s} for some integer constants Nᵣₛ. The constants Nᵣₛ for general roots are computed from the case where r and s are positive roots whose sum is a root; such a pair (r,s) is called special.

Constants Cᵣₛᵢⱌ are defined, see Carter1972, 5.2.3, by

$u_s(u)u_r(t)=u_r(t)u_s(u)\prod_{i,j>0}u_{ir+js}(C_{rsij}(-t)^iu^j)$

Where ir+js runs over the positive integral combinations of r and s which are roots, taken in lexicographic order on (i,j). The constants Cᵣₛᵢⱌ are computed from the constants Nᵣₛ, see Carter1972, bottom of page 61 and top of page 76.

The fields of struct Unipotent Group are:

  • W: the Weyl group of G
  • order: the total order on the roots used to normalize products of root subgroups (by default 1:nref(W))
  • special: aNamedTuplefor each special pair of roots(r,s)`
  • r index of r
  • s index of s
  • rs index of r+s
  • N: the constant Nᵣₛ
  • comm: stores the Cᵣₛᵢⱌ as the list of quadruples (i,j,ir+js,Cᵣₛᵢⱌ).
julia> U=UnipotentGroup(coxgroup(:G,2))
UnipotentGroup(G₂)

julia> U.special
10-element Vector{@NamedTuple{r::Int64, s::Int64, rs::Int64, N::Int64, comm::Vector{NTuple{4, Int64}}}}:
 (r = 1, s = 2, rs = 3, N = 1, comm = [(1, 1, 3, 1), (1, 2, 4, -1), (1, 3, 5, 1), (2, 3, 6, 2)])
 (r = 2, s = 3, rs = 4, N = 2, comm = [(1, 1, 4, 2), (2, 1, 5, 3), (1, 2, 6, -3)])
 (r = 2, s = 4, rs = 5, N = 3, comm = [(1, 1, 5, 3)])
 (r = 1, s = 5, rs = 6, N = 1, comm = [(1, 1, 6, 1)])
 (r = 3, s = 4, rs = 6, N = 3, comm = [(1, 1, 6, 3)])
 (r = 2, s = 1, rs = 3, N = -1, comm = [(1, 1, 3, -1), (2, 1, 4, -1), (3, 1, 5, -1), (3, 2, 6, -1)])
 (r = 3, s = 2, rs = 4, N = -2, comm = [(1, 1, 4, -2), (2, 1, 6, -3), (1, 2, 5, 3)])
 (r = 4, s = 2, rs = 5, N = -3, comm = [(1, 1, 5, -3)])
 (r = 5, s = 1, rs = 6, N = -1, comm = [(1, 1, 6, -1)])
 (r = 4, s = 3, rs = 6, N = -3, comm = [(1, 1, 6, -3)])
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(r1=>c1,..,r_n=>c_n)'

Where U is a UnipotentGroup. In the first form the function creates the element uáµ£(1), and in the second form the element u_{r_1}(c_1)
 u_{r_n}(c_n)

julia> U=UnipotentGroup(coxgroup(:G,2))
UnipotentGroup(G₂)

julia> U(2)
u2(1)

julia> U(1=>2,2=>4)
u1(2)u2(4)

julia> U(2=>4,1=>2)
u1(2)u2(4)u3(-8)u4(32)u5(-128)u6(512)
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 — Module

Finite Coxeter groups are the finite complex reflection groups which can be defined on a real vector space V.

Weyl groups are the finite Coxeter groups which can be defined over a rational vector space V (thus over the integers).

Like finite complex reflection groups, finite Coxeter groups are implemented as groups of permutations of a set of roots. The particular crystallographic root systems for Weyl groups play an important role in mathematics as they classify semi-simple Lie algebras and algebraic groups.

Let us give precise definitions. Let V be a real vector space and Vⱜ its dual. A root system is a finite set of vectors R⊂ V (the roots), together with a map r↩ rⱜ from R to a subset Rⱜ of Vⱜ (the coroots) such that:

  • For any r∈ R, we have rⱜ(r)=2, so that the formula x↩ x-rⱜ(x)r defines a reflection sáµ£:V→ V with root r and coroot rⱜ.
  • The reflection sáµ£ stabilizes R.

The subgroup W=W(R) of GL(V) generated by the reflections sáµ£ for r∈ R is a finite Coxeter group. We require reduced root systems, that is such that the only elements of R colinear with r∈ R are r and -r; for Weyl groups, we also require that the root system be crystallographic, that is rⱜ(s) is an integer, for any s∈ R,rⱜ∈ Rⱜ.

If we identify V with Vⱜ by choosing a W-invariant bilinear form (.;.), then we have rⱜ=2r/(r;r). A root system R is irreducible if R is not the union of two orthogonal subsets; equivalently the representation of W on the subspace generated by R is irreducible. If R is reducible then the corresponding Coxeter group is the direct product of the Coxeter groups associated with the irreducible components of R.

Let us now describe how a root system R and a presentation of the corresponding W are encoded in a Cartan matrix or a Dynkin diagram. We can choose a linear form on V which does not vanish on any element of R. Depending on the sign of the value of this linear form on a root r ∈ R we call r positive or negative. Then there exists a unique subset Π of the positive roots, the simple roots, such that any positive root is a linear combination with non-negative coefficients of the roots in Π. Any two sets of simple roots (corresponding to different choices of linear forms) can be transformed into each other by a unique element of W(R). If S is the set of reflections with respect to the simple roots, then (W,S) is a Coxeter system. These generating reflections are called Coxeter generators or simple reflections.

Since the pairing between V and Vⱜ is W-invariant, if Π is a set of simple roots and if we define the Cartan matrix as being the n times n matrix C={rⱜ(r')} for r,r'∈Π, this matrix is independent of the chosen linear form up to simultaneous permutation of rows and columns. Since the action of sáµ£ on r' for r,r'∈Π is given by sáµ£(r')=r'-C(r,r')r, the Cartan matrix determines the reflection representation of W.

For a crystallographic root system the Cartan matrix has integral entries, and in the basis Π (completed by a basis of the orthogonal), sᵣ has an integral matrix. All finite-dimensional (complex) representations of a finite Coxeter group can be realized over the field generated by the entries of the Cartan matrix.

The Cartan matrix is encoded in a Dynkin diagram, a tree with weighted edges and an orientation on edges of even weight >2, as follows. The vertices are indexed by the simple reflections; an edge is drawn between s and t if the order mₛₜ of st is greater than 2 and is given the weight mₛₜ. These weights are encoded by drawing the edge single for weight 3, double for weight 4 and triple for weight 6. The arrows indicate the relative root lengths (going from the longer to the shorter root) which may differ between different orbits of W on R. Alternately the Dynkin diagram can be obtained from the Cartan matrix as follows: if Cᵣₛ and Cₛᵣ are integers such that |Cₛᵣ|≥|Cᵣₛ|=1 there is an edge of weight |Cₛᵣ| from r to s with an arrow pointing to s if |Cₛᵣ|>1. Note that the Cartan matrices we consider here are not necessarily symmetric, contrary to the Cartan matrices we considered describing the reflection representation of a general Coxeter group; being symmetric corresponds to all roots being taken of the same length.

The irreducible crystallographic root systems are classified by the following list of Dynkin diagrams. The labeling of the nodes is the order of the generators and is shown by the function diagram.

Aₙ O—O—O—
—O   Bₙ O⇐ O—O—
—O  Cₙ O⇒ O—O—
—O  Dₙ O 2
   1 2 3 
 n      1  2 3 
 n     1  2 3 
 n     ï¿š
                                              O—O—
—O
                                              1 3 
 n

G₂ O⇛ O  F₄ O—O⇒O—O    E₆  O 2    E₇  O 2      E₈  O 2
   1  2     1 2 3 4        ï¿š          ï¿š            ï¿š
                       O—O—O—O—O  O—O—O—O—O—O  O—O—O—O—O—O—O
                       1 3 4 5 6  1 3 4 5 6 7  1 3 4 5 6 7 8

We get the Coxeter diagram, which describes the underlying Weyl group, if we ignore the arrows: we see that the root systems B_n and C_n correspond to the same Coxeter group (the Coxeter diagram is defined by the Coxeter matrix). Weyl groups can also be characterized as the finite Coxeter groups such that all off-diagonal entries of the Coxeter matrix are in {2,3,4,6}.

Here are the Coxeter diagrams for the finite Coxeter groups which are not crystallographic (I₂(e) is not crystallographic if e∉ {2,3,4,6}).

       e        5         5
I₂(e) O—O   H₃ O—O—O  H₄ O—O—O—O
      1 2      1 2 3     1 2 3 4

The function cartan gives the cartan matrix for an irreducible root system

julia> cartan(:D,4)
4×4 Matrix{Int64}:
  2   0  -1   0
  0   2  -1   0
 -1  -1   2  -1
  0   0  -1   2

julia> cartan(:I,2,5) # for type I₂(e) give e as 3rd argument
2×2 Matrix{Cyc{Int64}}:
       2  ζ₅²+ζ₅³
 ζ₅²+ζ₅³        2

Given two Cartan matrices c1 and c2, their matrix direct sum (corresponding to the orthogonal direct sum of the root systems) can be obtained by cat(c1,c2,dims=[1,2]).

The whole root system can be recovered from the simple roots and the corresponding coroots, since each root is in the orbit of a simple root. The restriction of the simple reflections to the span of R is determined by the Cartan matrix, so R is determined by the Cartan matrix and the set of simple roots.

The function rootdatum takes as arguments a matrix r whose lines represents the list of simple roots and another matrix cr whose lines are the corresponding coroots and produces a FiniteCoxeterGroup. Such an object is a permutation group containing in addition the description of a root system. cr*transpose(r) should be a Cartan matrix. Each element of the coxeter group is represented as the permutation it induces on the roots, coded as a permutation of 1:2N where we label the positive roots by 1:N, and the negative roots by N+1:2N.

If a single matrix argument is given to rootdatum it is taken as cr and r is taken to be the identity matrix; we get thus a particular root system where the roots are the canonical basis of V. For convenience, rootdatum(cartan(t...)) can be simplified to coxgroup(t...).

julia> W=coxgroup(:D,4) # same as rootdatum(cartan(:D,4))
D₄

julia> cartan(W)
4×4 Matrix{Int64}:
  2   0  -1   0
  0   2  -1   0
 -1  -1   2  -1
  0   0  -1   2

Also, the FiniteCoxeterGroup associated to a direct sum of irreducible root systems can be obtained as

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

julia> cartan(W) # same as cat(cartan(:A,2), cartan(:B,2),dims=[1,2])
4×4 Matrix{Int64}:
  2  -1   0   0
 -1   2   0   0
  0   0   2  -2
  0   0  -1   2

The elements of a Weyl group are permutations of the roots:

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

julia> p=W(1,3,2,1,3) # permutes the 24 roots
(1,14,13,2)(3,17,8,18)(4,12)(5,20,6,15)(7,10,11,9)(16,24)(19,22,23,21)

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

finally, a benchmark on julia 1.0.2

julia> @btime length(elements(coxgroup(:E,7)))
  531.385 ms (5945569 allocations: 1.08 GiB)

GAP3 for the same computation takes 2.2s

Chevie.CoxGroups.coxeter_group — Function

coxeter_group(type,rank[,bond];sc=false) (or coxgroup)

If C=cartan(type,rank[,bond]), this is equivalent to rootdatum(C). If sc=true this is equivalent to rootdatum(permutedims(C),one(C)).

The resulting object W, a FiniteCoxeterGroup, has an additional entry compared to a PermRootGroup.

  • W.rootdec: the root vectors, given as linear combinations of simple roots. The first nref(W) roots are positive, the next nref(W) are the corresponding negative roots. Moreover, the first semisimplerank(W) roots are the simple roots. The positive roots are ordered by increasing height.

and roots(W) is ordered is the same way as W.rootdec.

For how to get various information on the root system and the Coxeter group, see the functions nref, coroots, rootlengths, simple_reps, simple_conjugating, reflrep, simpleroots, simplecoroots, PermX, cartan, inclusion, restriction, action, rank, semisimplerank

In terms of root data, this function returns the adjoint root datum of Weyl group W. If sc=true it returns the simply connected root datum.

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

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

julia> W.rootdec
12-element Vector{Vector{Int64}}:
 [1, 0]
 [0, 1]
 [1, 1]
 [1, 2]
 [1, 3]
 [2, 3]
 [-1, 0]
 [0, -1]
 [-1, -1]
 [-1, -2]
 [-1, -3]
 [-2, -3]

julia> reflrep(W)
2-element Vector{Matrix{Int64}}:
 [-1 0; 1 1]
 [1 3; 0 -1]
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)

For I⊆1:nref(W), the subgroup H of W generated by refls(W,I).

A theorem found independently by Deodhar1989 and Dyer1990 is that a subgroup H of a Coxeter system (W,S) generated by reflections has a canonical Coxeter generating set, formed of the t ∈ Ref(H) such length(W,tt')>length(W,t) for any t'∈ Ref(H) different from t. This is used by reflection_subgroup to determine the Coxeter system of H.

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

julia> diagram(W)
O⇛ O G₂
1  2

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

julia> diagram(H)
O Ã₁
1
O A₁
2

The notation G₂₍₂₆₎ means that roots(W,[2,6]) is a system of simple roots for H.

If H is a standard parabolic subgroup of a Coxeter group W then the length function on H (with respect to its set of generators) is the restriction of the length function on W. This need not no longer be true for arbitrary reflection subgroups of W.

julia> elH=word.(Ref(H),elements(H))
4-element Vector{Vector{Int64}}:
 []
 [1]
 [2]
 [1, 2]

julia> elW=word.(Ref(W),elements(H))
4-element Vector{Vector{Int64}}:
 []
 [2]
 [1, 2, 1, 2, 1]
 [1, 2, 1, 2, 1, 2]

julia> map(w->H(w...),elH)==map(w->W(w...),elW)
true

We implement finite reflection groups as permutation groups on a set of roots. Consequently, a reflection subgroup H⊆ W is a permutation subgroup, thus its elements are represented as permutations of the roots of the parent group.

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.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 $N_W(W_J)=W_J⋊ N₁$ where N₁ is the group generated by the v(s,J), which form a Coxeter system for N₁. Equivalently N₁ consists of the J-reduced elements of N_W(W_J). The quotient R=N_W(W_J)/W_J has a natural reflection representation on $X(ZL_J/ZG)$, using that by Lusztig1976, the images of the roots of W in $X(ZL_J)$ form a root system. The function returns R as a reflection group on $X(ZL_J/ZG)$, with some extra attributes reflecting its origin

  • R.relative_indices=setdiff(S,J) in a certain order
  • R.toparent= the list of v(s,J) corresponding to .relative_indices; defines an isomorphism R→ N₁.
  • R.fromparent is a function mapping elements of N₁ to R. The inverse mapping to .toparent.
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> p==standard_parabolic(W,[19,1,9,20]) # can give inclusiongens
true

julia> reflection_subgroup(W,[20,30,19,22].^p) # same as R^p
E₆₍₂₄₅₆₎=A₄Ί₁²

julia> R=reflection_subgroup(W,[1,2,3,5,6,35])
E₆₍₁‚₃‚₂‚₃₅‚₅‚₆₎=A₂₍₁₃₎×A₂₍₂₆₎×A₂₍₄₅₎

julia> standard_parabolic(W,R)
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.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 — Module

Garside 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 is the braid group. Here we implement braid groups as part 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:

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

  2. 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, 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 (the package AffineA implements, following the work of François Digne, 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 indices given as arguments:

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> xrepr(w^-1,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 the indices of their constituting atoms.

We will now describe the dual braid monoid. First we define interval monoids. Given a group W and a set S of generators of W as a monoid, we define the length l_S(w) as the minimum number of elements of S needed to write w. We then define left-divisors of x as those d∈W 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 this case we denote this set by [1,w], an interval for the poset of S-divisibility. We say that w is Garside for l_S 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 l_S. 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. For the implementation of finite categories we use, see the docstrings of Category and endomorphisms.

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,i::Integer)

convert to an element of B the i-th atom of M.

Chevie.Garside.Category — Type

Category{TO,TM} is the type of a finite category whose objects are of type TO and maps of type TM. It is represented as a struct with two fields:

  • obj::Vector{TO} the objects
  • atoms::Vector{Vector{Pair{TM,Int}}} a vector representing the atoms (generators) of the category. It is such that atoms[i] is a Vector of pairs m=>j representing a map m from obj[i] to obj[j]. If the julia objects of type TM belong to a monoid, a general map can be represented as a triple (i,m,j) where m is of type TM representing a map from obj[i] to obj[j].

A category is graphically shown by giving the :graph io property:

julia> W=coxsym(4);M=BraidMonoid(W)
BraidMonoid(𝔖 ₄)

julia> xprint(conjcat(M(1,1,2,2,3));graph=true)
category with 4 objects and 8 generating maps
      1232       12       213       213       213       32 
213.32―――➔ 12.213―➔ 213.12――➔ 12.213――➔ 213.32――➔ 32.213―➔ 213.32
      1321       213 
213.12―――➔ 32.213――➔ 213.12
Chevie.Garside.Category — Method

Category(atomsfrom::Function,o;action::Function=^)

constructs a category from an initial object o and a function atomsfrom(o) which given object o returns atoms from o as "maps" m such that the target object is action(o,m).

As an example we construct a Garside category associated to the braid group of G₃₁, realized as the centralizer of a 4th root of Ύ³⁰ in the dual braid monoid of E₈; that is the fixed points of ÎŽad¹⁵ in the 2-divided category.

julia> W=coxgroup(:E,8);M=DualBraidMonoid(W)
DualBraidMonoid(E₈,c=[1, 4, 6, 8, 3, 2, 5, 7])

julia> s4=left_divisors(M,M.ÎŽ,4); # simples of length 4

julia> s=M(s4[findfirst(x->x*ÎŽad(M,x,8)==M.ÎŽ,s4)])#an object of 2-divided cat
(1 8 17 35)

julia> "the right-lcms of the `Ύⁱ`-orbits on `leftdescents(b)`"
       function satoms(b,i)
         M=b.M
         ld=M.atoms[leftdescents(b)]
         di=Perm(ld,ÎŽad.(Ref(M),ld,i))
         if isnothing(di) error(b," is not ÎŽ^$i-stable") end
         map(o->M(rightlcm(M,ld[o]...)),orbits(di,eachindex(ld)))
       end
satoms

julia> Category(x->satoms(x,15),s;action=(o,m)->inv(m)*o*ÎŽad(m,8))
category with 88 objects and 660 generating maps
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.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))
1-element Vector{GarsideElt{Perm{Int16}, BraidMonoid{Perm{Int16}, FiniteCoxeterGroup{Perm{Int16},Int64}}}}:
 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 # the (sliding circuits) summit set
2-element Vector{GarsideElt{Perm{Int16}, BraidMonoid{Perm{Int16}, FiniteCoxeterGroup{Perm{Int16},Int64}}}}:
 32143
 21324
julia> xprint(C;graph=true)   # show the conjugations among the summit set
category with 2 objects and 4 generating maps
     32143      21343      21324      13214
32143────→ 32143────→ 21324────→ 21324────→ 32143
julia> conjcat(w;ss=Val(:ss)).obj # the super summit set
4-element Vector{GarsideElt{Perm{Int16}, BraidMonoid{Perm{Int16}, FiniteCoxeterGroup{Perm{Int16},Int64}}}}:
 32143
 13243
 21432
 21324
Chevie.Garside.conjugating_elt — Function

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

julia> W=coxsym(4);M=BraidMonoid(W)
BraidMonoid(𝔖 ₄)

julia> endomorphisms(conjcat(M(1,1,2,2,3)),1)
2-element Vector{GarsideElt{Perm{Int16}, BraidMonoid{Perm{Int16}, CoxSym{Int16}}}}:
 213.1232
 12.213
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 — Function

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

shrink(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] 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.ÎŽ (that is x^(M.ÎŽ^i)).

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

Eigenspaces 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 and the functions in the module dSeries 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 no 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 toparent in W

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 normalizes W₁.

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

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

The 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.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> 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> BDSymbols(4,0)
13-element Vector{Vector}:
 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.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₂)

see 3.9 and 6.4 Malle1995.

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

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

This 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 faster 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.lin2cart — Method

lin2cart([l₁,
,lₙ],i) is GAP3 CartesianAt faster cartesian(map(j->1:j,l))[i]

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₆‚₁‚₁
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[,z1])

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. Let 𝔟 be the spets attached to W. A property checked case-by case is that, for a unipotent character γ of 𝔟 with polynomial generic degree deg γ(q) , deg γ(zq) is equal to ±deg γ'(q) for another unipotent character γ'; ±γ' is called the Ennola transform of γ. For W a Weyl group, the spets 𝔟 is a finite reductive group, in which case z=-1 if -1 is in W and z=1 otherwise. The function returns the signed permutation e done by ennola on the unipotent degrees (as an SPerm of 1:length(UnipotentCharacters(W))).

The SPerm e 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 (they include a description of the Ennola-permutation in terms of the fusion algebras attached to each Lusztig family).

If a second argument z1 is given, it should be a power of z and the corresponding power of e is returned.

julia> ennola(rootdatum("3D4"))
SPerm{Int64}: (3,-4)(5,-5)(6,-6)(7,-8)

julia> 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 above 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 q⅓ in the character table of the spetsial Hecke algebra of W.

For a non-irreducible group, z-ennola is defined if z can be considered an element of the the centre of each irreducible component.

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)
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)/2       qΊ₁²Ί₂│
│G₂₍₂₎=Ã₁Ί₂│              q/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 — Module

This 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}0&1\\0&0 \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 $𝐓$ and the root system Ί; then $α↊⟚σ,α⟩$ defines a linear form on $Ί$, determined by its value on simple roots Π. It is possible to choose a system of simple roots such 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.

Another classification of unipotent elements was given by Bala-Carter. A standard parabolic subgroup 𝐏 of 𝐆 parameterised by a subset I⊂Π is distinguished if the linear form σ taking the value 2 for α∈ I and 0 for other simple roots satisfies 2n₀+semisimplerank(𝐆)=n₂, where náµ¢ is the number of roots in Ί where σ takes the value i. Given a distinguished parabolic 𝐏, there is a unique unipotent class which is dense in the unipotent radical of 𝐏. This class has the linear form described by the Dynkin-Richardson diagram equal to σ. Such unipotent classes are called distinguished. The theorem of Bala-Carter says that every unipotent class is distinguished in the smallest Levi subgroup 𝐋 which contains it, and that such pairs of 𝐋 and the distinguished parabolic 𝐏 of 𝐋 taken up to 𝐆-conjugacy are in bijection with unipotent classes of 𝐆.

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 now describe the Springer correspondence. Indecomposable locally constant $𝐆$-equivariant sheaves on a unipotent class $C$, called local systems, are parameterised by irreducible characters of $A(u)$ for u∈ C. The ordinary Springer correspondence is a bijection between irreducible characters of the Weyl group and a large subset of the local systems containing all trivial local systems (those parameterised by the trivial character of $A(u)$ for each $u$). More generally, the generalised 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 parameterised by the characters of the relative Weyl group $W_𝐆 (𝐋):=N_𝐆 (𝐋)/𝐋$. There are only few cuspidal pairs (at most one in each dimension for classical groups).

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 parameterised 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 parameterised 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 relation to characters of $𝐆(𝔜_q)$, considering for simplicity 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 restrictions of the Deligne-Lusztig characters $R_w$ for w∈ W on 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 first be 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).

Finally, we describe how unipotent classes of 𝐆 are parameterised in various quasisimple groups. In classical types, the classes are parametrised by partitions corresponding to the Jordan form in the standard representation. Thus,

  • for Aₙ we have partitions of n+1.
  • for B_n we have partitions of 2n+1 where even parts occur an even number of times. In characteristic 2, types B and C are isogenous so have the same classification; thus see the next paragraph.
  • for C_n we have partitions of 2n where odd parts occur an even number of times. In characteristic 2, there are 2ᵏ classes attached to a partition where k is the number of even parts which occur an even number of times.
  • for D_n we have partitions of 2n where even parts occur an even number of times, excepted there are two classes when all parts are even. In characteristic 2, we have partitions of 2n where odd parts occur an even number of times, excepted there are 2ᵏ+ÎŽ classes attached to a partition where k is the number of even parts which occur an even number of times, and ÎŽ is 2 when all parts are even and 0 otherwise.

In exceptional groups, the names of the classes are derived from the Bala-Carter classification. The name for a class parametrised by (𝐋,𝐏) is of the form l(p) where l is the name of 𝐋 and (p) is present if there is more than one distinguished parabolic in 𝐋 and describes which one it is. Before the classification of Bala-Carter was universally adopted, Shoji and Mizuno used a different scheme where sometimes a class was parametrised by a reductive subgroup of maximal rank which was not a Levi. These older labels can be obtained instead by giving the IO property :shoji=>true or :mizuno=>true. In a bad characteristic p, there are extra classes. Each of them is associated to a class c in good characteristic and is named (c)ₚ.

We illustrate the above descriptions on some examples:

julia> UnipotentClasses(rootdatum(:sl,4))
UnipotentClasses(sl₄)
1111<211<22<31<4
┌────┬───────────────────────────────────────────────────────────────┐
│u   │D-R dℬ áµ€ B-C   C_𝐆(u) A₃(Ί₁³) A₁(A₁×A₁Ω₁)/-1 .(A₃)/ζ₄ .(A₃)/ζ₄³│
├────┌────────────────────────────────────────────────────────────────
│4   │222    0 222    q³.Z₄     1:4           -1:2    ζ₄:Id    ζ₄³:Id│
│31  │202    1 22.    q.Ω₁   Id:31                                  │
│22  │020    2 2.2 q.A₁.Z₂    2:22          11:11                   │
│211 │101    3 2..  q⁵.A₁Ω₁  Id:211                                  │
│1111│000    6 ...       A₃ Id:1111                                  │
└────┮───────────────────────────────────────────────────────────────┘

The first column of the table gives the name of the unipotent class, here 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, which is only shown 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 shows $u$ as a regular unipotent in a Levi subgroup by giving the Dynkin-Richardson diagram of a regular unipotent (all 2's) for the entries corresponding to the Levi and . for the entries which not corresponding 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 a different 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 dℬ áµ€ B-C  C_𝐆(u) A₃(Ί₁³)│
├────┌─────────────────────────────
│4   │222    0 222      q³    Id:4│
│31  │202    1 22.   q.Ω₁   Id:31│
│22  │020    2 2.2   q.A₁   Id:22│
│211 │101    3 2.. q⁵.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 dℬ áµ€ B-C C_𝐆(u)         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. It also illustrates how we display in general the Bala-Carter classification. If a class is attached to (𝐋,𝐏) then the simple roots in the complement of 𝐋 have a .. Those in 𝐋 have a 0 or a 2, the 2s characterizing 𝐏. So, from the B-C column, we see that that G₂(a₁) 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     │dℬ áµ€ B-C C_𝐆(u)  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│
└──────┮─────────────────────────────┘

An example which illustrates how to get the shoji names of classes

julia> uc=UnipotentClasses(coxgroup(:F,4));

julia> uc.classes[10:end]
7-element Vector{UnipotentClass}:
 UnipotentClass(C₃(a₁))
 UnipotentClass(F₄(a₃))
 UnipotentClass(C₃)
 UnipotentClass(B₃)
 UnipotentClass(F₄(a₂))
 UnipotentClass(F₄(a₁))
 UnipotentClass(F₄)

julia> xdisplay(uc.classes[10:end],shoji=true)
7-element Vector{UnipotentClass}:
 UnipotentClass(A₁+B₂)
 UnipotentClass(A₃+Ã₁)
 UnipotentClass(C₃)
 UnipotentClass(B₃)
 UnipotentClass(C₃+A₁)
 UnipotentClass(B₄)
 UnipotentClass(F₄)

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₂$.

The data on unipotent classes for arbitrary reductive groups are obtained as follows. The data for a quasi-simple simply connected group 𝔟 have been entered by hand for each type. In such a group to each Springer series is attached a character of A(Z), the group of components of the center. For any reductive group 𝔟' of the same type with center Z' the group A(Z') is a quotient of the group A(Z). The Springer series for 𝔟' are those such that the corresponding character of A(Z) factors through A(Z') (for computing A(Z') see algebraic_center). The geometric unipotent classes of 𝔟 and 𝔟' are in bijection. For u a unipotent element of 𝔟' (which we can consider also as a unipotent element of 𝔟) the group A₁=A(u) in 𝔟' is a quotient of A=A(u) in 𝔟 that we can compute as follows: the Springer correspondence for 𝔟' tells us which characters of A survive in 𝔟'. Then A' is the quotient of A by the common kernel of these characters.

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 parametrised 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 showtable, 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 — Type

A 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 showtable 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)
┌──────┬─────────────────────────────────────────────────────┐
│u     │             E₆(Ί₁⁶) G₂(A₂×A₂Ί₁²)/ζ₃ G₂(A₂×A₂Ί₁²)/ζ₃²│
├──────┌──────────────────────────────────────────────────────
│E₆    │                1:1ₚ            ζ₃:1            ζ₃²:1│
│E₆(a₁)│                1:6ₚ           ζ₃:εₗ           ζ₃²:εₗ│
│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ₛ          ζ₃:ε_c          ζ₃²:ε_c│
│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(uc) gives the decomposition of the functions $X̃_{u,ϕ}$ on local systems. t=XTable(uc,classes==true) gives the values of the functions $X̃_{u,ϕ}$ on unipotent classes. A side effect of classes=true is to compute the cardinal of the unipotent conjugacy classes, available in t.cardClass; in this case displaying t will show the cardinal of the centralizers of unipotent elements, available in t.centClass.

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> t=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²  .│
├──────────┌──────────────────────────────────────────────────────────
│|C_𝐆(u)|  │q⁶Ί₁²Ί₂²Ί₃Ί₆ q⁶Ί₁Ί₂ qΩ₁Ω₂    6q⁎        2q⁎       3q⁎ 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³⁄₂│
└────────┮────────────────────────────────────────────┘
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 standard parabolic subgroups of W as defined by Richardson, each given as a 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 subgroup. Their Dynkin-Richardson diagram contains a 0 at the indices of the parabolic subgroup, otherwise a 2.

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 class in the algebraic group 𝐆 which contains a given unipotent class of a reductive subgroup of maximum rank 𝐊 of 𝐆.

The argument h is a linear form on the roots of 𝐊, given by its value on the simple roots; this linear form is extended to the roots of 𝐆 by 0 on the orthogonal of the roots of K; and finally the resulting form is conjugated by an element of the Weyl group so that it takes positive values on the simple roots. If the initial form describes a Dynkin-Richardson diagram for 𝐊, the result will describe a Dynkin-Richardson diagram for 𝐆.

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].dynkin
4-element Vector{Int64}:
 0
 1
 0
 0

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 A₁+Ã₁.

Chevie.Ucl.special_pieces — Method

'special_pieces(<uc>)'

The special pieces form a partition of the unipotent variety of a reductive group 𝐆 which was first defined in Spaltenstein1982 chap. III as the fibres 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 is 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 that 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.