Curtis--Steinberg--Tits Presentations

In Magma a group of Lie type over a field is defined by generators which satisfy Steinberg relations (see section The Steinberg Presentation). In particular the unipotent elements xα(a) are parametrised by the field and the torus elements are parametrised by the non-zero elements of the field. However, the number of generators and relations can be reduced considerably using a form of the Curtis--Steinberg--Tits (CST) presentation [BGK+97].

This section describes basic functions to compute with highest weight representations of finite groups of Lie type defined by CST presentations: see the previous section and Chapter REPRESENTATIONS OF LIE GROUPS AND ALGEBRAS for more functions for highest weight representations.

Currently this functionality is available only for algebraically simple finite reductive groups with a simply connected root datum: all untwisted types and the twisted groups of types ()2An (n odd), ()2Dn, ()3D4 and ()2E6.

Let G(q) be a simply connected group defined over the field Fq, let Δ = {α1, ..., αd} be a base of simple roots and let B be a basis for Fq regarded as a vector space over its prime field. The CST presentation can be described as follows.

For i < j, let Φij be the subsystem spanned by αi and αj, put Ψ = bigcupi, jΦij and Υ = bigcupi, j{ (α, β) ∈Φij x Φij | α≠∓ β }. Then G(q) has a presentation with generators xα(a) for α ∈Ψ and a∈B. It is enough to require relations xα(a)xα(b) = xα(a + b) for α∈Ψ and relations

[xα(a), xβ(b)] = ∏i, j > 0 xiα + jβ(Cijαβaibj)

for (α, β)∈Υ and a, b∈B. (If G(q) were not simply connected we would need additional generators for the torus.)

In Magma, the CST generators are represented by a pair of sequences X, Y

eqalignno( X &= [[xα(a) | a ∈B] | α ∈Ψ ]quadand
Y &= [[x - α(a) | a ∈B] | α ∈Ψ],
)

where X (resp. Y) may be regarded as a matrix whose rows are indexed by positive (resp. negative) roots and whose columns are indexed by basis elements of Fq.

For many functions there are optional parameters OnlySimple and GS. If OnlySimple is true, only the CST generators xα(a) where ∓α is a simple root are used. (The function ExtendGeneratorList can be used to extend the simple generators to the full collection of CST generators.)

The functions generally use the default signs for the extraspecial pairs (Section Constructing Root Data). However, if GS is true, the root order and signs used by Gilkey and Seitz [GS88] are used; this only applies to groups of types F4 and G2.

Contents

CST_Generators(t,r,q,w) : MonStgElt, RngIntElt, RngIntElt, SeqEnum -> SeqEnum, SeqEnum
    GS: BoolElt                         Default: false
    OnlySimple: BoolElt                 Default: false
    Weyl: BoolElt                       Default: false
    Signs: Any                          Default: 1
The Curtis--Steinberg--Tits generators for the group of Lie type t and rank r over the field Fq in the irreducible representation with highest weight w. If OnlySimple is true, only generators for the simple roots are returned. If Weyl is true, the Weyl representation of highest weight w is returned. If w is the empty sequence, the standard representation is used.

The parameter Signs can take the values described in Section Constructing Root Data.

CST_Presentation(t,r,q) : MonStgElt, RngIntElt, RngIntElt -> GrpSLP, SeqEnum
    GS: BoolElt                         Default: false
The Curtis--Steinberg--Tits relations for the simply connected group of Lie type t and rank r over the field Fq. The function returns an SLP-group G and a sequence containing the relations as straight-line programs in G.

If GS is true, the Gilkey--Seitz structure constants are used and the simple roots for groups of type G2 are swapped.

CST_VerifyPresentation(t,r,q,X,Y) : MonStgElt, RngIntElt, RngIntElt, SeqEnum, SeqEnum -> BoolElt, RngIntElt
    GS: BoolElt                         Default: false
Given Curtis--Steinberg--Tits generators X, Y for a simply connected group of Lie type t and rank r over the field Fq, verify that the generators satisfy the relations. Set GS to true if the Gilkey--Seitz conventions hold for X and Y.

Example GrpLie_CSTPres (H110E25)

Verify that the CST generators for the 273-dimensional representation of (F)4(5) satisfy the CST relations but not the relations for (F)4(5). When the relations are not satisfied, the index of the first relation which fails is returned.
> X,Y := CST_Generators("F",4,5,[0,0,1,0]);
> CST_VerifyPresentation("F",4,5,X,Y);
true
> CST_VerifyPresentation("F",4,3,X,Y);
false 1
> G, rels := CST_Presentation("F",4,3);
> rels[1];
function(G)
    w1 := G.1^3; return w1;
