[Next][Prev] [Right] [Left] [Up] [Index] [Root]

Group Recognition

Subsections

Constructive Recognition of Alternating Groups

RecogniseAlternatingOrSymmetric(G, n) : Grp, RngIntElt -> BoolElt, BoolElt, UserProgram, UserProgram
Constructive recognition of the group G, which will succeed with probability ≥1 - e5 if G is isomorphic to either the alternating or symmetric group of degree n > 11. The method is that of Beals et al [BLGN+03], implemented by Colva Roney-Dougal.

The return values start with a flag indicating success or failure. If the algorithm was successful, then there are three more return values: a flag which is true when G is symmetric and false when alternating, and two programs. The first program takes an element x of an overgroup of G and produces a boolean to indicate whether x ∈G and a permutation representing x in the natural action of Sn (if such a permutation exists). The second taking a permutation to the corresponding element of G. The programs define mutually inverse group isomorphisms, implemented as Magma functions.


Example GrpASim_RecogniseAltsym1 (H65E3)

We give an example of RecogniseAlternatingOrSymmetric in use.

> a:= AlternatingGroup(13);
> h:= Stabiliser(a, {1,2});
> k:= CosetImage(a, h);
> Degree(k);
78
> worked, is_sym, bb_to_perm, perm_to_bb:= 
> RecogniseAlternatingOrSymmetric(k, 13);
> worked;
true
> is_sym;
false
> x:= Sym(78)!(1, 35, 16, 28, 14, 26, 69, 5, 74)(2, 54, 
> 67, 18, 51, 63, 6, 50, 77)(3, 33, 78, 12, 34, 29, 19, 15, 73)
> (4, 52, 61, 24, 49, 60, 68, 38, 64)(7, 20, 71, 17,
> 32, 11, 72, 8, 36)(9, 76, 47, 31, 56, 62, 13, 53, 59)
> (10, 70, 57, 23, 37, 22, 21, 27, 25)(30, 45, 46, 43, 42,
> 44, 40, 41, 75)(39, 55, 65)(48, 66, 58);
> x in k;
true;
> in_k, perm_image:= bb_to_perm(x);
> in_k;
true
> perm_image;
(1, 2, 3)(4, 7, 12, 6, 10, 11, 13, 9, 8)
> perm_to_bb(perm_image) eq x;
true

RecogniseSymmetric(G, n: parameters) : Grp, RngIntElt -> BoolElt, Map, Map, Map, Map, BoolElt
    maxtries: RngIntElt                 Default: 100n + 5000
    Extension: BoolElt                  Default: false
The group G should be known to be isomorphic to the symmetric group Sn for some n ≥8. The Bratus-Pak algorithm [BP00] (implemented by Derek Holt) is used to define an isomorphism between G and Sn. If successful, return true, homomorphism from G to Sn, homomorphism from Sn to G, the map from G to its word group and the map from the word group to G.

If the optional parameter Extension is set, then the group G should be known to be isomorphic either to Sn or to a perfect central extension 2.Sn. In that case, the first two maps returned will be a homomorphism from G to Sn and a map from Sn to G that induces a homomorphism onto G/Z(G). The sixth value returned will be true, if G isomorphic to 2.Sn and false, if G isomorphic to 2.An.

If unsuccessful, false is returned. This will always occur if the input group is not isomorphic to Sn (or 2.Sn when Extension is set) with n ≥8, and may occur occasionally even when G is isomorphic to Sn. The optional parameter maxtries (default 100n + 5000) can be used to control the number of random elements chosen before giving up.

SymmetricElementToWord (G, g) : Grp, GrpElt -> BoolElt, GrpSLPElt
If g is an element of G which has been constructively recognised to be isomorphic to Sn (or 2.Sn), then return true and element of word group for G which evaluates to g. Otherwise return false. This facilitates membership testing in G.
RecogniseAlternating(G, n: parameters) : Grp, RngIntElt -> BoolElt, Map, Map, Map, Map, BoolElt
    maxtries: RngIntElt                 Default: 100n + 5000
    Extension: BoolElt                  Default: false
The group G should be known to be isomorphic to the alternating group An for some n ≥9. The Bratus-Pak algorithm [BP00] (implemented by Derek Holt) is used to define an isomorphism between G and An. If successful, return true, homomorphism from G to An, homomorphism from An to G, the map from G to its word group and the map from the word group to G.

If the optional parameter Extension is set, then the group G should be known to be isomorphic either to An or to a perfect central extension 2.An. In that case, the first two maps returned will be a homomorphism from G to An and a map from An to G that induces a homomorphism onto G/Z(G). The sixth value returned will be true, if G isomorphic to 2.An and false, if G isomorphic to 2.An.

If unsuccessful, false is returned. This will always occur if the input group is not isomorphic to An (or 2.An when Extension is set) with n ≥9, and may occur occasionally even when G is isomorphic to An. The optional parameter {tt maxtries} (default 100n + 5000) can be used to control the number of random elements chosen before giving up.

AlternatingElementToWord (G, g) : Grp, GrpElt -> BoolElt, GrpSLPElt
If g is an element of G which has been constructively recognised to be isomorphic to An (or 2.An), then return true and element of word group for G which evaluates to g. Otherwise return false. This facilitates membership testing in G.
GuessAltsymDegree(G: parameters) : Grp -> BoolElt, MonStgElt, RngIntElt
    maxtries: RngIntElt                 Default: 5000
    Extension: BoolElt                  Default: false
The group G should be believed to be isomorphic to Sn or An for some n > 6, or to 2.Sn or 2.An if the optional parameter Extension is set. This function attempts to determine n and whether G is symmetric or alternating. It does this by sampling orders of elements. It returns either false, if it is unable to make a decision after sampling maxtries elements (default 5000), or true, type and n, where type is "Symmetric" or "Alternating", and n is the degree. If G is not isomorphic to Sn or An (or 2.Sn or 2.An when Extension is set) for n > 6, then the output is meaningless - there is no guarantee that false will be returned. There is also a small probability of a wrong result or false being returned even when G is Sn or An with n > 6. This function was written by Derek Holt.

Example GrpASim_RecogniseAltsym2 (H65E4)

For a group G which is believed to be isomorphic to Sn or An for some unknown value of n > 6, the function GuessAltsymDegree can be used to try to guess n, and then RecogniseSymmetric or RecogniseAlternating can be used to confirm the guess.

> G:= sub< GL(10,5) |
> PermutationMatrix(GF(5),Sym(10)![2,3,4,5,6,7,8,9,1,10]), 
> PermutationMatrix(GF(5),Sym(10)![1,3,4,5,6,7,8,9,10,2]) >;
> GuessAltsymDegree(G);
true Alternating 10
> flag, m1, m2, m3, m4  := RecogniseAlternating(G,10);
> flag;
true
> x:=Random(G); Order(x);
8
> m1(x);
(1, 2, 4, 9, 10, 8, 6, 3)(5, 7)
> m2(m1(x)) eq x;
true
> m4(m3(x)) eq x;
true
> flag, w := AlternatingElementToWord(G,x);
> flag;
true
> m4(w) eq x;                                           
true
> y := Random(Generic(G));                   
> flag, w := AlternatingElementToWord(G,y);    
> flag;
false
> flag, m1, m2, m3, m4 := RecogniseAlternating(G,11);
> flag;
false
> flag, m1, m2, m3, m4 := RecogniseSymmetric(G,10);  
> flag;
false

