5.1 Permutation groups

Permutation groups are so easy to input because their elements, i.e., permutations, are so easy to type: they are entered and displayed in disjoint cycle notation. So let's construct a permutation group:

gap> s8 := Group( (1,2), (1,2,3,4,5,6,7,8) );
Group( [ (1,2), (1,2,3,4,5,6,7,8) ] )

We formed the group generated by the permutations (1,2) and (1,2,3,4,5,6,7,8), which is well known to be the symmetric group on eight points, and assigned it to the identifier s8. Now the group S₈ contains the alternating group on eight points which can be described in several ways, e.g., as the group of all even permutations in s8, or as its derived subgroup.

gap> a8 := DerivedSubgroup( s8 );
Group([(1,2,3),(2,3,4),(2,4)(3,5),(2,6,4),(2,4)(5,7),(2,8,6,4)(3,5)])
gap> Size( a8 ); IsAbelian( a8 ); IsPerfect( a8 );
20160
false
true

Once information about a group like s8 or a8 has been computed, it is stored in the group so that it can simply be looked up when it is required again. This holds for all pieces of information in the previous example. Namely, a8 stores its order and that it is nonabelian and perfect, and s8 stores its derived subgroup a8. Had we computed a8 as CommutatorSubgroup( s8, s8 ), however, it would not have been stored, because it would then have been computed as a function of two arguments, and hence one could not attribute it to just one of them. (Of course the function CommutatorSubgroup can compute the commutator subgroup of two arbitrary subgroups.) The situation is a bit different for Sylow p-subgroups: The function SylowSubgroup also requires two arguments, namely a group and a prime p, but the result is stored in the group --- namely together with the prime p in a list called ComputedSylowSubgroups, but we won't dwell on the details here.

gap> syl2 := SylowSubgroup( a8, 2 );; Size( syl2 );
64
gap> Normalizer( a8, syl2 ) = syl2;
true
gap> cent := Centralizer( a8, Centre( syl2 ) );; Size( cent );
192
gap> DerivedSeries( cent );; List( last, Size );
[ 192, 96, 32, 2, 1 ]

We have typed double semicolons after some commands to avoid the output of the groups (which would be printed by their generator lists). Nevertheless, the beginner is encouraged to type a single semicolon instead and study the full output. This remark also applies for the rest of this tutorial.

With the next examples, we want to calculate a subgroup of a8, then its normalizer and finally determine the structure of the extension. We begin by forming a subgroup generated by three commuting involutions, i.e., a subgroup isomorphic to the additive group of the vector space 2³.

gap> elab := Group( (1,2)(3,4)(5,6)(7,8), (1,3)(2,4)(5,7)(6,8),
>                   (1,5)(2,6)(3,7)(4,8) );;
gap> Size( elab );
8
gap> IsElementaryAbelian( elab );
true

As usual, GAP prints the group by giving all its generators. This can be annoying, especially if there are many of them or if they are of huge degree. It also makes it difficult to recognize a particular group when there already several around. Note that although it is no problem for us to specify a particular group to GAP, by using well-chosen identifiers such as a8 and elab, it is impossible for GAP to use these identifiers when printing a group for us, because the group does not know which identifier(s) point to it, in fact there can be several. In order to give a name to the group itself (rather than to the identifier), you have to use the function SetName. We do this with the name 2^3 here which reflects the mathematical properties of the group. From now on, GAP will use this name when printing the group for us, but we still cannot use this name to specify the group to GAP, because the name does not know to which group it was assigned (after all, you could assign the same name to several groups). When talking to the computer, you must always use identifiers.

gap> SetName( elab, "2^3" ); elab;
2^3
gap> norm := Normalizer( a8, elab );; Size( norm );
1344

Now that we have the subgroup norm of order 1344 and its subgroup elab, we want to look at its factor group. But since we also want to find preimages of factor group elements in norm, we really want to look at the natural homomorphism defined on norm with kernel elab and whose image is the factor group.

gap> hom := NaturalHomomorphismByNormalSubgroup( norm, elab );
<action homomorphism>
gap> f := Image( hom );
Group([(),(),(),(1,2)(3,4),(1,3)(2,4),(1,2)(5,6),(3,5)(4,6),(2,3)(6,7)])
gap> Size( f );
168

The factor group is again represented as a permutation group. However, the action domain of this factor group has nothing to do with the action domain of norm. (It only happens that both are subsets of the natural numbers.) We can now form images and preimages under the natural homomorphism. The set of preimages of an element under hom is a coset modulo elab. We use the function PreImages here because hom is not a bijection, so an element of the range can have several preimages or none at all.

gap> ker:= Kernel( hom );
2^3
gap> x := (1,8,3,5,7,6,2);; Image( hom, x );
(1,3,2,6,5,4,7)
gap> coset := PreImages( hom, last );
RightCoset(2^3,( 2, 8, 6, 7, 3, 4, 5))

Note that GAP is free to choose any representative for the coset of preimages. Of course the quotient of two representatives lies in the kernel of the homomorphism.

gap> rep:= Representative( coset );
( 2, 8, 6, 7, 3, 4, 5)
gap> x * rep^-1 in ker;
true

The factor group f is a simple group, i.e., it has no non-trivial normal subgroups. GAP can detect this fact, and it can then also find the name by which this simple group is known among group theorists. (Such names are of course not available for non-simple groups.)

gap> IsSimple( f ); IsomorphismTypeFiniteSimpleGroup( f );
true
rec( series := "L", parameter := [ 2, 7 ], 
  name := "A(1,7) = L(2,7) ~ B(1,7) = O(3,7) ~ C(1,7) = S(2,7) ~ 2A(1,7) = U(2\
,7) ~ A(2,2) = L(3,2)" )
gap> SetName( f, "L_3(2)" );

We give f the name L_3(2) because the last part of the name string reveals that it is isomorphic to the simple linear group L₃(2). This group, however, also has a lot of other names. Names that are connected with a = sign are different names for the same matrix group, e.g., A(2,2) is the Lie type notation for the classical notation L(3,2). Other pairs of names are connected via , these then specify other classical groups that are isomorphic to that linear group (e.g., the symplectic group S(2,7), whose Lie type notation would be C(1,7)).

The group norm acts on the eight elements of its normal subgroup elab by conjugation, yielding a representation of L₃(2) in s8 which leaves one point fixed (namely point 1). The image of this representation can be computed with the function Action; it is even contained in the group norm and we can show that norm is indeed a split extension of the elementary abelian group 2³ with this image of L₃(2).

gap> op := Action( norm, elab );
Group( [ (), (), (), (5,6)(7,8), (5,7)(6,8), (3,4)(7,8), (3,5)(4,6), 
  (2,3)(6,7) ] )
gap> IsSubgroup( a8, op ); IsSubgroup( norm, op );
true
true
gap> IsTrivial( Intersection( elab, op ) );
true
gap> SetName( norm, "2^3:L_3(2)" );

By the way, you should not try the operator < instead of the function IsSubgroup. Something like

gap> elab < a8;
false

will not cause an error, but the result does not signify anything about the inclusion of one group in another; < tests which of the two groups is less in some total order. On the other hand, the equality operator = in fact does test the equality of its arguments.

Summary. In this section we have used the elementary group functions to determine the structure of a normalizer. We have assigned names to the involved groups which reflect their mathematical structure and GAP uses these names when printing the groups.

[Top] [Up] [Next] [Index]

GAP 4 manual
February 2000