end function
CSTtoChev(t,r,q,X,Y) : MonStgElt, RngIntElt, RngIntElt, SeqEnum, SeqEnum -> Map
    GS: BoolElt                         Default: false
    UseMap: BoolElt                     Default: false
Given Curtis--Steinberg--Tits generators X, Y which satisfy the presentation for a group of Lie type t and rank r over the field of q elements, return a function f from the group they generate to the standard Magma copy obtained from ChevalleyGroup(t,r,q). The function f will be a homomorphism up to a scalar multiple.

Set GS to true if the Gilkey--Seitz conventions hold for X and Y. If UseMap is true, the function f is returned as a Magma Map, otherwise the type is UserProgram.

Example GrpLie_CSTtoChev (H110E26)

Construct a map from the 28-dimensional representation of the simply connected version of the twisted group ()3(D)4(3) to its standard 8-dimensional representation.
> X,Y := CST_Generators("3D",4,3,[0,1,0,0]);
> f := CSTtoChev("3D",4,3,X,Y : UseMap);
> G := Domain(f); G:Minimal;
MatrixGroup(28, GF(5^3))
> L := Codomain(f); L;
GL(8, GF(5, 3))
> C := ChevalleyGroup("3D",4,3);
> Order(C);
20560831566912
> forall{ x : x in Generators(G) | f(x) in C };
true
ExtendGeneratorList(t,r,X,Y) : MonStgElt, RngIntElt, RngIntElt, SeqEnum, SeqEnum -> SeqEnum,SeqEnum
    GS: BoolElt                         Default: false
Given matrix generators (for the simple roots and their negatives) for a simply connected group of Lie type t and rank k over the field of q elements, return the Curtis--Steinberg--Tits generators.
IrreducibleHighestWeightRepresentation(G,w) : GrpLie, SeqEnum -> Map
The function CST_Generators returns the Curti--Steinberg--Tits generators either for a Weyl module of weight w or its irreducible quotient. This function returns the corresponding irreducible representation as a Map.
IrreducibleHighestWeightGenerators(G,w) : GrpLie, SeqEnum -> SeqEnum,SeqEnum
    OnlySimple: BoolElt                 Default: false
For a simply connected finite group G over the field of q elements and a q-restricted weight w return Curtis--Steinberg--Tits generators X, Y for the irreducible G-module of weight w for the group G. If OnlySimple is true, return generators for just the simple roots.

If varpi1, varpi2, ...,varpik are the fundamental weights, then w = a1varpin + a2varpi2 + ... + ak varpik is q-restricted if 0≤ai < q for 1 ≤i≤k.

IrreducibleHighestWeightFunction(G,w) : GrpLie, SeqEnum -> UserProgram
This is a version of IrreducibleHighestWeightGenerators which returns the homomorphism from G to the matrix representation of weight w.
VermaModule(G,w) : GrpLie, SeqEnum -> ModGrp
For a finite group G of Lie type and a weight w this function returns a module M of highest weight w such that every highest weight module of weight w is a quotient of M.
UniversalHighWeightRepresentation(G,w) : GrpLie, SeqEnum -> Map,SeqEnum,SeqEnum
This function returns a homomorphism from G into GL(M) and Curtis-Steinberg--Tits generators for the image, where M is the module returned by the previous function.

Chevalley Groups

Let L be a complex semisimple Lie algebra with root system Φ, simple roots Δ, Cartan subalgebra H, one-dimensional root spaces (L)α and Cartan decomposition (L) = H direct-sum bigoplusα ∈Φ(L)α.

We choose basis vectors eα∈(L)α such that [eα, eβ] = cα, β, and the structure constants cα, β are integers ∓ (r + 1), where r is the greatest integer such that β - rα is a root.

For all α∈Δ, we have hα = [e - α, eα]∈H and the Chevalley basis of L is the set {eα}α∈Φ∪{hα}α∈Δ. The Z-span of the Chevalley basis is the Lie algebra (L)Z.

Given a field F, define (L)F = (L)Z tensor F. For all roots α there is a homomorphism xα from the additive group of F to GL((L)F) given by

xα(ξ) = 1 + ξ ad eα + (ξ2/2!)(ad eα)2 + ... .

Then

G_(egtrm ad)(F) = < xα(ξ) | ξ∈F, α∈Φ >.

is the adjoint Chevalley group. Other than a few exceptions of rank 1 or 2 over fields of at most 3 elements these groups are simple. However, G_(egtrm ad)(F) is generally not the adjoint group of Lie type in the sense of linear algebraic groups (see [Car93, p. 39]).

More generally, given a representation varphi : (L)Z to GL(M), where M is a Z-module, we may define root elements

xα(ξ) = 1 + ξvarphi(eα) + (ξ2/2!)varphi(eα)2 + ... .

and set