The nature of the GuessAltsymDegree function is that it assumes that its input is either an alternating or symmetric group and then tries to guess which one and the degree. As such, it is almost always correct when the input is an alternating or symmetric group, but will often return a bad guess when the input group is not of this form, as in the following example.

> GuessAltsymDegree(Sym(50));
true Symmetric 50
> GuessAltsymDegree(Alt(73));
true Alternating 73
> GuessAltsymDegree(PSL(5,5)); 
true Alternating 82

Determining the Type of a Finite Group of Lie Type

Given a finite quasisimple group of Lie type in any representation, the functions in this section apply probabilistic algorithms to determine its defining characteristic and type as a Lie group.

LieCharacteristic(G : parameters) : Grp -> RngIntElt
    NumberRandom: RngIntElt             Default: 100
    Verify: BoolElt                     Default: true
Given a finite quasisimple permutation or matrix group G which is of Lie type, determine its defining characteristic. The Monte Carlo algorithm implemented by this function is that of Liebeck and O'Brien [LO07]. Since it is Monte Carlo, there is a small probability of error. The number of random elements considered is NumberRandom. If Verify is true, then we first verify that G is perfect by applying IsProbablyPerfect.

Example GrpASim_WriteOverSmallerField (H65E5)

> F := GF (4);
> w := PrimitiveElement (F);
> a := [
> 0,w^3,0,0,0,
> w^3,0,0,0,0,
> 0,0,0,w^3,0,
> 0,0,w^3,0,0,
> w^2,w^2,w^3,w^3,w^3];
> b := [
> 0,0,w^3,0,0,
> w^1,w^2,w^2,0,0,
> w^2,w^1,w^2,0,0,
> 0,0,0,0,w^3,
> w^2,w^2,w^2,w^3,w^3];
> G := sub <GL(5, F) | a, b>;
> LieCharacteristic(G);
11

LieType(G, p : parameters) : GrpMat, RngIntElt -> BoolElt, Tup
LieType(G, p : parameters) : GrpMat, RngIntElt -> BoolElt, Tup
    NumberRandom: RngIntElt             Default: 100
If the matrix or permutation group G is nearly simple, and its non-abelian composition factor is isomorphic to a group of Lie type in characteristic p, then this function returns true and its standard Chevalley name. Otherwise it returns false.

The algorithm is that of Babai, Kantor, Pálfy and Seress [BKPS02]; this implementation was developed by Malle and O'Brien. Since it is Monte Carlo, there is a small probability of error. The number of random elements considered is NumberRandom.

The standard name is a tuple that defines the isomorphism type of the composition factor. It is similar to that employed by CompositionFactors, described in the Permutation Groups chapter.

If the composition factor is a group of Lie type, then the tuple is <s, n, q> and it defines the adjoint Chevalley group of Lie series s and Lie rank n over GF (q). The tuple entries are valid arguments for ChevalleyGroup.

If the composition factor is an alternating group, and so lies in family 17, then the tuple is <17, n, 0> and it defines the alternating group of degree n.

If the composition factor is a sporadic group and so lies in family 18, then the tuple is <18, n, s>; the string s is its standard Atlas name and n is the number of the group in family 18.

SimpleGroupName(G : parameters): GrpMat -> BoolElt, List
SimpleGroupName(G : parameters): GrpPerm -> BoolElt, List
    NumberRandom: RngIntElt             Default: 100
If the matrix or permutation group G is nearly simple, this function returns true and a list of possible names for its non-abelian simple composition factor; otherwise it returns false. Since it is Monte Carlo, there is a small probability of error. The number of random elements considered is NumberRandom. The list of standard names follows the convention described above.

The algorithm and implementation were developed by Malle and O'Brien; it uses LieType and LieCharacteristic.


Example GrpASim_IdentifySimple (H65E6)

We create the classical group Ω(7, 5) in its natural representation and apply SimpleGroupName to it.

> SetSeed(1);
> G := Omega(7, 5);
> flag, name := SimpleGroupName(G);
> name;
[* <B, 3, 5> *]

We create a certain 5-dimensional matrix group over GF(3) and determine which simple group it is.

> F := GF(3);
> P := GL(5,F);
> gens := [
> P![2,1,2,1,2,2,0,0,0,2,0,2,0,0,0,0,1,2,0,1,1,0,2,2,1],
> P![2,1,0,2,1,1,2,0,2,2,1,1,2,1,1,0,2,0,1,1,1,1,2,2,2]];
> G := sub <P | gens>;
> flag, name := SimpleGroupName(G);
> flag;
true
> name;
[* <18, 1, M11> *]

> /* naming an alternating group */

> G := MatrixGroup<4, GF(2) |
>    [ 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0 ],
>    [ 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 0 ] >;
> flag, name := SimpleGroupName(G);
> flag;
true
> /* this is A5 */
> name; 
[* <17, 5, 0> *]
> /* naming a classical group */
> F := GF(7^2);
> P := GL (6,F);
> w := PrimitiveElement (F);
> gens := [
> P![w^12,w^36,  0,  5,  2,  0,w^44,w^36,  0,  6,  2,  0,
> w^42,w^42,w^28,w^22,w^22,  3,  4,  3,  0,w^36,w^12,  0,
> 2,  3,  0,w^20,w^12,  0,w^14,w^14,  1,w^18,w^18, w^4],
>
> P![w^38,w^26,w^25,w^21, w^9,  3,w^21,w^45,w^33, w^4,w^28,
> 2,  6,  4, w^1, w^7,w^15,  4,  1,w^36,w^35, w^5,w^41,  5,
> w^31, w^7,w^43,w^36,w^12,  1,w^34,w^42,w^11,w^39,w^47,  2]
> ];
> G := sub <P | gens>;
> flag, name := LieType(G, 5);
> flag;
true 
> name;
<A, 1, 5>
> /* so this is SL(2, 5) */ 

Classical Forms

Let G be an absolutely irreducible subgroup of GL(d, q). The following functions compute symplectic, unitary and orthogonal forms of the underlying vector space V left invariant by the action of G.

A bilinear form is a bilinear function κfrom V x V -> F. It is G-invariant modulo scalars if for each g ∈G there is a μg ∈F such that κ(vg, wg) = μg κ(v, w) for all v, w ∈V.

Now suppose that a |-> bar(a) is an automorphism of F of order 2. A sesquilinear form is a biadditive function κfrom V x V -> F such that κ( au, bv) = a bar(b) κ(u, v) for all u, v ∈V and a, b∈F. It is G-invariant modulo scalars if for each g ∈G there is a μg ∈F such that κ(vg, wg) = μg κ(v, w) for all v, w ∈V.

A quadratic form is a function chi : V -> F such that

(1)
chi(av) = a2 chi(v) for all a∈F, v∈V; and
(2)
the form κ, defined by κ(u, v) = chi( u + v ) - chi(u) - chi(v) for all u, v ∈V, is bilinear.

It is G-invariant if for each g ∈G, chi(vg) = chi(v) for all v ∈V. It is G-invariant modulo scalars if for each g ∈G there is a μg ∈F such that chi(vg) = μg chi(v) for all v ∈V.

