5.2 Actions of Groups

In order to get another representation of a8, we consider another action, namely that on the elements of a certain conjugacy class by conjugation.

gap> ccl := ConjugacyClasses( a8 );; Length( ccl );
14
gap> List( ccl, c -> Order( Representative( c ) ) );
[ 1, 2, 2, 3, 6, 3, 4, 4, 5, 15, 15, 6, 7, 7 ]
gap> List( ccl, Size );
[ 1,210,105,112,1680,1120,2520,1260,1344,1344,1344,3360,2880,2880 ]

Note the difference between Order (which means the element order), Size (which means the size of the conjugacy class) and Length (which means the length of a list). We choose to let a8 operate on the class of length 112.

gap> class := First( ccl, c -> Size(c) = 112 );;
gap> op := Action( a8, AsList( class ) );;

We use AsList here to convert the conjugacy class into a list of its elements whereas we wrote Action( norm, elab ) directly in the previous section. The reason is that the elementary abelian group elab can be quickly enumerated by GAP whereas the standard enumeration method for conjugacy classes is slower than just explicit calculation of the elements. However, GAP is reluctant to construct explicit element lists, because for really large groups this direct method is infeasible.

Note also the function 'First', used to find the first element in a list which passes some test. See First in the reference manual for more details.

We now have a permutation representation op on 112 points, which we test for primitivity. If it is not primitive, we can obtain a minimal block system (i.e., one where the blocks have minimal length) by the function Blocks.

gap> IsPrimitive( op, [ 1 .. 112 ] );
false
gap> blocks := Blocks( op, [ 1 .. 112 ] );;

Note that we must specify the domain of the action. You might think that the functions IsPrimitive and Blocks could use [1..112] as default domain if no domain was given. But this is not so easy, for example would the default domain of Group( (2,3,4) ) be [1..4] or [2..4]? To avoid confusion, all action functions require that you specify the domain of action. If we had specified [1..113] in the primitivity test above, point 113 would have been a fixpoint (and the action would not even have been transitive).

Now blocks is a list of blocks (i.e., a list of lists), which we do not print here for the sake of saving paper (try it for yourself). In fact all we want to know is the size of the blocks, or rather how many there are (the product of these two numbers must of course be 112). Then we can obtain a new permutation group of the corresponding degree by letting op act on these blocks setwise.

gap> Length( blocks[1] );  Length( blocks );
2
56
gap> op2 := Action( op, blocks, OnSets );;
gap> IsPrimitive( op2, [ 1 .. 56 ] );
true

Note that we give a third argument (the action function OnSets) to indicate that the action is not the default action on points but an action on sets of elements given as sorted lists. (Section Basic Actions of the reference manual lists all actions that are pre-defined by GAP.)

The action of op on the given block system gave us a new representation on 56 points which is primitive, i.e., the point stabilizer is a maximal subgroup. We compute its preimage in the representation on eight points using the associated action homomorphisms (which of course are monomorphisms). We construct the composition of two homomorphisms with the * operator, reading left-to-right.

gap> ophom := ActionHomomorphism( a8, op );;
gap> ophom2 := ActionHomomorphism( op, op2 );;
gap> composition := ophom * ophom2;;
gap> stab := Stabilizer( op2, 2 );;
gap> preim := PreImages( composition, stab );
Group([(2,5,7),(1,4)(2,7),(2,6,7),(1,3)(5,7),(6,8,7)])

The normalizer of an element in the conjugacy class class is a group of order 360, too. In fact, it is a conjugate of the maximal subgroup we had found before, and a conjugating element in a8 is found by the function RepresentativeAction.

gap> sgp := Normalizer( a8, Subgroup(a8,[Representative(class)]) );;
gap> Size( sgp );
360
gap> RepresentativeAction( a8, sgp, preim );
(2,4)(7,8)

So far we have seen a few applications of the functions Action and ActionHomomorphism. But perhaps even more interesting is the fact that the natural homomorphism hom constructed above is also an action homomorphism; this is also the reason why its image is represented as a permutation group: it is the natural representation for actions. We will now look at this action homomorphism again to find out on what objects it operates. These objects form the so-called external set which is associated with every action homomorphism. We will mention external sets only superficially in this tutorial, for details see External Sets in the reference manual. For the moment, we need only know that the external set is obtained by the function UnderlyingExternalSet.