Gvarphi(F) = < xα(ξ) | ξ∈F, α∈Φ >.

This is also called a Chevalley group.

Suppose that Δ = {α1, ..., αn} and that Φ' is a root subsystem of Φ with simple roots Δ'⊂Δ such that Δ - Δ' = {αi} for some i. The restriction of the adjoint action of (L)Z to the Lie subalgebra (L)Z' corresponding to Φ' preserves the Z-submodule V of (L)Z whose basis is the set X of elements eβ such that the coefficient of αi is 1 when β is expressed as a sum of simple roots.

For root data of types A, B, C, D and rank n and types (E)6 and (E)7, the embedding in the root datum of rank n + 1 adds an extra node to the Dynkin diagram and the construction of the previous paragraph produces the "standard module" for the corresponding Chevalley group. For groups of type (E)8 the "standard module" is the adjoint representation.

The construction of the "standard modules" for groups of types (F)4 and (G)2 is more complicated. In order to defined them we identify the Lie algebra of type (F)4 with the algebra of fixed points of the graph automorphism order 2 of (E)6 and identify the Lie algebra of type (G)2 with the fixed points of a graph automorphism of order 3 of (D)4.

StandardLieRepresentation(t,r) : MonStgElt, RngIntElt -> SeqEnum, SeqEnum
This function returns two sequences of lower triangular integer matrices defining the action of the Z-form (L)Z of the simple Lie algebra of type t and rank r on its "standard module". The first sequence represents the simple roots and the second sequence represents the negatives of the simple roots.
AdjointChevalleyGroup(t,r,q) : MonStgElt,RngIntElt,RngIntElt -> GrpMat
This function returns the adjoint Chevalley group of type t and rank r over the field of q elements as a matrix group. The generators are Curtis--Steinberg--Tits generators.

Example GrpLie_AdjointChev (H110E27)

The adjoint Chevalley group of type (B)n(q) is isomorphic to the permutation group (P)Ω(2n + 1, q).
> n := 2;
> q := 5;
> G := AdjointChevalleyGroup("B",n,q);
> Type(G),Dimension(G);
GrpMat 10
> H := POmega(2*n+1,q);
> Type(H), Degree(H);
GrpPerm 156
> flag, _ := IsIsomorphic(G,H);
> flag;
true
LieRootMatrix(R,α,B) : RootDtm,ModTupFldElt,SetIndx -> AlgMatElt
    Basis: MonStgInt                    Default: "Root"
The matrix of ad (eα) acting on the module with basis B (on the right), where B must be a subset of the positive or the negative roots of the root datum R, as outlined in the construction above. By default α is a vector with respect to the root basis.
LieTypeGenerators(t,k,q) : MonStgElt, RngIntElt, RngIntElt -> SeqEnum,SeqEnum
LieTypeGenerators(t,k,K) : MonStgElt, RngIntElt, FldFin -> SeqEnum,SeqEnum
LieTypeGenerators(G) : GrpLie -> SeqEnum,SeqEnum
    GS: BoolElt                         Default: false
The Curtis--Steinberg--Tits generators of a simply connected group G of Lie type or the simply connected group of Lie type t and rank r over the finite field K or Fq. This function is available for both twisted and untwisted groups. If GS is true, the Gilkey--Seitz structure constants and root order are used.
SLPGeneratorList(t,r,q) : MonStgElt, RngIntElt, RngIntElt -> SeqEnum, SeqEnum
    GS: BoolElt                         Default: false
The Curtis--Steinberg--Tits generators of the simply connected group of Lie type t and rank r over the field of q elements, returned as straight-line programs. If GS is true, the Gilkey--Seitz structure constants and root order are used.

Morphisms and the Row Reduction Algorithm

From an irreducible quasisimple matrix group H of known Lie type t and rank r over the field of q elements, the work of [LO16] produces Curtis--Steinberg--Tits generators X, Y as part of the constructive recognition algorithm. This section describes some functions to construct homomorphisms ρ : G to H and their inverses from such generators, where G is the simply connected group of Lie type t, rank r over Fq.

From the homomorphism ρ : G to H and a matrix A∈H, an element g G such that ρ(g) = A can be constructed using the Chevalley normal form of the Bruhat decomposition of A. That is, we write g = uh/dot wu', where u, h, /dot w and u' have the properties described in Subsection Twisted Groups of Lie type. This uses the "row reduction" algorithms for twisted [CT] and untwisted [CMT04] groups (a generalisation of Gaussian row reduction of matrices to groups of Lie type).

Morphism(G,X,Y) : GrpLie,SeqEnum,SeqEnum -> Map
    OnlySimple: BoolElt                 Default: false
    GS: BoolElt                         Default: false
    Verify: BoolElt                     Default: false