A bilinear form which is G-invariant (modulo scalars) is represented by a matrix B such that g * B * (g)tr = μg B for all g∈G and is unique up to multiplication by an element of F. Assume F has an automorphism a |-> bar(a) of order 2; a sesquilinear form is a matrix B such that g * B * bar(g)tr = μg B for all g∈G and is unique up to multiplication by an element of F (where bar(g) denotes the matrix obtained from g by replacing each entry gij by bar(gij)). A quadratic form is represented by an upper triangular matrix Q such that the matrix g * Q * gtr, normalized into an upper triangular matrix, equals μg Q.

The functions below will exit with an error message if the input group G is reducible. They may also exit with error if G is not absolutely irreducible, or if Scalars is true and the derived subgroup [G, G] of G is not absolutely irreducible. They may however sometimes succeed in finding a fixed form when G is irreducible but not absolutely irreducible.

ClassicalForms(G: parameters): GrpMat -> Rec
    Scalars: BoolElt                    Default: false
Given as input a matrix group G acting absolutely irreducibly on the underlying vector space V over the field F, ClassicalForms will try to find a classical form which is G-invariant or prove that no such form exists. If the optional argument Scalars is true then it will look for a form which is G-invariant modulo scalars. When Scalars is true, it is only guaranteed to succeed when [G, G] acts absolutely irreducibly on V. If it finds a fixed form, then it will stop and will not look for alternative fixed forms of different types.

The classical forms are: symplectic (non-degenerate, alternating bilinear), unitary (non-degenerate sesquilinear) or orthogonal (a symmetric bilinear form and a quadratic form).

The function ClassicalForms returns a record forms which contains the components formType, sign, bilinearForm, sesquilinearForm, quadraticForm and scalars. Depending on the entry formType the record components are set to indicate:

"unknown": it is not known whether G fixes a classical form.
"linear": it is known that G does not fix a classical form modulo scalars.
"symplectic": G fixes a symplectic form modulo scalars. The matrix of the form is stored in bilinearForm and the scalars for each generator of G are stored in scalars. In characteristic two this also implies that no quadratic form is fixed.
"unitary": G fixes a unitary form (modulo scalars). The matrix of the form is stored in sesquilinearForm. The scalars for each generator of G are stored in scalars.
"orthogonalcircle":
"orthogonalplus":
"orthogonalminus": G fixes an orthogonal form modulo scalars. The matrix of the bilinear form is stored in bilinearForm and the corresponding quadratic form in quadraticForm. The scalars for each generator of G are stored in scalars. In the orthogonal case, sign is set to 0, 1, or -1 when formType is "orthogonalcircle", "orthogonalplus", or "orthogonalminus", respectively.
SymplecticForm(G: parameters) : GrpMat -> BoolElt, AlgMatElt [,SeqEnum]
    Scalars: BoolElt                    Default: false
If the absolutely irreducible group G preserves a symplectic form (modulo scalars if the optional argument Scalars is true), this function returns true and the matrix of the form. If it is known that G does not preserve such a form it returns false. If it cannot decide (perhaps because the group does not act absolutely irreducibly), then it exits with an error message. If Scalars is true, then the list of scalars for the generators of G is also returned.
SymmetricBilinearForm(G: parameters) : GrpMat -> BoolElt, AlgMatElt, MonStgElt [,SeqEnum]
    Scalars: BoolElt                    Default: false
If the absolutely irreducible group G preserves an orthogonal form (modulo scalars if the optional argument Scalars is true), then this function returns true, the matrix of the symmetric bilinear form, and the type of the form (as in ClassicalForms). If it is known that G does not preserve such a form, it returns false. If it cannot decide, then it exits with an error message. If Scalars is true, then the list of scalars for the generators of G is also returned.
QuadraticForm(G): GrpMat -> BoolElt, AlgMatElt, MonStgElt [,SeqEnum]
    Scalars: BoolElt                    Default: false
If the absolutely irreducible group G preserves a quadratic form (modulo scalars if the optional argument Scalars is true), this function returns true, the matrix of the form in upper triangular form, and the type of the form (as in ClassicalForms). If it is known that G does not preserve such a form it returns false. If it cannot decide, then it exits with an error message. If Scalars is true, then the list of scalars for the generators of G is also returned.
UnitaryForm(G) : GrpMat -> BoolElt, AlgMatElt [,SeqEnum]
    Scalars: BoolElt                    Default: false
If the absolutely irreducible group G preserves a unitary form (non-degenerate sesquilinear) (modulo scalars if the optional argument Scalars is true), then this function returns true and the matrix of the form. If it is known that G does not preserve such a form, it returns false. If it cannot decide, then it exits with an error message. If Scalars is true, then the list of scalars for the generators of G is also returned.
FormType(G) : GrpMat -> MonStgElt
    Scalars: BoolElt                    Default: false
If the absolutely irreducible group G preserves a classical form (modulo scalars if the optional argument Scalars is true), this function returns its type (see ClassicalForms). Otherwise it returns "unknown".

Example GrpASim_ClassicalForms (H65E7)

> G := Omega( 9, 11 );
> ClassicalForms( G );
rec<recformat<bilinearForm, quadraticForm, sesquilinearForm, bilinFlag, 
sesquiFlag, scalars, formType, bc, n> | bilinearForm := 
[ 0  0  0  0  0  0  0  0  1]
[ 0  0  0  0  0  0  0  1  0]
[ 0  0  0  0  0  0  1  0  0]
[ 0  0  0  0  0  1  0  0  0]
[ 0  0  0  0  6  0  0  0  0]
[ 0  0  0  1  0  0  0  0  0]
[ 0  0  1  0  0  0  0  0  0]
[ 0  1  0  0  0  0  0  0  0]
[ 1  0  0  0  0  0  0  0  0], 
quadraticForm := 
[ 0  0  0  0  0  0  0  0  1]
[ 0  0  0  0  0  0  0  1  0]
[ 0  0  0  0  0  0  1  0  0]
[ 0  0  0  0  0  1  0  0  0]
[ 0  0  0  0  3  0  0  0  0]
[ 0  0  0  0  0  0  0  0  0]
[ 0  0  0  0  0  0  0  0  0]
[ 0  0  0  0  0  0  0  0  0]
[ 0  0  0  0  0  0  0  0  0], 
sesquilinearForm := false, bilinFlag := true,  sesquiFlag := false, 
scalars := [ 1, 1 ], formType := orthogonalcircle, sign := 0>
> FormType( G );
orthogonalcircle
> SymplecticForm( G );
false

TransformForm(form, type) : AlgMatElt, MonStgElt -> GrpMatElt
Return a matrix m such that Gm lies in the classical group returned by the Magma function GU, Sp, or GO(Plus/Minus). The argument form should be a classical form of type type fixed by an absolutely irreducible subgroup G of GL(d, q). It should be the bilinear or sesquilinear form fixed by G, except when G is orthogonal in characteristic 2, in which case it should be the quadratic form. The argument type should be as in the formType component of the record returned by ClassicalForms; i.e. one of "symplectic", "unitary", "orthogonalcircle", "orthogonalplus", or "orthogonalminus".
TransformForm(G) : GrpMat -> GrpMatElt
    Scalars: BoolElt                    Default: false
This function calls ClassicalForms to find a form fixed by the absolutely irreducible subgroup G of GL(d, q). If Scalars is true, then ClassicalForms is called with Scalars set to true, so that a form fixed module scalars is found. If a form form of type type is fixed, then it returns TransformForm(form, type). Otherwise it returns false.
SpinorNorm(g, form): GrpMatElt, AlgMatElt -> RngIntElt
The spinor norm of g with respect to the given form . form must be the matrix of an orthogonal form (ie, it must be symmetric and nonsingular), and g an element of the general orthogonal group GO(Plus/Minus) fixing that form. Note that the form is ignored in even characteristic, since the spinor norm of g is just equal to the rank modulo 2 of g - I in that case.