gap> t := UnderlyingExternalSet( hom );
<xset:RightTransversal(2^3:L_3(2),Group([ (3,4)(5,6), (3,5)(4,6), (2,3)(6,7), 
  (1,2)(7,8) ]))>

For the natural homomorphism hom the external set is a right transversal of a subgroup U in norm, and action on the right transversal really means action on the cosets of the subgroup U. When executing the function call

NaturalHomomorphismByNormalSubgroup( norm,
elab )

, GAP has chosen a subgroup U for which the kernel of this action (i.e., the core of U in norm) is the desired normal subgroup elab. For the purpose of operating on the cosets, the right transversal t contains one representative from each coset of U. Regarded this way, a transversal is simply a list of group elements, and you can make GAP produce this list by AsList(t). (Try it.)

The image of such a representative from AsList(t) under right multiplication with an element from norm will in general not be in AsList(t), because it will not be among the chosen representatives again. Hence right multiplication is not an action on AsList(t). However, GAP uses a special trick to be discussed below to make this a well-defined action on the cosets represented by the elements of AsList(t). For now, it is important to know that the external set t is more than just the right transversal on which the group norm operates. Altogether three things are necessary to specify an action: a group G, a set D, and a function opr :D ×G Ž D . We can access these ingredients with the following functions:

gap> ActingDomain(t); Enumerator(t); FunctionAction(t);
2^3:L_3(2) # the group
RightTransversal(2^3:L_3(2),Group([ (3,4)(5,6), (3,5)(4,6), (2,3)(6,7), 
  (1,2)(7,8) ]))
function( pnt, elm ) ... end
gap> NameFunction( last );
"OnRight"

The function which is named "OnRight" is also assigned to the identifier OnRight, and it means multiplication from the right; this is the usual way to operate on a right transversal. OnRight( d, g ) is defined as d * g.

Observe that the external set t and its Enumerator are printed the same way, but be aware that an external set also comprises the acting domain and the action function. The Enumerator itself, i.e., the right transversal, in turn comprises knowledge about the group norm and the subgroup U, and this is what allows the special trick promised above. As far as Position is concerned, the Enumerator behaves as an (immutable) list and you can ask for the position of an element in it.

gap> elm := (1,4)(2,7)(3,6)(5,8);;
gap> Position( Enumerator(t), elm );
fail
gap> PositionCanonical( Enumerator(t), elm );
1

The result fail means that the element was not found at all in the list: it is not among the chosen representatives. The difference between the functions Position and PositionCanonical is that the first simply looks whether elm is contained among the representatives which together form the right transversal t, whereas the second really looks for the position of the coset described by the representative elm. In other words, it first replaces elm by a canonical representative of the same coset (which must be contained in Enumerator(t)) and then looks for its position, hence the name. The function ActionHomomorphism (and its relatives) always use PositionCanonical when they calculate the images of the generators of the source group (here, norm) under the homomorphism (here, hom). Therefore they can give a well-defined action on an enumerator, even if the action would not be well-defined on AsList( enumerator ).

The image of the natural homomorphism is the permutation group f that results from the action of norm on the right transversal. It can be calculated by either of the following commands. The second of them shows that the external set t contains all information that is necessary for Action to do its work.

gap> Action( norm, Enumerator(t), OnRight ) = f;
true
gap> Action( t ) = f;
true

We have specified the action function OnRight in this example, but we have seen examples like Action( norm, elab ) earlier where this third argument was not given. If an action function is omitted, GAP always assumes OnPoints which is defined as OnPoints( d, g ) = d

g. This ``caret'' operator denotes conjugation in a group if both arguments d and g are group elements (contained in a common group), but it also denotes the natural action of permutations on positive integers (and exponentiation of integers as well, of course).

Summary. In this section we have learned how groups can operate on GAP objects such as integers and group elements. We have used ActionHomomorphism, among others, to construct a natural homomorphism, in which case the group operated on the right transversal of a suitable subgroup. This right transversal gave us an example for the use of PositionCanonical, which allowed us to specify cosets by giving representatives.

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

GAP 4 manual
February 2000