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

Identification

Subsections

Identification as an Abstract Group

NameSimple(G) : GrpPerm -> <RngIntElt, RngIntElt, RngIntElt>
Given a simple group G, determine the isomorphism type of G. The type is returned in the form of a triple of three integers f, d and q, where the interpretation of these integers is that given in the description of the function CompositionFactors.

Identification as a Permutation Group

The first functions described in this subsection detect whether or not a permutation group is alternating or symmetric in its natural representation. They are based on the algorithm `Detect Alternating' outlined in [CB92].

IsAlternating(G) : GrpPerm -> BoolElt
Returns true if the permutation group G defined as acting on X is the alternating group Alt(X).
IsSymmetric(G) : GrpPerm -> BoolElt
Returns true if the permutation group G defined as acting on X is the symmetric group Sym(X).
IsAltsym(G) : GrpPerm -> BoolElt
Returns true if the permutation group G defined as acting on X contains the alternating group Alt(X).
TwoTransitiveGroupIdentification(G) : GrpPerm -> Tup
Given a 2-transitive group G, return a tuple giving the abstract isomorphism type of the group. This is an implementation of the method of Cameron and Cannon [CC91].
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.

IsEven(G): GrpPerm -> BoolElt
Given a permutation group G check if G is even, ie. contained in the alternating group.

Example GrpPerm_RecogniseAltsym1 (H58E39)

We give an example of RecogniseAlternatingOrSymmetric in use.

> SetSeed(1);
> 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 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 GrpPerm_RecogniseAltsym2 (H58E40)

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.

> SetSeed(1);
> 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

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

Version: V2.19 of Mon Dec 17 14:40:36 EST 2012