Recognizing Classical Groups in their Natural Representation

Let G be an irreducible subgroup of GL(d, q). The following algorithm is designed to test whether G contains the corresponding classical group Ωand is contained in Δ. Here Ωand Δare defined as follows:

Case "linear": Δ= GL(d, q), Ω= SL( d, q)
Case "symplectic": Δ= GSp(d, q), Ω= Sp( d, q)
Case "orthogonalplus": Δ= GO^ + (d, q), Ω= Ω^ + (d, q)
Case "orthogonalminus": Δ= GO^ - (d, q), Ω= Ω^ - (d, q)
Case "orthogonalcircle":Δ= GO(d, q), Ω= Ω(d, q)
Case "unitary": Δ= GU(d, q), Ω= SU(d, q)
RecognizeClassical( G : parameters): GrpMat -> BoolElt
    Case: MonStgElt                     Default: "unknown"
    NumberOfElements: RngIntElt         Default: 25
    SetVerbose("Classical", n):         Maximum: 3
RecognizeClassical takes as input a group G, which is a subgroup of GL(d, q).

The parameter Case is one of "linear", "symplectic", "orthogonalplus", "orthogonalminus", "orthogonalcircle", "unitary" or "unknown"; if Case is supplied, then the algorithm seeks to decide for this case only.

The parameter NumberOfElements is the number of random elements selected from G during the execution of the algorithm.

The output of RecognizeClassical is either true, false or "Does not apply". If the algorithm returns true, then we know with certainty that G contains Ωand is contained in Δ. Note that the proof of correctness of the algorithm depends on the finite simple group classification. If it returns false then either G does not contain Ω, or G is not contained in Δ, or G is not irreducible, or there is a small chance that G is contained in Δand contains Ω. More precisely, if the irreducible group G is contained in Δand really does contain Ωthen the probability with which the algorithm returns false is less than varepsilon, where varepsilon is a real number between 0 and 1. The smaller the value of varepsilon, the larger NumberOfElements must be. If the algorithm returns "Does not apply" then it is not applicable to the given group.

If "Classical" is set to verbose then, where RecognizeClassical returns true, it also prints the statement "Proved that the group contains a classical group of type case in n random selections", where n is the number of selections needed. If it returns false, it prints a statement giving some indication of why the algorithm reached this conclusion.

Theoretical details of the algorithms used may be found in Niemeyer & Praeger [NP97][NP98] [NP99] and Praeger [Pra99]. Its approach is based on the SL-recognition algorithm (Neumann & Praeger, [NP92]). This implementation also uses algorithms described in Celler & Leedham-Green [CLG97a][CLG97b] and Celler et al. [CLGM+95].

For small fields (q < 216), the cost of this implementation for a given value of NumberOfElements is O( d3 log d ) bit operations.

IsLinearGroup(G) : GrpMat -> BoolElt
This function tests whether the subgroup G of GL(d, q) contains SL(d, q). If the function can establish this fact, it returns true and otherwise false. Hence, if IsLinearGroup returns false, there is a small chance that G nevertheless contains SL(d, q). See RecognizeClassical for more details.
IsSymplecticGroup(G) : GrpMat -> BoolElt
This function tests whether the subgroup G of GSp(d, q) contains Sp(d, q). If the function can establish this fact, it returns true and otherwise false. Hence, if IsSymplecticGroup returns false, there is a small chance that G nevertheless contains Sp(d, q). See RecognizeClassical for more details.
IsOrthogonalGroup(G) : GrpMat ->BoolElt
This function tests whether the subgroup G of GOε(d, q) contains Ωε(d, q). If the function can establish this fact, it returns true and otherwise false. Hence, if IsOrthogonalGroup returns false, there is a small chance that G nevertheless contains Ωε(d, q). See RecognizeClassical for more details.
IsUnitaryGroup(G) : GrpMat -> BoolElt
This function tests whether the subgroup G of GU(d, q) contains SU(d, q). If the function can establish this fact, it returns true and otherwise false.
ClassicalType(G) : GrpMat -> MonStgElt
If G is known to be a classical subgroup of GL(d, q) this function returns the appropriate classical type as a string, i.e. "linear", "symplectic", "orthogonalplus", "orthogonalminus", "orthogonalcircle", or "unitary". Otherwise the function returns false.

Example GrpASim_RecognizeClassical (H65E8)

> G := SU (60, 9);
> SetVerbose( "Classical", true );
> RecognizeClassical( G );
true
> IsLinearGroup( G );
false
> IsUnitaryGroup( G );
true
> IsSymplecticGroup( G );
false
> IsOrthogonalGroup( G );
false
> ClassicalType( G );
unitary
> G := Sp (462, 3);
> time RecognizeClassical( G );
true
Time: 7.630

Constructive Recognition of Linear Groups

The functions in this section recognise whether of not a given group G is a specified linear group T. If it is, then an isomorphism between G and T is returned.

RecognizeSL2(G) : GrpMat -> BoolElt, Map, Map, Map, Map
RecognizeSL2(G) : GrpPerm -> BoolElt, Map, Map, Map, Map
RecognizeSL2(G, q) : GrpMat, RngIntElt -> BoolElt, Map, Map, Map, Map
RecognizeSL2(G, q) : GrpPerm, RngIntElt -> BoolElt, Map, Map, Map, Map
If G, a matrix or permutation group, is isomorphic, possibly modulo scalars, to (P)SL(2, q), then homomorphisms between G and (P)SL(2, q) are constructed. The function returns a homomorphism from G to (P)SL(2, q), a homomorphism from (P)SL(2, q) to G, the map from G to its word group, and the map from the word group to G.

If q, the cardinality of the defining field for G, is known, it should be supplied. Otherwise, the function SL2Characteristic is used to determine q; if q is large, this calculation may be expensive.

SL2ElementToWord(G, g) : GrpMat, GrpMatElt -> BoolElt, GrpSLPElt
SL2ElementToWord(G, g) : GrpPerm, GrpPermElt -> BoolElt, GrpSLPElt
If g is an element of the matrix or permutation group G which has been constructively recognised to have central quotient isomorphic to PSL(2, q), then return true and element of word group for G which evaluates to g, else false. This facilitates membership testing in G.
SL2Characteristic(G : parameters) : GrpMat -> RngIntElt, RngIntElt
SL2Characteristic(G : parameters) : GrpPerm -> RngIntElt, RngIntElt
    NumberRandom: RngIntElt             Default: 100
    Verify: BoolElt                     Default: true
Subject to the assumption that the group G has central quotient (P)SL(2, q), determine its characteristic and field size. The Monte Carlo algorithm implemented by this function is that of Liebeck and O'Brien [LO07]. Since it is Monte Carlo, there is a small probability of error. The number of random elements considered is NumberRandom. If Verify is true, then we first verify that G is perfect by applying IsProbablyPerfect.

The constructive recognition algorithms for SL(2, q) were developed by Conder, Leedham-Green and O'Brien [CLGO06]. The algorithm used for other representations was developed by Brooksbank and O'Brien.


Example GrpASim_RecognizeSL2-1 (H65E9)

Our first example uses G = SL(2, 32) in its natural representation. We first recognise the group and then express a random matrix of G as a word in the generators of G.

