5.5 Nice Monomorphisms

In this section we will construct a matrix group of degree 2 over the Gaussian rationals. Because the group of all invertible 2×2-matrices over this field is infinite, GAP cannot be sure from the beginning that our group is finite, even though we know that it is the quaternion group of order 8, hence finite. To investigate it, we will try to construct a monomorphism of the matrix group into a permutation group, which is much nicer to work with. The image of this nice monomorphism is then isomorphic to our matrix group, and we can perform calculations in the nice group and lift the results back to the matrix group with the nice monomorphism. (The imaginary root of -1 is obtained as E(4), a 4th primitive complex root of unity.) 

gap> i := E(4);; grp := Group([[i,0],[0,-i]],[[0,1],[-1,0]]);;
gap> SetName( grp, "Q8" );
gap> orb := Union( Orbits( grp, [ [1,0], [0,1] ] ) );
[ [ -1, 0 ], [ 0, -1 ], [ 0, 1 ], [ 0, -E(4) ], [ 0, E(4) ], [ 1, 0 ], 
  [ -E(4), 0 ], [ E(4), 0 ] ]
The list orb is the union of orbits under grp which contains a basis for the two-dimensional row vector space over the rationals. Therefore the action on orb is faithful on 8 points, and hence grp is finite. We have made use here of the possibility to call Orbits with a list that is not closed under the action: it will be replaced by the closure on which the orbits are then determined (in our case, there is only one orbit). 
gap> hom := ActionHomomorphism( grp, orb );; IsInjective( hom );
true
gap> p := Image( hom );
Group( [ (1,7,6,8)(2,5,3,4), (1,2,6,3)(4,8,5,7) ])
To demonstrate the technique of nice monomorphisms, we compute the conjugacy classes of the permutation group and lift them back into the matrix group with the monomorphism hom. Lifting back a conjugacy class means finding the preimage of the representative and of the centralizer; the latter is called StabilizerOfExternalSet in GAP (because conjugacy classes are represented as external sets, see Section Conjugacy Classes in the reference manual). 
gap> pcls := ConjugacyClasses( p );; gcls := [  ];;
gap> for pc  in pcls  do
>      gc:=ConjugacyClass(grp,PreImagesRepresentative(hom,Representative(pc)));
>      SetStabilizerOfExternalSet(gc,PreImage(hom,
>                                 StabilizerOfExternalSet(pc)));
>      Add( gcls, gc );
>    od;
gap> List( gcls, Size );
[ 1, 2, 2, 1, 2 ]
All the steps we have made above are automatically performed by GAP if you simply ask for ConjugacyClasses( grp ), provided that GAP already knows that grp is finite, e.g., because you asked IsFinite( grp ) before. The reason for this is that a finite matrix group like grp is ``handled by a nice monomorphism''. For such groups, GAP uses the command NiceMonomorphism to construct a monomorphism like hom and then proceeds as we have done above. 
gap> grp := Group([[i,0],[0,-i]],[[0,1],[-1,0]]);;
gap> IsFinite( grp );
true
gap> IsHandledByNiceMonomorphism( grp );
true
gap> hom := NiceMonomorphism( grp );
<action homomorphism>
gap> UnderlyingExternalSet( hom ); p := Image( hom );
<xset:[ [ -1, 0 ], [ 0, -1 ], [ 0, 1 ], [ 0, -E(4) ], [ 0, E(4) ], [ 1, 0 ], 
  [ -E(4), 0 ], [ E(4), 0 ] ]>
Group([ (1,7,6,8)(2,5,3,4), (1,2,6,3)(4,8,5,7) ])
gap> cc := ConjugacyClasses( grp );; ForAll(cc, x-> x in gcls); 
true
gap> ForAll(gcls, x->x in cc); # cc and gcls are ordered differently
true

Nice monomorphisms are not only used for matrix groups, but also for other kinds of groups in which one cannot calculate easily enough. As another example, let us show that the automorphism group of the quaternion group of order 8 is isomorphic to the symmetric group of degree 4 by examining the ``nice object'' associated with that automorphism group. 

gap> aut := AutomorphismGroup( p );; NiceMonomorphism(aut);;
gap> niceaut := NiceObject( aut );
Group([(1,4,2,3),(1,5,4)(2,6,3),(1,2)(3,4),(3,4)(5,6)])
gap> IsomorphismGroups( niceaut, SymmetricGroup( 4 ) );
[ (1,4,2,3), (1,5,4)(2,6,3), (1,2)(3,4), (3,4)(5,6) ]->
[ (1,4,2,3), (2,3,4), (1,2)(3,4), (1,4)(2,3) ]

The range of a nice monomorphism is in most cases a permutation group, because nice monomorphisms are mostly action homomorphisms. In some cases, like in our last example, the group is solvable and you might prefer a pc group as nice object. You cannot change the nice monomorphism of the automorphism group (because it is the value of the attribute NiceMonomorphism), but you can compose it with an isomorphism from the permutation group to a pc group to obtain your personal nicer monomorphism. If you reconstruct the automorphism group, you can even prescribe it this nicer monomorphism as its NiceMonomorphism, because a newly-constructed group will not yet have a NiceMonomorphism set. 

gap> nicer := NiceMonomorphism(aut) * IsomorphismPcGroup(niceaut);;
gap> aut2 := GroupByGenerators( GeneratorsOfGroup( aut ) );;
gap> SetIsHandledByNiceMonomorphism( aut2, true );
gap> SetNiceMonomorphism( aut2, nicer );
gap> NiceObject( aut2 );
Group([ f1*f2, f2^2*f3, f4, f3 ])  # a pc group
The star * denotes composition of mappings from the left to the right, as we have seen in Section Actions of groups above. Reconstructing the automorphism group may of course result in the loss of other information GAP had already gathered, besides the (not-so-)nice monomorphism.

Summary. In this section we have seen how calculations in groups can be carried out in isomorphic images in nicer groups. We have seen that GAP pursues this technique automatically for certain classes of groups, e.g., for matrix groups that are known to be finite.

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

GAP 4 manual
February 2000