Given an algebraically simple, simply connected group G of Lie type and Curtis--Steinberg--Tits generators for a representation, return the homomorphism from G to the group generated by X and Y. If generators X and Y are available only for the simple roots and their negatives, set OnlySimple to true. If the generators follow the Gilkey--Seitz conventions, set GS to true. If Verify is true, the function first checks that X and Y satisfy the appropriate CST presentation. This function applies to both twisted and untwisted groups.
ChevalleyForm(ρ,A) : Map[GrpLie,GrpMat], GrpMatElt -> SeqEnum, FldFinElt
Given a homomorphism ρ : G to H from a simply connected group G of Lie type to a matrix group H and a matrix A, this function returns a sequence s and a field element z. If A is not in the image of ρ (modulo scalars) then s = [ ], otherwise the elements of s = [u, h, /dot w, u'] are the components of the Chevalley normal form of an element g = uh/dot wu' such that A = zρ(g).

Example GrpLie_ChevForm (H110E28)

Choose a random element in a twisted group of Lie type, get a scalar multiple of its image in an irreducible highest weight representation and then check the Chevalley normal form.
> G := TwistedGroupOfLieType("2E",6,3);
> RootDatum(G);
Twisted simply connected root datum of dimension 6 of type 2E6,4
> Dimension(G);
78
> X,Y := CST_Generators("2E",6,3,[0,1,0,0,0,0]);
> rho := Morphism(G,X,Y);
> L := Codomain(rho);
> Dimension(L);
77
> F<t> := BaseRing(L);
> I := sub<L | &cat X, &cat Y>;
> g := Random(G);
> A := L!ScalarMatrix(77,t)*rho(g);
> s,z := ChevalleyForm(rho,A);
> z;
t
> &* s eq g;
true
PrepareRewrite(t,r,q,X,Y) : MonStgElt,RngIntElt,RngIntElt,SeqEnum,SeqEnum -> UserProgram, Map
TwistedPrepareRewrite(t,r,q,X,Y) : MonStgElt,RngIntElt,RngIntElt, SeqEnum,SeqEnum -> UserProgram, Map
    OnlySimple: BoolElt                 Default: false
    GS: BoolElt                         Default: false
This function constructs the group G of Lie type t and rank r over the field of q elements and the homomorphism f : G to H, where H is the matrix group generated by the CST generators X and Y. In addition to f this function returns a map varphi : H to G such that f varphi = idH.

If generators X and Y are available only for the simple roots and their negatives, set OnlySimple to true. If the generators follow the Gilkey--Seitz conventions, set GS to true.

LieTypeRewrite(t,r,q,X,Y,g) : MonStgElt,RngIntElt,RngIntElt,SeqEnum,SeqEnum,GrpMatElt -> BoolElt, GrpSLPElt
TwistedLieTypeRewrite(t,r,q,X,Y,g) : MonStgElt,RngIntElt,RngIntElt,SeqEnum,SeqEnum,GrpMatElt -> BoolElt, GrpSLPElt
    OnlySimple: BoolElt                 Default: false
    GS: BoolElt                         Default: false
Given a finite (untwisted or twisted) matrix group H with generators X, Y in CST format and an element g∈H, return a boolean flag b and, if b is true, an SLP π that expresses g as a word in the given generators.

If the parameter OnlySimple is true, the return value π is an SLP in the generators corresponding to the simple roots and their negatives. Set GS to true if the generators follow the Gilkey--Seitz conventions.

Example GrpLie_LieRewrite (H110E29)

Check that the SLP returned by TwistedLieTypeRewrite evaluates to the correct matrix when evaluated on the CST generators.
> X,Y := CST_Generators("3D",4,5,[]);
> H := sub< Parent(X[1,1]) | &cat X, &cat Y>;
> g := Random(H);
> flag, s := TwistedLieTypeRewrite("3D",4,5,X,Y,g);
> flag;
true
> gens := &cat X cat &cat Y;
> g eq Evaluate(s,gens);
true
RowReductionMap(ρ) : Map[GrpLie,GrpMat] -> UserProgram
TwistedRowReductionMap(ρ) : Map[GrpLie,GrpMat] -> UserProgram
Given an irreducible representation ρ : G(q)to GL(M) of an untwisted (resp. twisted) finite group G of Lie type, this function returns a function f such that ρ(f(A)) = A for all A in the image of A.

More precisely, given A in the codomain of ρ, the application of f to A returns two values: a sequence w of length 0 or 1, and an element z. If A is a scalar multiple of an element of the image of ρ, then w[1] is a Steinberg word in the domain of ρ and z is a field element such that zρ(w[1]) = A; otherwise w is empty and z is a message indicating the reason for failure. In particular, if A is in the image of ρ, then z is 1.

V2.28, 13 July 2023