> G := SL(2, 3^2);
> flag, phi, tau, gamma, delta := RecogniseSL2(G, 3^2);
> g := G![1, 2, 0, 1];
> w := gamma(g);
> delta(w) eq g;
true

Example GrpASim_RecogniseSL2-2 (H65E10)

We now consider a representation of a 2-dimensional linear group inside GL(6, GF(57) ).

> K<w> := GF(5, 7);
> G := 
> MatrixGroup<6, GF(5, 7) |
> [w^19035, w^14713, w^50617, w^14957, w^51504, w^48397, w^16317, w^3829,
>  w^35189, w^2473, w^19497, w^77192, w^46480, w^6772, w^29577, w^61815,
>  w^54313, w^16757, w^43765, w^64406, w^58788, w^30789, w^13579, w^66728,
>  w^7733, w^45434, w^42411, w^61613, w^12905, w^6889, w^50116, w^16117,
>  w^56717, w^25226, w^49940, w^36836 ],
> [w^63955, w^40568, w^45004, w^11642, w^39536, w^11836, w^52594, w^71166,
>  w^47015, w^74450, w^32373, w^37021, w^76381, w^18155, w^57943, w^31194,
>  w^62524, w^65864, w^11868, w^76867, w^26483, w^41335, w^64856, w^41125,
>  w^43990, w^40104, w^24842, w^3153, w^23777, w^60024, w^14454, w^68648,
>  w^43403, w^26710, w^39779, w^22074 ] >;
>
> flag, phi, tau, gamma, delta := RecogniseSL2(G, 5^7);
> phi;
Mapping from: GrpMat: G to SL(2, GF(5, 7)) given by a rule [no inverse]
> g := Random(G);
> h := phi (g);
> h;
[w^40430   w^970]
[ w^5607 w^11606]
> k := tau(h);
> w := gamma(k);
> m := delta(w);

Recall that we are working modulo scalars.

> IsScalar(m * g^-1);
true
> H := SL(2, 5^7);
> h := H![1,1,0,1];
> g := tau(h);
> Order(g);
5 

We now test a random element of GL(6, GF(57) ) for membership of our group.

> g := Random(GL(6, 5^7));
> SL2ElementToWord(G, g);
false

RecogniseSL3(G) : GrpMat -> BoolElt, Map, Map, Map, Map
RecogniseSL3(G, q : parameters) : GrpMat, RngIntElt -> BoolElt, Map, Map, Map, Map
    Verify: BoolElt                     Default: true
If G ≤GL(d, F), is isomorphic, possibly modulo scalars, to (P)SL(3, q), then construct homomorphisms between G and (P)SL(3, q). Return homomorphism from G to (P)SL(3, q), homomorphism from (P)SL(3, q) to G, the map from G to its word group and the map from the word group to G.

If q, the cardinality of the defining field for G, is known, it should be supplied. Otherwise, it is computed using the functions LieCharacteristic and LieType.

If Verify is false, then assume G is isomorphic, possibly modulo scalars, to (P)SL(3, q).

SL3ElementToWord (G, g) : GrpMat, GrpMatElt -> BoolElt, GrpSLPElt
If g is an element of G which has been constructively recognised to have central quotient isomorphic to PSL(3, q), then return true and element of word group for G which evaluates to g, else false. This facilitates membership testing in G.

The constructive recognition algorithms for SL(3, q) were developed by Lübeck, Magaard, and O'Brien [LMO07]. Its current implementation, which is part of the CompositionTree package, was developed by Bäärnhielm and O'Brien.


Example GrpASim_RecogniseSL3 (H65E11)

We create SL(3, 54) in its natural representation and recognise it. We then form its symmetric square and apply the recognition machinery to that.

> G := SL(3, 5^4);
> flag, phi, tau, gamma, delta := RecogniseSL3(G);
> w := PrimitiveElement (GF(5^4));
> g := GL(3, 5^4)! [1,2,1,0,w,1,0,0,w^-1];
> w := gamma (g);
> delta (w) eq g;
true
> G := ActionGroup(SymmetricSquare(GModule(G)));
> flag, phi, tau, gamma, delta := RecogniseSL3(G);
> phi;
Mapping from: GL(6, GF(5, 4)) to SL(3, GF(5, 4)) given by a rule [no inverse]
> g := Random(G);
> h := phi(g);
> h;
[$.1^40430   $.1^970]
[ $.1^5607 $.1^11606]
> k := tau(h);
> w := gamma(k);
> m := delta(w);

Recall that we are working modulo scalars. We conclude by testing whether a random element of GL(6, 54) is contained in our group.

> IsScalar(m * g^-1);
true
> g := Random(GL(6, 5^4));
> SL3ElementToWord(G, g);
false

RecogniseSL(G, d, q) : Grp, RngIntElt, RngIntElt -> BoolElt, Map, Map
RecognizeSL(G, d, q) : Grp, RngIntElt, RngIntElt -> BoolElt, Map, Map
Use the Kantor-Seress algorithm to try to find an isomorphism between the finite group G (regarded as a black-box group) and SL(d, q) or PSL(d, q). The first return value indicates whether the attempt was successful. If so, then the second and third return values are mutually inverse homomorphisms (modulo scalars if G isomorphic to ( PSL)(d, q)) from G to SL(d, q) and from SL(d, q) to G.

Warning: This function often returns false even when G is isomorphic to SL(d, q) or PSL(d, q), so it should be called repeatedly until it returns true!

Constructive Recognition of Symplectic Groups

RecogniseSpOdd(G, d, q) : Grp, RngIntElt, RngIntElt -> BoolElt, Map, Map
RecognizeSpOdd(G, d, q) : Grp, RngIntElt, RngIntElt -> BoolElt, Map, Map
Use the Kantor-Seress algorithm to try to find an isomorphism between the finite group G (regarded as a black-box group) and Sp(d, q) or PSp(d, q) for odd q. The first return value indicates whether the attempt was successful. If so, then the second and third return values are mutually inverse homomorphisms (modulo scalars if G isomorphic to ( PSp)(d, q)) from G to Sp(d, q) and from Sp(d, q) to G.

Warning: This function often returns false even when G is isomorphic to Sp(d, q) or PSp(d, q), so it should be called repeatedly until it returns true!

RecogniseSp4Even(G, q) : Grp, RngIntElt, RngIntElt -> BoolElt, Map, Map
RecognizeSp4Even(G, q) : Grp, RngIntElt, RngIntElt -> BoolElt, Map, Map
Use an algorithm of Peter Brooksbank to try to find an isomorphism between the finite group G (regarded as a black-box group) and Sp(4, q) for even q. The first return value indicates whether the attempt was successful. If so, then the second and third return values are mutually inverse homomorphisms from G to Sp(d, q) and from Sp(d, q) to G. The third and fourth return values are mutually inverse homomorphisms from G to the word group W of G and from W to G.

Constructive Recognition of Unitary Groups

