For each finite non-abelian simple group S, we designate a specific standard copy of S. The standard copy has a designated set of standard generators. For example, the standard copy of Alt(n) is on n points; its standard generators are (1, 2, 3) and either of (3, ..., n) or (1, 2)(3, ..., n) according to the parity of n. For a projective representation, the standard copy is the quotient of a matrix group by its scalar subgroup. For example, the standard copy of PSL(n, q) is the quotient of SL(n, q) by its scalar subgroup.
To compute in a copy G of S, we first construct effective isomorphisms between G and its standard copy. We do this by finding generators in G that correspond to the standard generators of S under an isomorphism. More formally, a constructive recognition algorithm for a non-abelian simple group G (possibly with decorations) solves the following problem: construct an isomorphism φfrom G to a standard copy S of G, such that φ(g) can be computed efficiently for every g ∈G. This is done by constructing standard generators in both G and its standard copy S.
A rewriting algorithm for G solves the constructive membership problem: given g ∈U ≥G = < X >, decide whether or not g ∈G, and if so express g as an SLP in X. (Here U is the generic overgroup of G, such as GL(d, q) or Sym(n).) The rewriting algorithm is used to make the isomorphism between S and G effective. To compute the image of an arbitrary element s of S in G, we first write s as an SLP in the standard generators of S and then evaluate the SLP in the copy of the standard generators in G.
To verify that the homomorphism from S to G is an isomorphism, we can evaluate in G a standard presentation for S on its standard generators. If the copy of the standard generators in G satisfy the presentation, then we have proved that we have an isomorphism.
For a detailed discussion of these topics, see [O'B11], [LGO09].
This intrinsic produces the standard generators of Leedham-Green and O'Brien for the quasisimple classical group of specified type in dimension d over field of size q. The type is designated by the argument "type" which must be one of the strings "SL", "Sp", "SU", "Omega", "Omega-", or "Omega+". The standard generators defined a specific copy of a classical group and are defined in [LGO09] and [DLLGO13].
Case: MonStgElt Default: "unknown"
Randomiser: GrpRandProc Default:
The argument G must be a matrix group defined over a finite field such that G = < X > is conjugate to a quasisimple classical group in its natural representation in dimension at least 2. The intrinsic constructs a copy ( S) in G of the generators defined by StandardGenerators. If G is quasisimple and classical, then the function returns true, the standard generators ( S), and SLPs for these in X; otherwise it returns false.The result returned by the intrinsic ClassicalType (G) can be supplied using the optional parameter Case.
The parameter Randomiser allows the user to specify the random process that is be used to construct random elements and the SLPs returned for the standard generators are in the word group of this process. The default value of Randomiser is RandomProcessWithWords(G).
The implementations for even and odd characteristic were developed by Heiko Dietrich and Eamonn O'Brien respectively.
G is a classical group in its natural representation; return a change-of-basis matrix to conjugate the generators returned by ClassicalStandardGenerators to those returned by ClassicalConstructiveRecognition (G). The latter intrinsic must have been applied to G.
Method: MonStgElt Default: "choose"
Let G be a classical group of type type, which is one of the strings "SL", "Sp", "SU", "Omega", "Omega-", or "Omega+", with dimension dim over the field GF(q) generated by gens which satisfy ClassicalStandardPresentation (type, dim, q). Further, let g be an element of Generic(G).If g ∈G, then the function returns true and an SLP for g in gens; if g not∈G then the function searches for an SLP w such that g .Evaluate(w, gens) - 1 centralizes G; if it is successful, it returns false and w. Otherwise the function returns false, false.
The function chooses one of the following methods:
The optional parameter Method can be used to override the default choice of method. The possible values of Method are CharP and BB.
- (i)
- If G is in its natural representation and gens is ClassicalStandardGenerators (type, dim, q) then Elliot Costi's implementation [Cos09] is used.
- (ii)
- If (i) is not valid, but G is an absolutely irreducible representation in the defining characteristic, then another implementation developed by Csaba Schneider is used. This implementation is based on the description given by Costi [Cos09].
- (iii)
- If neither of (i) and (ii) is valid, then a "black-box" method, independent of the representation of G, developed by Csaba Schneider is used. This case is not yet implemented for orthogonal groups.
A description of the algorithm used in the defining characteristic case appears in [Cos09]; a short description of the black-box algorithm appears in [AMPS10]. The code was prepared for distribution by Csaba Schneider.
This is a faster specialized verson of the intrinsic ClassicalRewrite discussed above; it is designed for classical groups in their natural representation.The argument type must be one of the strings "SL", "Sp", "SU", "Omega", "Omega-", or "Omega+". Both CB and g are elements of some GL (d, q).
If g is a member of the group generated by ClassicalStandardGenerators (type, d, q)^(( CB)) then the function returns true and an SLP w such that Evaluate (w, ClassicalStandardGenerators (type, d, q)^(( CB))) = g. Otherwise the function returns false, false.
This algorithm was developed and implemented by Elliot Costi; the code was prepared for distribution by Csaba Schneider.
Projective: BoolElt Default: false
Given the specification type, d, q of a quasisimple group G, this intrinsic constructs a presentation on the standard generators for G. The string type must be one of "SL", "Sp", "SU", "Omega", "Omega-", or "Omega+", while d is the dimension and q is the cardinality of the finite field. The presentations are described in [LGO]. The relations are returned as SLPs together with the parent SLPGroup.If the parameter Projective is set to true, the intrinsic constructs a presentation for the corresponding projective group.
As our first illustration, we produce standard generators for SL(6, 53):
> E := ClassicalStandardGenerators ("SL", 6, 5^3); > E; [ [ 0 1 0 0 0 0] [ 4 0 0 0 0 0] [ 0 0 1 0 0 0] [ 0 0 0 1 0 0] [ 0 0 0 0 1 0] [ 0 0 0 0 0 1], [ 0 0 0 0 0 1] [ 4 0 0 0 0 0] [ 0 4 0 0 0 0] [ 0 0 4 0 0 0] [ 0 0 0 4 0 0] [ 0 0 0 0 4 0], [ 1 1 0 0 0 0] [ 0 1 0 0 0 0] [ 0 0 1 0 0 0] [ 0 0 0 1 0 0] [ 0 0 0 0 1 0] [ 0 0 0 0 0 1], [ $.1 0 0 0 0 0] [ 0 $.1^123 0 0 0 0] [ 0 0 1 0 0 0] [ 0 0 0 1 0 0] [ 0 0 0 0 1 0] [ 0 0 0 0 0 1] ]
We now perform constructive recognition on SL(6, 53), and so obtain S, conjugate to E in GL(6, 53). Observe that the change-of-basis matrix returned by ClassicalChangeOfBasis performs this conjugation.
> G := SL (6, 5^3); > f, S, W := ClassicalConstructiveRecognition (G); > f; true > CB := ClassicalChangeOfBasis (G); > E^CB eq S; true
Note that W is list of SLPs expressing S in terms of defining generators of G.
> S eq Evaluate (W, [G.i: i in [1..Ngens (G)]]); true
We next express a random element of G as a SLP in S and then check that the standard generators satisfy the standard presentation.
> g := Random (G); > f, w := ClassicalRewriteNatural ("SL", CB, g); > Evaluate (w, S) eq g; true > > P, R := ClassicalStandardPresentation ("SL", 6, 5^3); > Set (Evaluate (R, S)); { [ 1 0 0 0 0 0] [ 0 1 0 0 0 0] [ 0 0 1 0 0 0] [ 0 0 0 1 0 0] [ 0 0 0 0 1 0] [ 0 0 0 0 0 1] }
We perform constructive recognition on a random conjugate of Sp(10, 36) and again check that the standard generators satisfy the standard presentation.
> G := RandomConjugate (Sp(10, 3^6)); > f, S, W := ClassicalConstructiveRecognition (G); > f; true
The return variable W is list of SLPs expressing S in terms of defining generators of G.
> S eq Evaluate (W, [G.i: i in [1..Ngens (G)]]); true > > g := Random (G); > CB := ClassicalChangeOfBasis (G); > f, w := ClassicalRewriteNatural ("Sp", CB, g); > Evaluate (w, S) eq g; true > > P, R := ClassicalStandardPresentation ("Sp", 10, 3^6); > Set (Evaluate (R, S)); { [1 0 0 0 0 0 0 0 0 0] [0 1 0 0 0 0 0 0 0 0] [0 0 1 0 0 0 0 0 0 0] [0 0 0 1 0 0 0 0 0 0] [0 0 0 0 1 0 0 0 0 0] [0 0 0 0 0 1 0 0 0 0] [0 0 0 0 0 0 1 0 0 0] [0 0 0 0 0 0 0 1 0 0] [0 0 0 0 0 0 0 0 1 0] [0 0 0 0 0 0 0 0 0 1] }
As another demonstration, we constructively recognise Ω - (16, 26).
> G := RandomConjugate (OmegaMinus (16, 2^6)); > f, S, W := ClassicalConstructiveRecognition (G); > f; true
A random element of G is expressed as an SLP in S:
> g := Random (G); > CB := ClassicalChangeOfBasis (G); > f, w := ClassicalRewriteNatural ("Omega-", CB, g); > Evaluate (w, S) eq g; true
Finally, we illustrate using ClassicalRewrite to write an element of a classical group in a non-natural representation as an SLP in its standard generators.
> gens := [ExteriorSquare (x) : x in ClassicalStandardGenerators ("Sp", 6, 25)]; > G := sub<Universe (gens) | gens>; > x := Random (G); > f, w := ClassicalRewrite (G, gens, "Sp", 6, 25, x); > f; true > Evaluate (w, gens) eq x; true > f, w := ClassicalRewrite (G, gens, "Sp", 6, 25, x : Method := "BB"); > f; true > Evaluate (w, gens) eq x; true