RecogniseSU3(G, d, q) : Grp, RngIntElt, RngIntElt -> BoolElt, Map, Map
RecognizeSU3(G, d, q) : Grp, RngIntElt, RngIntElt -> BoolElt, Map, Map
Use an algorithm of Peter Brooksbank to try to find an isomorphism between the finite group G (regarded as a black-box group) and SU(3, q) or PSU(3, q) for q>2. The first return value indicates whether the attempt was successful. If so, then the second and third return values are mutually inverse homomorphisms (modulo scalars if G isomorphic to ( PSU)(3, q)) from G to SU(3, q) and from SU(3, q) to G. The third and fourth return values are mutually inverse homomorphisms from G to the word group W of G and from W to G.
RecogniseSU4(G, d, q) : Grp, RngIntElt, RngIntElt -> BoolElt, Map, Map
RecognizeSU4(G, d, q) : Grp, RngIntElt, RngIntElt -> BoolElt, Map, Map
Use an algorithm of Peter Brooksbank to try to find an isomorphism between the finite group G (regarded as a black-box group) and SU(4, q) or PSU(4, q). The first return value indicates whether the attempt was successful. If so, then the second and third return values are mutually inverse homomorphisms (modulo scalars if G isomorphic to ( PSU)(4, q)) from G to SU(4, q) and from SU(4, q) to G. The third and fourth return values are mutually inverse homomorphisms from G to the word group W of G and from W to G.

Constructive Recognition of SL(d, q) in Low Degree

Let SL(d, q) ≤H ≤GL(d, q) with q=pf, where V is the natural H-module. Let H act on an irreducible GF(q)-module W of dimension at most d2. Magaard, O'Brien & Seress [MOAS08] describe algorithms which, given as input the irreducible representation of H on W, construct a d-dimensional projective representation of H. Their implementations, prepared by Eamonn O'Brien, are described below.

RecogniseSymmetricSquare (G) : GrpMat -> BoolElt, GrpMat
G is symmetric square representation of H, where SL(d, q) ≤H ≤GL(d, q) and d ≥4. Reconstruct H; if successful, then return true and H, otherwise false.
SymmetricSquarePreimage (G, g) : GrpMat, GrpMatElt -> GrpMatElt
G is symmetric square representation of H, where SL(d, q) ≤H ≤GL(d, q); return preimage of g in H.
RecogniseAlternatingSquare (G) : GrpMat -> BoolElt, GrpMat
G is alternating square representation of H, where SL(d, q) ≤H ≤GL(d, q) and d ≥3. Reconstruct H; if successful, then return true and H, otherwise false.
AlternatingSquarePreimage (G, g) : GrpMat, GrpMatElt -> GrpMatElt
G is alternating square representation of H, where SL(d, q) ≤H ≤GL(d, q); return preimage of g in H.
RecogniseAdjoint (G) : GrpMat -> BoolElt, GrpMat
G is adjoint representation of H, where SL(d, q) ≤H ≤GL(d, q) and d ≥3. Reconstruct H; if successful, then return true and H, otherwise false.
AdjointPreimage (G, g) : GrpMat, GrpMatElt -> GrpMatElt
G is adjoint representation of H, where SL(d, q) ≤H ≤GL(d, q); return preimage of g in H.
RecogniseDelta (G) : GrpMat -> BoolElt, GrpMat
G is absolutely irreducible representation of H tensor Hpe, where SL(d, q) ≤H ≤GL(d, q) and d ≥4. Reconstruct H; if successful, then return true and H, otherwise false.
DeltaPreimage (G, g) : GrpMat, GrpMatElt -> GrpMatElt
G is absolutely irreducible representation of H tensor H^(pe), where SL(d, q) ≤H ≤GL(d, q); return preimage of g in H.

Example GrpASim_RecogniseSymmetricSquare (H65E12)

> G := SL(4, 3^2);
> G := SL(4, 9);
> M := GModule (G);
> M := SymmetricPower (M, 2);
> G := MatrixGroup (M);
> G := RandomConjugate (G);
> f, H := RecogniseSymmetricSquare (G);
> f;
true
> H;
MatrixGroup(4, GF(3^2))
Generators:
    [    0     1     0     0]
    [    0     0     0     1]
    [$.1^6     2     2   $.1]
    [    2   $.1     0   $.1]

    [    0     0     1     0]
    [$.1^2 $.1^7     1 $.1^6]
    [    1     2 $.1^6 $.1^6]
    [  $.1     0 $.1^7     0]
> g := Random (G);
>  h := SymmetricSquarePreimage (G, g);
> h;
[$.1^6     0     0 $.1^2]
[$.1^6     0 $.1^3     0]
[$.1^2 $.1^5     2   $.1]
[    0 $.1^3 $.1^5   $.1]

Constructive Recognition of Suzuki Groups

Introduction

A description of the functionality for constructive recognition and constructive membership testing of the Suzuki groups ( Sz)(q), with q = 22m + 1 for some m > 0 follows.

The main intrinsics of the package are RecogniseSz(G) which performs constructive recognition of G isomorphic to ( Sz)(q), SzElementToWord(G, g) which returns a GrpSLPElt for g in the generators of G, and IsSuzukiGroup(G) which is a non-constructive test for isomorphism between G and ( Sz)(q).

Informative printing can be obtained using one of a number of verbose flags:

SuzukiGeneral, for the general routines.
SuzukiStandard, for the routines related to the standard copy.
SuzukiConjugate, for the routines related to conjugation.
SuzukiTensor, for the routines related to tensor decomposition.
SuzukiMembership, for the routines related to membership testing.
SuzukiCrossChar, for the routines related to cross-characteristic representations.
SuzukiTrick, for the routines related to the double coset trick.
SuzukiNewTrick, for the routines related to the stabiliser trick.

For each of the flags, the verbose level takes any value up to 10, with higher values resulting in more output.
Recognition Functions
IsSuzukiGroup(G) : GrpMat -> BoolElt, RngIntElt
Given a matrix group G, this function determines (non-constructively) whether or not G is isomorphic to ( Sz)(q). The corresponding finite field cardinality q is also returned.

If the group G is defined over a field of odd characteristic or has degree greater than 4, the Monte Carlo algorithm of LieType is used. If G has degree 4 and is over a field of characteristic 2, then a fast Las Vegas algorithm is used, described in [Baccent127aaccent127a06a].

RecogniseSz(G : parameters) : GrpMat -> BoolElt, Map, Map, Map, Map
RecognizeSz(G : parameters) : GrpMat -> BoolElt, Map, Map, Map, Map
    Verify: BoolElt                     Default: true
    FieldSize: RngIntElt                Default: 
    Optimise: BoolElt                   Default: false
Let G be a group that is absolutely irreducible and is defined over a minimal field. This function constructively recognises G as a Suzuki group. If G is isomorphic to ( Sz)(q), where q is the size of the defining field of G, then return:
Isomorphism from G to ( Sz)(q).
Isomorphism from ( Sz)(q) to G.
Map from G to the word group of G.
Map from the word group of G to G.

The isomorphisms are composed of maps that are defined by rules, so Function should be used on each component to avoid unnecessary built-in membership testing. The word group is the GrpSLP group which is the parent of the elements returned by SzElementToWord. In general this is not the same as WordGroup(G), but is created from it using AddRedundantGenerators.

If Verify is true, then it is checked if G is isomorphic to ( Sz)(q), using IsSuzukiGroup. In that case, FieldSize must be set to the correct value of q. Constructive recognition of 2.( Sz)(8) is also handled.

If Optimise is true, then the third map returns element in an optimised word group (using AddRedundantGenerators). Then each invocation of the map will be faster, but the initialisation will take longer.

The algorithms used for constructive recognition are described in [Baccent127aaccent127a06a] and [Baccent127aaccent127a05].

SzElementToWord(G, g) : GrpMat, GrpMatElt -> BoolElt, GrpSLPElt
If G has been constructively recognised as a Suzuki group, and if g is an element of G, then return true and a GrpSLPElt from the word group of G which evaluates to g, else return false.

This facilitates membership testing in G.

SzPresentation(q) : RngIntElt -> GrpFP, HomGrp
If q = 22m + 1 for some m > 0, return a short presentation of ( Sz)(q) on the Magma standard generators, i.e. the generators returned by the Sz intrinsic.
SatisfiesSzPresentation(G) : GrpMat -> BoolElt
G is constructively recognised as ( Sz)(q) for some q. Verify that it satisfies a presentation for this group.
SuzukiIrreducibleRepresentation(F, twists : parameters) : FldFin, SeqEnum[RngIntElt] -> GrpMat
    CheckInput: BoolElt                 Default: true
Let F be a finite field of cardinality q = 22m + 1 for some m > 0, and let twists be a sequence of n distinct integers in the range [0 ... 2m]. The function returns an absolutely irreducible representation of ( Sz)(q) having dimension 4n, being a tensor product of twisted powers of the copy returned by the Sz intrinsic, where the twists are given by the input sequence.

If CheckInput is true, then it is verified that F and twists satisfy the above requirements. Otherwise this is not checked.


Example GrpASim_ex-1 (H65E13)

We illustrate the basic facilities starting with a random conjugate of the standard version of the Suzuki group Sz(32). We first perform non-constructive recognition.

> G := Sz(32);
> G ^:= Random(Generic(G));
> flag, q := SuzukiRecognition(G);
> flag, q eq 32;
true true

The next step is to perform constructive recognition. The explicit isomorphisms will be the values of iso and inv.

> flag, iso, inv, g2slp, slp2g := RecognizeSz(G);
> flag;
true
> iso, inv;
Mapping from: GrpMat: G to MatrixGroup(4, GF(2^5)) given by a rule [no inverse]
Mapping from: MatrixGroup(4, GF(2^5)) to GrpMat: G given by a rule [no inverse]

We now experiment with membership testing. We use Function to avoid Magma's built-in membership testing but in doing so, we may not obtain the shortest possible SLP.

> w := Function(g2slp)(G.1);
> #w;
284

The algorithm is probabilistic, so different executions will most likely give different results.

> ww := Function(g2slp)(G.1);
> w eq ww;
false

Note that the resulting SLPs are from a word group that is not the word group W corresponding to the defining generators of G. However, they can be coerced into W.

> W := WordGroup(G);
> NumberOfGenerators(Parent(w)), NumberOfGenerators(W);
7 3
> flag, ww := IsCoercible(W, w);
> flag;
true
> slp2g(w) eq Evaluate(ww, UserGenerators(G));
true

So there are two ways to get the element back. An alternative is to use the intrinsic SzElementToWord, which is better if the elements are not known to lie in the group.

> flag, ww := SzElementToWord(G, G.1);
> flag, slp2g(w) eq slp2g(ww);
true true

We take an element just outside the group.

> H := Sp(4, 32);
> flag, ww := SzElementToWord(G, H.1);
> flag;
false
> // in this case we will not get an SLP
> ww := Function(g2slp)(H.1);
> ww;
false
> SatisfiesSzPresentation(G);
true

Example GrpASim_ex-2 (H65E14)

As a variation we apply the machinery to 2.Sz(8). We demonstrate constructive recognition and constructive membership testing.

> A := ATLASGroup("2Sz8");
> reps := MatRepKeys(A);
> G := MatrixGroup(reps[3]);
> Degree(G), CoefficientRing(G);
40 Finite field of size 7
> flag, iso, inv, g2slp, slp2g := RecognizeSz(G);
> flag;
true
> R := RandomProcess(G);
> g := Random(R);
> w := Function(g2slp)(g);
> slp2g(w) eq g;
true

Example GrpASim_ex-3 (H65E15)

For the next example we consider a case where the dimension is large. We construct the Suzuki group in a 64-dimensional matrix representation and then take a random conjugate and also rewrite is over a smaller field.

> F := GF(2, 9);
> twists := [0, 3, 6];
> G := SuzukiIrreducibleRepresentation(F, twists);
> Degree(G), IsAbsolutelyIrreducible(G);
64 true
> G ^:= Random(Generic(G));
> flag, GG := IsOverSmallerField(G);
> flag, CoefficientRing(GG);
true Finite field of size 2^3

Non-constructive recognition is harder in this case and will give us the defining field size. Constructive recognition will decompose the tensor product.

> time SuzukiRecognition(GG);
true 512
Time: 2.330
> time flag, iso, inv, g2slp, slp2g := RecogniseSz(GG);
Time: 4.800
> iso;
Mapping from: GrpMat: GG to MatrixGroup(4, GF(2^9)) given by a rule [no inverse]

Constructive membership is again easy

> R := RandomProcess(GG);
> g := Random(R);
> time w := Function(g2slp)(g);
Time: 0.020
> // but SLP evaluation is harder in large dimensions
> time slp2g(w) eq g;
true
Time: 0.370
> time SatisfiesSzPresentation(GG);
true
Time: 10.930

Example GrpASim_ex-4 (H65E16)

The final example will be in cross characteristic. We build a representation of Sz(8) in cross characteristic.

> G := Sz(8);
> _, P := SuzukiPermutationRepresentation(G);
> // for example over GF(9)
> M := PermutationModule(P, GF(3, 2));
> factors := CompositionFactors(M);
> exists(m64){f : f in factors | Dimension(f) eq 64};
true
> m64;
GModule m64 of dimension 64 over GF(3^2)
> H := ActionGroup(m64);
> IsAbsolutelyIrreducible(H);
true
> flag, G := IsOverSmallerField(H);
> Degree(G), CoefficientRing(G);
64 Finite field of size 3

We actually end up with a group in characteristic 3.

> time flag, iso, inv, g2slp, slp2g := RecogniseSz(G);
Time: 3.490
> iso;
Mapping from: GrpMat: G to MatrixGroup(4, GF(2^3)) given by a rule [no inverse]
> R := RandomProcess(G);
> g := Random(R);
> time w := Function(g2slp)(g);
Time: 0.010
> time slp2g(w) eq g;
true
Time: 0.110
> time SatisfiesSzPresentation(G);
true
Time: 0.330

Constructive Recognition of Small Ree Groups

Introduction

This machinery provides functionality for constructive recognition and constructive membership testing of the small Ree groups ( (2)G2)(q) = ( Ree)(q), with q = 32m + 1 for some m > 0.

The important intrinsics are RecogniseRee which performs constructive recognition of G isomorphic to ( Ree)(q), ReeElementToWord which returns a GrpSLPElt for g in the generators of G, and IsReeGroup which is a non-constructive test for isomorphism between G and ( Ree)(q).

There are a few verbose flags used in the package.

ReeGeneral, for the general routines.
ReeStandard, for the routines related to the standard copy.
ReeConjugate, for the routines related to conjugation.
ReeTensor, for the routines related to tensor decomposition.
ReeMembership, for the routines related to membership testing.
ReeCrossChar, for the routines related to cross-characteristic representations.
ReeTrick, for the routines related to the stabiliser trick.
ReeInvolution, for the routines related to involution centralisers.
ReeSymSquare, for the routines related to symmetric square decomposition.

All the flags can be set to values up to 10, with higher values resulting in more output.
Recognition Functions
RecogniseRee(G : parameters) : GrpMat -> BoolElt, Map, Map, Map, Map
RecognizeRee(G : parameters) : GrpMat -> BoolElt, Map, Map, Map, Map
    Verify: BoolElt                     Default: true
    FieldSize: RngIntElt                Default: 
    Optimise: BoolElt                   Default: false
G is absolutely irreducible and defined over minimal field. Constructively recognise G as a Ree group. If G is isomorphic to ( Ree)(q) where q is the size of the defining field of G, then return:
Isomorphism from G to ( Ree)(q).
Isomorphism from ( Ree)(q) to G.
Map from G to the word group of G.
Map from the word group of G to G.

The isomorphisms are composed of maps that are defined by rules, so Function should be used on each component to avoid unnecessary built-in membership testing.

The word group is the GrpSLP which is the parent of the elements returned by ReeElementToWord. In general this is not the same as WordGroup(G), but is created from it using AddRedundantGenerators.

If Verify is true, then it is checked that G is isomorphic to ( Ree)(q), using IsReeGroup, otherwise this is not checked. In that case, FieldSize must be set to the correct value of q.

If Optimise is true, then the third map returns element in an optimised word group (using AddRedundantGenerators). Then each invocation of the map will be faster, but the initialisation will take longer.

The algorithms for constructive recognition are those of [Baccent127aaccent127a06b].

ReeElementToWord(G, g) : GrpMat, GrpMatElt -> BoolElt, GrpSLPElt
If G has been constructively recognised as a Ree group, and if g is an element of G, then return true and a GrpSLPElt from the word group of G which evaluates to g, else return false.

This facilitates membership testing in G.

IsReeGroup(G) : GrpMat -> BoolElt, RngIntElt
Determine (non-constructively) if G is isomorphic to ( Ree)(q). The corresponding q is also returned.

If G is over a field of characteristic not 3 or has degree greater than 7, the Monte Carlo algorithm of LieType is used. If G has degree 7 and is over a field of characteristic 3, then a fast Las Vegas algorithm is used.

ReeIrreducibleRepresentation(F, twists : parameters) : FldFin, SeqEnum[RngIntElt] -> GrpMat
    CheckInput: BoolElt                 Default: true
The finite field F must have size q = 32m + 1 for some m > 0, and twists should be a sequence of n distinct pairs of integers (i, j) where i is 7 or 27 and j in the range [0 ... 2m].

Return an absolutely irreducible representation of ( Ree)(q), a tensor product of twisted powers of the representation of dimension 7 or 27, where the twists are given by the input sequence.

If CheckInput is true, then it is verified that F and twists satisfy the above requirements. Otherwise this is not checked.


Example GrpASim_ex-1 (H65E17)

Our first example shows off the recognition machinery for the Ree group defined over GF(27).

> SetSeed(1);
> F := GF(3, 3);
> G := ReeGroup(F);
> G ^:= Random(Generic(G));
> flag, q := ReeRecognition(G);
> flag, q eq #F;
true true
> flag, iso, inv, g2slp, slp2g := RecognizeRee(G);
> flag;
true
> iso, inv;
Mapping from: GrpMat: G to MatrixGroup(7, GF(3^3)) given by a rule [no inverse]
Mapping from: MatrixGroup(7, GF(3^3)) to GrpMat: G given by a rule [no inverse]

We now experiment with membership testing. As the algorithm is probabilistic, different executions will most likely give different results.

> w := Function(g2slp)(G.1);
> #w;
342
> ww := Function(g2slp)(G.1);
> w eq ww;
false

The resulting SLPs are from another word group but can be coerced into W.

> W := WordGroup(G);
> NumberOfGenerators(Parent(w)), NumberOfGenerators(W);
7 3
> flag, ww := IsCoercible(W, w);
> flag;
true
> // so there are two ways to get the element back
> slp2g(w) eq Evaluate(ww, UserGenerators(G));
true

If the elements are not known to lie in the group, a better alternative is to use the intrinsic ReeElementToWord. We take a generator of Ω(7, F) as an example of an element not lying in G2(27).

> flag, ww := ReeElementToWord(G, G.1);
> flag, slp2g(w) eq slp2g(ww);
true true
> H := Omega(7, #F);
> flag, ww := ReeElementToWord(G, H.1);
> flag;
false
> ww := Function(g2slp)(H.1);
> ww;
false

Constructive Recognition of Large Ree Groups

Introduction

This machinery provides functionality for constructive recognition and constructive membership testing of the large Ree groups ( (2)F4)(q) = ( LargeRee)(q), with q = 22m + 1 for some m > 0.

The important intrinsics are RecogniseLargeRee which performs constructive recognition of G isomorphic to ( LargeRee)(q), LargeReeElementToWord which returns a GrpSLPElt for g in the generators of G, and IsLargeReeGroup which is a non-constructive test for isomorphism between G and ( LargeRee)(q).

There are a few verbose flags used in the package.

LargeReeGeneral, for the general routines.
LargeReeStandard, for the routines related to the standard copy.
LargeReeConjugate, for the routines related to conjugation.
LargeReeRyba, for the routines related to membership testing.
LargeReeTrick, for the routines related to the stabiliser trick.
LargeReeInvolution, for the routines related to involution centralisers.
All the flags can be set to values up to 10, with higher values resulting in more output.
Recognition Functions
RecogniseLargeRee(G : parameters) : GrpMat -> BoolElt, Map, Map, Map, Map
RecognizeLargeRee(G : parameters) : GrpMat -> BoolElt, Map, Map, Map, Map
    Verify: BoolElt                     Default: true
    FieldSize: RngIntElt                Default: 
    Optimise: BoolElt                   Default: false
G is absolutely irreducible and defined over minimal field. Constructively recognise G as a Large Ree group. If G is isomorphic to ( LargeRee)(q) where q is the size of the defining field of G, then return:
Isomorphism from G to ( LargeRee)(q).
Isomorphism from ( LargeRee)(q) to G.
Map from G to the word group of G.
Map from the word group of G to G.

The isomorphisms are composed of maps that are defined by rules, so Function should be used on each component to avoid unnecessary built-in membership testing.

The word group is the GrpSLP which is the parent of the elements returned by LargeReeElementToWord. In general this is not the same as WordGroup(G), but is created from it using AddRedundantGenerators.

If Verify is true, then it is checked that G is isomorphic to ( LargeRee)(q), using IsLargeRee, otherwise this is not checked. In that case, FieldSize must be set to the correct value of q.

If Optimise is true, then the third map returns element in an optimised word group (using AddRedundantGenerators). Then each invocation of the map will be faster, but the initialisation will take longer.

LargeReeElementToWord(G, g) : GrpMat, GrpMatElt -> BoolElt, GrpSLPElt
If G has been constructively recognised as a Large Ree group, and if g is an element of G, then return true and a GrpSLPElt from the word group of G which evaluates to g, else return false.

This facilitates membership testing in G.

IsLargeReeGroup(G) : GrpMat -> BoolElt, RngIntElt
Determine (non-constructively) if G is isomorphic to ( LargeRee)(q). The corresponding q is also returned.

If G is over a field of characteristic not 2 or has degree greater than 26, the Monte Carlo algorithm of LieType is used. If G has degree 26 and is over a field of characteristic 2, then a fast Las Vegas algorithm is used.

 [Next][Prev] [Right] [Left] [Up] [Index] [Root]

Version: V2.19 of Wed Apr 24 15:09:57 EST 2013