%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%
%W group.tex GAP documentation Thomas Breuer
%W & Frank Celler
%W & Martin Schoenert
%W & Heiko Theissen
%%
%H @(#)$Id: group.tex,v 4.38.2.6 2006/09/16 18:57:15 jjm Exp $
%%
%Y Copyright 1997, Lehrstuhl D fuer Mathematik, RWTH Aachen, Germany
%%
%% This file contains a tutorial introduction to groups.
%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\Chapter{Groups and Homomorphisms}
In this chapter we will show some computations with groups. The examples
deal mostly with permutation groups, because they are the easiest
to input. The functions mentioned here, like `Group', `Size' or
`SylowSubgroup', however, are the same for all kinds of groups, although
the algorithms which compute the information of course will be different
in most cases.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\Section{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:
\beginexample
gap> s8 := Group( (1,2), (1,2,3,4,5,6,7,8) );
Group([ (1,2), (1,2,3,4,5,6,7,8) ])
\endexample
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_8$ 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.
\beginexample
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
\endexample
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.
\beginexample
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 ]
\endexample
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^3$.
\beginexample
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
\endexample
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.
\beginexample
gap> SetName( elab, "2^3" ); elab;
2^3
gap> norm := Normalizer( a8, elab );; Size( norm );
1344
\endexample
\index{homomorphism!natural}
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.
\beginexample
gap> hom := NaturalHomomorphismByNormalSubgroup( norm, elab );
<action epimorphism>
gap> f := Image( hom );
Group([ (), (), (), (4,5)(6,7), (4,6)(5,7), (2,3)(6,7), (2,4)(3,5),
(1,2)(5,6) ])
gap> Size( f );
168
\endexample
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.
\beginexample
gap> ker:= Kernel( hom );
2^3
gap> x := (1,8,3,5,7,6,2);; Image( hom, x );
(1,7,5,6,2,3,4)
gap> coset := PreImages( hom, last );
RightCoset(2^3,(2,8,6,7,3,4,5))
\endexample
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.
\beginexample
gap> rep:= Representative( coset );
(2,8,6,7,3,4,5)
gap> x * rep^-1 in ker;
true
\endexample
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.)
\beginexample
gap> IsSimple( f ); IsomorphismTypeInfoFiniteSimpleGroup( 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)" );
\endexample
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_3(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_3(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^3$ with this image of
$L_3(2)$.
\beginexample
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)" );
\endexample
By the way, you should not try the operator `\<' instead of the function
`IsSubgroup'. Something like
\beginexample
gap> elab < a8;
false
\endexample
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.
{\bf 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.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\Section{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.
In the following example we temporarily increase the line length limit
from its default value 80 to 82 in order to make the long expression fit
into one line.
\beginexample
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> SizeScreen([ 82, ]);;
gap> List( ccl, Size );
[ 1, 210, 105, 112, 1680, 1120, 2520, 1260, 1344, 1344, 1344, 3360, 2880, 2880 ]
gap> SizeScreen([ 80, ]);;
\endexample
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.
\beginexample
gap> class := First( ccl, c -> Size(c) = 112 );;
gap> op := Action( a8, AsList( class ) );;
\endexample
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 "ref: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'.
\beginexample
gap> IsPrimitive( op, [ 1 .. 112 ] );
false
gap> blocks := Blocks( op, [ 1 .. 112 ] );;
\endexample
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.
\beginexample
gap> Length( blocks[1] ); Length( blocks );
2
56
gap> op2 := Action( op, blocks, OnSets );;
gap> IsPrimitive( op2, [ 1 .. 56 ] );
true
\endexample
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~"ref: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.
\beginexample
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([ (1,4,2), (3,6,7), (3,8,5,7,6), (1,4)(7,8) ])
\endexample
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'.
\beginexample
gap> sgp := Normalizer( a8, Subgroup(a8,[Representative(class)]) );;
gap> Size( sgp );
360
gap> RepresentativeAction( a8, sgp, preim );
(3,4)(7,8)
\endexample
% The scalar product of permutation characters of two subgroups <U>, <V>,
% say, equals the number of $(<U>,<V>)$-double cosets. For example, the
% norm of the natural permutation character of degree eight is two since
% the action of `a8' on the cosets of a point stabilizer is at least doubly
% transitive. We also compute the numbers of $(`sgp',`sgp')$ and
% $(`sgp',`stab')$ double cosets.
% \b eginexample
% gap> stab := Stabilizer( a8, 1 );;
% gap> Length( DoubleCosets( a8, stab, stab ) );
% 2
% gap> Length( DoubleCosets( a8, sgp, sgp ) );
% 4
% gap> Length( DoubleCosets( a8, sgp, stab ) );
% 2
% \e ndexample
\index{homomorphism!operation} \index{homomorphism!action}\index{external set}
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 "ref:External Sets" in the reference manual. For the moment,
we need only know that the external set is obtained by the function
`UnderlyingExternalSet'.
\beginexample
gap> t := UnderlyingExternalSet( hom );
<xset:RightTransversal(2^3:L_3(2),Group(
[ (1,5)(2,6)(3,7)(4,8), (1,3)(2,4)(5,7)(6,8), (1,2)(3,4)(5,6)(7,8),
(5,6)(7,8), (5,7)(6,8), (3,4)(7,8), (3,5)(4,6) ]))>
\endexample
\index{right transversal}
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>\colon <D>\times <G>\to
<D>$. We can access these ingredients with the following functions:
\beginexample
gap> ActingDomain(t); # the group
2^3:L_3(2)
gap> Enumerator(t);
RightTransversal(2^3:L_3(2),Group(
[ (1,5)(2,6)(3,7)(4,8), (1,3)(2,4)(5,7)(6,8), (1,2)(3,4)(5,6)(7,8),
(5,6)(7,8), (5,7)(6,8), (3,4)(7,8), (3,5)(4,6) ]))
gap> FunctionAction(t);
function( pnt, elm ) ... end
gap> NameFunction( last );
"OnRight"
\endexample
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>'.
%\exercise In analogy to `OnRight' you might expect a function `OnLeft',
%but actually there are two functions `OnLeftInverse' and
%`OnLeftAntiOperation'. How are they defined and why?
%
%\answer `OnLeftInverse( <d>, <g> )' means `<g>^-1 * <d>', i.e.,
%multiplication with the inverse from the left, which defines an
%operation. In contrast, the mapping $<left>\colon (<d>,<g>) \mapsto <g>
%* <d>$ does not yield an operation, but an anti-operation, i.e., $<left>(
%<left>( <d>, <g>_1 ), <g>_2 ) = <left>( <d>, <g>_2 * <g>_1 )$, whereas
%for an operation, the right hand side is required to have the product
%$<g>_1 * <g>_2$. The {\GAP} function which performs this mapping <left>
%is therefore called `OnLeftAntiOperation', and, unlike `OnLeftInverse',
%this cannot be used as last argument to an operation function.
\index{enumerator}
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.
\beginexample
gap> elm := (1,4)(2,7)(3,6)(5,8);;
gap> Position( Enumerator(t), elm );
fail
gap> PositionCanonical( Enumerator(t), elm );
5
\endexample
\atindex{Position vs. PositionCanonical}{@\noexpand `Position' vs.\ %
\noexpand `PositionCanonical'}
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> )'.
%\exercise What would be the result of the function call
%`PositionCanonical( AsList(t), elm )' (where `AsList(t)' is equivalent to
%`AsList(Enumerator(t))')?
%
%\answer `fail', because `AsList(t)' is simply a list of representatives
%without any knowledge about the cosets they represent. In other words,
%{\GAP} does not know that they are representatives, and so the
%``canonical representative'' associated with `elm' is `elm' itself, which
%is not among the elements of the list.
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.
\beginexample
gap> Action( norm, Enumerator(t), OnRight ) = f;
true
gap> Action( t ) = f;
true
\endexample
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).
%\exercise Could these several meanings of `<d> ^ <g>' lead to
%ambiguities?
%
%\answer Yes, if <d> is a cyclotomic and <g> a positive integer, then `<d>
%^ <g>' could mean exponentiation as well as conjugation in the group of
%non-zero cyclotomics. To avoid such ambiguities, {\GAP} refuses to
%construct groups of cyclotomic numbers.
% \exercise What difference does it make whether something is stored in a
% record component like `hom!.externalSet' or as an attribute like
% `Enumerator(t)'?
%
% \answer A record component like `hom!.externalSet' must be entered when
% the object `hom' is constructed, which makes sense because an operation
% homomorphism like `hom' is constructed for a given external set.
% Attributes like `Enumerator(t)' need not be set upon construction of the
% object, they can be computed and stored when they are required for the
% first time and subsequently be looked up. This mechanism is explained in
% section~"Attributes".
{\bf 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.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\Section{Subgroups!as Stabilizers}
Action functions can also be used without constructing external sets.
We will try to find several subgroups in `a8' as stabilizers of such
actions. One subgroup is immediately available, namely the stabilizer
of one point. The index of the stabilizer must of course be equal to the
length of the orbit, i.e.,~8.
\beginexample
gap> u8 := Stabilizer( a8, 1 );
Group([ (2,3,4), (2,4)(3,5), (2,6,4), (2,4)(5,7), (2,8,6,4)(3,5) ])
gap> Index( a8, u8 );
8
gap> Orbit( a8, 1 ); Length( last );
[ 1, 3, 2, 4, 5, 6, 7, 8 ]
8
\endexample
This gives us a hint how to find further subgroups. Each subgroup is the
stabilizer of a point of an appropriate transitive action (namely the
action on the cosets of that subgroup or another action that is
equivalent to this action). So the question is how to find other
actions. The obvious thing is to operate on pairs of points. So using
the function `Tuples' we first generate a list of all pairs.
\beginexample
gap> pairs := Tuples( [1..8], 2 );;
\endexample
Now we would like to have `a8' operate on this domain. But we cannot use
the default action `OnPoints' because `<list> ^ <perm>' is not
defined. So we must tell the functions from the actions package how
the group elements operate on the elements of the domain. In our example
we can do this by simply passing `OnPairs' as an optional last argument.
All functions from the actions package accept such an optional argument
that describes the action. One example is `IsTransitive'.
\beginexample
gap> IsTransitive( a8, pairs, OnPairs );
false
\endexample
The action is of course not transitive, since the pairs `[ 1, 1 ]' and
`[ 1, 2 ]' cannot lie in the same orbit.
So we want to find out what the orbits are.
The function `Orbits' does that for us.
It returns a list of all the orbits.
We look at the orbit lengths and representatives for the orbits.
\beginexample
gap> orbs := Orbits( a8, pairs, OnPairs );; Length( orbs );
2
gap> List( orbs, Length );
[ 8, 56 ]
gap> List( orbs, o -> o[1] );
[ [ 1, 1 ], [ 1, 2 ] ]
\endexample
The action of `a8' on the first orbit (this is the one containing
`[1,1]', try `[1,1] in orbs[1]') is of course equivalent to the original
action, so we ignore it and work with the second orbit.
\beginexample
gap> u56 := Stabilizer( a8, orbs[2][1], OnPairs );; Index( a8, u56 );
56
\endexample
So now we have found a second subgroup. To make the following
computations a little bit easier and more efficient we would now like to
work on the points `[1..56]' instead of the list of pairs. The function
`ActionHomomorphism' does what we need. It creates a homomorphism
defined on `a8' whose image is a new group that operates on `[1..56]' in
the same way that `a8' operates on the second orbit.
\beginexample
gap> h56 := ActionHomomorphism( a8, orbs[2], OnPairs );;
gap> a8_56 := Image( h56 );;
\endexample
We would now like to know if the subgroup `u56' of index 56 that we found
is maximal or not.
As we have used already in Section~"Actions of groups",
a subgroup is maximal if and only if the action on the cosets of this
subgroup is primitive.
\beginexample
gap> IsPrimitive( a8_56, [1..56] );
false
\endexample
Remember that we can leave out the function if we mean `OnPoints' but
that we have to specify the action domain for all action functions.
%\exercise What happens if you call a function like `Operation( <G>, <D>
%)', where the group <G> moves points that are not contained in the
%operation domain~<D>?
%
%\answer If the operation domain <D> is closed under the action of the
%group <G>, i.e., if it is a union of orbits, `Operation' will construct
%the operation only on that domain, i.e., it will compute the restriction
%of <G> to~<D>. If the operation domain is not closed, however, {\GAP}
%will fail to construct the generating permutations and return a
%`MagmaWithInverses( [ fail, \dots, fail ] )', which is no good for
%further computations. An exception to this rule is the function `Orbits':
%if <D> is not closed under <G>, then `Orbits( <G>, <D> )' silently
%replaces <D> by its closure under <G> and then computes the orbits. In
%other words, it computes all <G>-orbits that contain at least one point
%from the original~<D>.
We see that `a8_56' is not primitive. This means of course that the
action of `a8' on `orb[2]' is not primitive, because those two
actions are equivalent. So the stabilizer `u56' is not maximal. Let us
try to find its supergroups. We use the function `Blocks' to find a block
system. The (optional) third argument in the following example tells
`Blocks' that we want a block system where 1 and 14 lie in one block.
\beginexample
gap> blocks := Blocks( a8_56, [1..56], [1,14] );
[ [ 1, 3, 4, 5, 6, 14, 31 ], [ 2, 13, 15, 16, 17, 23, 24 ],
[ 7, 8, 22, 34, 37, 47, 49 ], [ 9, 11, 18, 20, 35, 38, 48 ],
[ 10, 25, 26, 27, 32, 39, 50 ], [ 12, 28, 29, 30, 33, 36, 40 ],
[ 19, 21, 42, 43, 45, 46, 55 ], [ 41, 44, 51, 52, 53, 54, 56 ] ]
\endexample
The result is a list of sets, such that `a8_56' operates on those sets.
Now we would like the stabilizer of this action on the sets. Because
we want to operate on the sets we have to pass `OnSets' as third
argument.
\beginexample
gap> u8_56 := Stabilizer( a8_56, blocks[1], OnSets );;
gap> Index( a8_56, u8_56 );
8
gap> u8b := PreImages( h56, u8_56 );; Index( a8, u8b );
8
gap> IsConjugate( a8, u8, u8b );
true
\endexample
So we have found a supergroup of `u56' that is conjugate in `a8' to `u8'.
This is not surprising, since `u8' is a point stabilizer, and `u56' is a
two point stabilizer in the natural action of `a8' on eight points.
Here is a *warning*: If you specify `OnSets' as third argument to a
function like `Stabilizer', you have to make sure that the point (i.e.
the second argument) is indeed a set. Otherwise you will get a puzzling
error message or even wrong results! In the above example, the second
argument `blocks[1]' came from the function `Blocks', which returns a
list of sets, so everything was OK.
Actually there is a third block system of `a8_56' that gives rise to a
third subgroup.
\beginexample
gap> blocks := Blocks( a8_56, [1..56], [1,13] );;
gap> u28_56 := Stabilizer( a8_56, [1,13], OnSets );;
gap> u28 := PreImages( h56, u28_56 );;
gap> Index( a8, u28 );
28
\endexample
We know that the subgroup `u28' of index 28 is maximal, because we know
that `a8' has no subgroups of index 2, 4, or 7. However we can also
quickly verify this by checking that `a8_56' operates primitively on the
28 blocks.
\beginexample
gap> IsPrimitive( a8_56, blocks, OnSets );
true
\endexample
`Stabilizer' is not only applicable to groups like `a8' but also to their
subgroups like `u56'. So another method to find a new subgroup is to
compute the stabilizer of another point in `u56'. Note that `u56' already
leaves 1 and 2 fixed.
\beginexample
gap> u336 := Stabilizer( u56, 3 );;
gap> Index( a8, u336 );
336
\endexample
Other functions are also applicable to subgroups. In the following we
show that `u336' operates regularly on the 60~triples of `[4..8]' which
contain no element twice. We constuct the list of these 60~triples with
the function `Orbit' (using `OnTuples' as the natural generalization of
`OnPairs') and then pass it as action domain to the function
`IsRegular'. The positive result of the regularity test means that this
action is equivalent to the actions of `u336' on its 60 elements
from the right.
\beginexample
gap> IsRegular( u336, Orbit( u336, [4,5,6], OnTuples ), OnTuples );
true
\endexample
Just as we did in the case of the action on the pairs above, we now
construct a new permutation group that operates on `[1..336]' in the same
way that `a8' operates on the cosets of `u336'. But this time we let `a8'
operate on a right transversal, just like `norm' did in the natural
homomorphism above.
\beginexample
gap> t := RightTransversal( a8, u336 );;
gap> a8_336 := Action( a8, t, OnRight );;
\endexample
To find subgroups above `u336' we again look for nontrivial block systems.
\beginexample
gap> blocks := Blocks( a8_336, [1..336] );; blocks[1];
[ 1, 43, 85 ]
\endexample
We see that the union of `u336' with its 43rd and its 85th coset
is a subgroup in `a8_336', its index is 112.
We can obtain it as the closure of `u336' with a representative
of the 43rd coset, which can be found as the 43rd element
of the transversal~`t'.
Note that in the representation `a8_336' on 336 points,
this subgroup corresponds to the stabilizer of the block `[ 1, 43, 85 ]'.
\beginexample
gap> u112 := ClosureGroup( u336, t[43] );;
gap> Index( a8, u112 );
112
\endexample
Above this subgroup of index 112 lies a subgroup of index 56, which is
not conjugate to `u56'. In fact, unlike `u56' it is maximal. We obtain
this subgroup in the same way that we obtained `u112', this time forcing
two points, namely 7 and 43 into the first block.
\beginexample
gap> blocks := Blocks( a8_336, [1..336], [1,7,43] );;
gap> Length( blocks );
56
gap> u56b := ClosureGroup( u112, t[7] );; Index( a8, u56b );
56
gap> IsPrimitive( a8_336, blocks, OnSets );
true
\endexample
We already mentioned in Section~"Actions of groups"
that there is another standard
action of permutations, namely the conjugation.
E.g., since no other action is specified in the following example,
`OrbitLength' simply operates via `OnPoints',
and because `$<perm>_1$ ^ $<perm>_2$' is defined as the conjugation
of $perm_2$ on $perm_1$, in fact we compute the length of
the conjugacy class of `(1,2)(3,4)(5,6)(7,8)'.
\beginexample
gap> OrbitLength( a8, (1,2)(3,4)(5,6)(7,8) );
105
gap> orb := Orbit( a8, (1,2)(3,4)(5,6)(7,8) );;
gap> u105 := Stabilizer( a8, (1,2)(3,4)(5,6)(7,8) );; Index( a8, u105 );
105
\endexample
Note that although the length of a conjugacy class of any element <elm>
in any finite group <G> can be computed as `OrbitLength( <G>, <elm> )',
the command `Size( ConjugacyClass( <G>, <elm> ) )' is probably more
efficient.
\beginexample
gap> Size( ConjugacyClass( a8, (1,2)(3,4)(5,6)(7,8) ) );
105
\endexample
Of course the stabilizer `u105' is in fact the centralizer of the element
`(1,2)(3,4)(5,6)(7,8)'. `Stabilizer' notices that and computes the
stabilizer using the centralizer algorithm for permutation groups. In the
usual way we now look for the subgroups above `u105'.
\beginexample
gap> blocks := Blocks( a8, orb );; Length( blocks );
15
gap> blocks[1];
[ (1,2)(3,4)(5,6)(7,8), (1,3)(2,4)(5,8)(6,7), (1,4)(2,3)(5,7)(6,8),
(1,5)(2,6)(3,8)(4,7), (1,6)(2,5)(3,7)(4,8), (1,7)(2,8)(3,6)(4,5),
(1,8)(2,7)(3,5)(4,6) ]
\endexample
To find the subgroup of index 15 we again use closure. Now we must be a
little bit careful to avoid confusion. `u105' is the stabilizer of
`(1,2)(3,4)(5,6)(7,8)'. We know that there is a correspondence between
the points of the orbit and the cosets of `u105'. The point
`(1,2)(3,4)(5,6)(7,8)' corresponds to `u105'.
To get the subgroup above `u105' that has index 15 in `a8',
we must form the closure of `u105' with an element of the coset that
corresponds to any other point in the first block.
If we choose the point `(1,3)(2,4)(5,8)(6,7)',
we must use an element of `a8' that maps `(1,2)(3,4)(5,6)(7,8)' to
`(1,3)(2,4)(5,8)(6,7)'.
The function `RepresentativeAction' does what we need.
It takes a group and two points and returns an element of the group
that maps the first point to the second.
In fact it also allows you to specify the action as an optional fourth
argument as usual, but we do not need this here.
If no such element exists in the group, i.e., if the two points do not
lie in one orbit under the group,
`RepresentativeAction' returns `fail'.
\beginexample
gap> rep := RepresentativeAction( a8, (1,2)(3,4)(5,6)(7,8),
> (1,3)(2,4)(5,8)(6,7) );
(2,3)(6,8)
gap> u15 := ClosureGroup( u105, rep );; Index( a8, u15 );
15
\endexample
`u15' is of course a maximal subgroup, because `a8' has no subgroups of
index 3 or~5. There is in fact another class of subgroups of index 15
above `u105' that we get by adding `(2,3)(6,7)' to `u105'.
\beginexample
gap> u15b := ClosureGroup( u105, (2,3)(6,7) );; Index( a8, u15b );
15
gap> RepresentativeAction( a8, u15, u15b );
fail
\endexample
`RepresentativeAction' tells us that there is no element <g> in `a8'
such that `u15 ^ <g> = u15b'. Because `^' also denotes the conjugation of
subgroups this tells us that `u15' and `u15b' are not conjugate.
{\bf Summary.} In this section we have demonstrated some functions from
the actions package. There is a whole class of functions that we did
not mention, namely those that take a single element instead of a whole
group as first argument, e.g., `Cycle' and `Permutation'. These are fully
described in Chapter "ref:Group Actions" in the reference
manual.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\Section{Group Homomorphisms!by Images}
We have already seen examples of group homomorphisms in the last
sections, namely natural homomorphisms and action homomorphisms. In
this section we will show how to construct a group homomorphism $G\to H$
by specifying a generating set for $G$ and the images of these generators
in~$H$. We use the function `GroupHomomorphismByImages( <G>, <H>, <gens>,
<imgs> )' where <gens> is a generating set for <G> and <imgs> is a list
whose $i$th entry is the image of `<gens>[ $i$ ]' under the homomorphism.
\beginexample
gap> s4 := Group((1,2,3,4),(1,2));; s3 := Group((1,2,3),(1,2));;
gap> hom := GroupHomomorphismByImages( s4, s3,
> GeneratorsOfGroup(s4), [(1,2),(2,3)] );
[ (1,2,3,4), (1,2) ] -> [ (1,2), (2,3) ]
gap> Kernel( hom );
Group([ (1,4)(2,3), (1,3)(2,4) ])
gap> Image( hom, (1,2,3) );
(1,2,3)
gap> Image( hom, DerivedSubgroup(s4) );
Group([ (1,3,2), (1,3,2) ])
\endexample
%notest
\beginexample
gap> PreImage( hom, (1,2,3) );
Error, <map> must be an inj. and surj. mapping called from
<function>( <arguments> ) called from read-eval-loop
Entering break read-eval-print loop ...
you can 'quit;' to quit to outer loop, or
you can 'return;' to continue
brk> quit;
\endexample
\beginexample
gap> PreImagesRepresentative( hom, (1,2,3) );
(1,4,2)
gap> PreImage( hom, TrivialSubgroup(s3) ); # the kernel
Group([ (1,4)(2,3), (1,3)(2,4) ])
\endexample
This homomorphism from $S_4$ onto $S_3$ is well known from elementary
group theory. Images of elements and subgroups under `hom' can be
calculated with the function `Image'. But since the mapping `hom' is not
bijective, we cannot use the function `PreImage' for preimages of
elements (they can have several preimages). Instead, we have to use
`PreImagesRepresentative', which returns one preimage if at least one
exists (and would return `fail' if none exists, which cannot occur for
our surjective `hom'.) On the other hand, we can use `PreImage' for the
preimage of a set (which always exists, even if it is empty).
Suppose we mistype the input when trying to construct a homomorphism,
as in the following example.
\beginexample
gap> GroupHomomorphismByImages( s4, s3,
> GeneratorsOfGroup(s4), [(1,2,3),(2,3)] );
fail
\endexample
There is no such homomorphism, hence `fail' is returned.
But note that because of this, `GroupHomomorphismByImages' must do
some checks, and this was also done for the mapping `hom' above.
One can avoid these checks if one is sure that the desired
homomorphism really exists.
For that, the function `GroupHomomorphismByImagesNC' can be used;
the `NC' stands for ``no check''.
But note that horrible things can happen if `GroupHomomorphismByImagesNC'
is used when the input does not describe a homomorphism.
\beginexample
gap> hom2 := GroupHomomorphismByImagesNC( s4, s3,
> GeneratorsOfGroup(s4), [(1,2,3),(2,3)] );
[ (1,2,3,4), (1,2) ] -> [ (1,2,3), (2,3) ]
gap> Size( Kernel(hom2) );
24
\endexample
In other words, {\GAP} claims that the kernel is the full `s4',
yet `hom2' obviously has some non-trivial images!
Clearly there is no such thing as a homomorphism
which maps an element of order~4 (namely, (1,2,3,4))
to an element of order~3 (namely, (1,2,3)).
*But if you use the command `GroupHomomorphismByImagesNC',
{\GAP} trusts you.*
\beginexample
gap> IsGroupHomomorphism( hom2 );
true
\endexample
And then it produces serious nonsense if the thing is not a homomorphism,
as seen above!
Besides the safe command `GroupHomomorphismByImages',
which returns `fail' if the requested homomorphism does not exist,
there is the function `GroupGeneralMappingByImages',
which returns a general mapping (that is, a possibly multi-valued
mapping) that can be tested with `IsGroupHomomorphism'.
\beginexample
gap> hom2 := GroupGeneralMappingByImages( s4, s3,
> GeneratorsOfGroup(s4), [(1,2,3),(2,3)] );;
gap> IsGroupHomomorphism( hom2 );
false
\endexample
\index{group general mapping}\index{cokernel}\index{kernel}
\atindex{GroupHomomorphismByImages vs. GroupGeneralMappingByImages}%
{@\noexpand `GroupHomomorphismByImages' vs.\ %
\noexpand `GroupGeneralMappingByImages'}
But the possibility of testing for being a homomorphism is not the only
reason why {\GAP} offers *group general mappings*. Another (more
important?) reason is that their existence allows ``reversal of arrows''
in a homomorphism such as our original `hom'. By this we mean the
`GroupHomomorphismByImages' with left and right sides exchanged, in which
case it is of course merely a `GroupGeneralMappingByImages'.
\beginexample
gap> rev := GroupGeneralMappingByImages( s3, s4,
> [(1,2),(2,3)], GeneratorsOfGroup(s4) );;
\endexample
Now we have
$a {\buildrel hom\over\longmapsto} b \iff b {\buildrel rev\over\longmapsto} a$
for $a\in `s4'$ and $b\in `s3'$. Since every
such $b$ has 4~preimages under `hom', it now has 4~images under `rev'.
Just as the 4~preimages form a coset of the kernel $V_4\le `s4'$ of
`hom', they also form a coset of the *cokernel* $V_4\le `s4'$ of
`rev'. The cokernel itself is the set of all images of `One( s3 )'
(it is a normal subgroup in the group of all images under `rev'). The
operation 'One' returns the identity element of a group, see "ref:One"
in the reference manual. And this is why {\GAP} wants to perform such
a reversal of arrows: it calculates the kernel of a homomorphism like
`hom' as the cokernel of the reversed group general mapping (here `rev').
\beginexample
gap> CoKernel( rev );
Group([ (1,4)(2,3), (1,3)(2,4) ])
\endexample
\index{group general mapping!single-valued}
\index{group general mapping!total}
The reason why `rev' is not a homomorphism is that it is not
single-valued (because `hom' was not injective). But there is another
critical condition: If we reverse the arrows of a non-surjective
homomorphism, we obtain a group general mapping which is not defined
everywhere, i.e., which is not total (although it will be single-valued
if the original homomorphism is injective). {\GAP} requires that a group
homomorphism be both single-valued and total,
so you will get `fail' if you say
`GroupHomomorphismByImages( <G>, <H>, <gens>, <imgs> )' where <gens> does
not generate <G> (even if this would give a decent homomorphism on the
subgroup generated by <gens>). For a full description,
see Chapter "ref:Group Homomorphisms" in the reference manual.
The last example of this section shows that the notion of kernel and
cokernel naturally extends even to the case where neither `hom2' nor its
inverse general mapping (with arrows reversed) is a homomorphism.
\beginexample
gap> CoKernel( hom2 ); Kernel( hom2 );
Group([ (2,3), (1,3) ])
Group([ (3,4), (2,3,4), (1,2,4) ])
gap> IsGroupHomomorphism( InverseGeneralMapping( hom2 ) );
false
\endexample
{\bf Summary.} In this section we have constructed homomorphisms by
specifying images for a set of generators. We have seen that by reversing
the direction of the mapping, we get group general mappings, which need
not be single-valued (unless the mapping was injective) nor total (unless
the mapping was surjective).
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\Section{Nice Monomorphisms}
For some types of groups, the best method to calculate in an isomorphic
group in a ``better'' representation (say, a permutation group). We call an
injective homomorphism, that will give such an isomorphic image a ``nice
monomorphism''.
For example in the case of a matrix group we can take the action on the
underlying vector space (or a suitable subset) to obtain such a
monomorphism:
\beginexample
gap> grp:=GL(2,3);;
gap> dom:=GF(3)^2;;
gap> hom := ActionHomomorphism( grp, dom );; IsInjective( hom );
true
gap> p := Image( hom,grp );
Group([ (4,7)(5,8)(6,9), (2,7,6)(3,4,8) ])
\endexample
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~"ref:Conjugacy Classes" in the reference manual).
\beginexample
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, 8, 12, 1, 8, 6, 6, 6 ]
\endexample
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 (such as the
`hom' in the previous example) and then proceeds as we have done above.
\beginexample
gap> grp:=GL(2,3);;
gap> IsHandledByNiceMonomorphism( grp );
true
gap> hom := NiceMonomorphism( grp );
<action isomorphism>
gap> p :=Image(hom,grp);
Group([ (4,7)(5,8)(6,9), (2,7,6)(3,4,8) ])
gap> cc := ConjugacyClasses( grp );; ForAll(cc, x-> x in gcls);
true
gap> ForAll(gcls, x->x in cc); # cc and gcls might be ordered differently
true
\endexample
Note that a nice monomorphism might be defined on a larger group than `grp'
-- so we have to use `Image(hom,grp)' and not only `Image(hom)'.
%\exercise (To be done after you know about methods and method selection,
%see Chapter~"Attributes and their Methods".) Study the {\GAP} library to
%find out how the finiteness of `grp' was determined in the above example.
%
%\answer `IsFinite' delegates to `Size' which delegates to `Enumerator'.
%This operation finally constructs a list of all group elements by
%repeated calls of `ClosureGroupDefault', which effectively performs an
%orbit algorithm for the group acting on itself via right multiplication.
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.
\beginexample
gap> p:=Group((1,7,6,8)(2,5,3,4), (1,2,6,3)(4,8,5,7));;
gap> aut := AutomorphismGroup( p );; NiceMonomorphism(aut);;
gap> niceaut := NiceObject( aut );
Group([ (1,2)(3,4), (3,4)(5,6), (1,5,2,6), (1,5,3)(2,6,4) ])
gap> IsomorphismGroups( niceaut, SymmetricGroup( 4 ) );
[ (1,2)(3,4), (3,4)(5,6), (1,5,2,6), (1,5,3)(2,6,4) ] ->
[ (1,4)(2,3), (1,3)(2,4), (1,4,2,3), (1,3,2) ]
\endexample
%\exercise The nice monomorphism associated with the automorphism group of
%`p' is an operation homomorphism. What is its underlying external set?
%
%\answer `UnderlyingExternalSet( NiceMonomorphism( aut ) )' gives the list
%\begintt|nobreak
%[ (1,2,5,7)(3,6,8,4), (1,3,5,8)(2,4,7,6), (1,4,5,6)(2,8,7,3),
% (1,6,5,4)(2,3,7,8), (1,7,5,2)(3,4,8,6), (1,8,5,3)(2,6,7,4) ]
%\endtt
%which contains the six elements of order~4 in `p'. The automorphism group
%must permute these elements, and the action is faithful because they
%generate~`p'.
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.
\beginexample
gap> nicer := NiceMonomorphism(aut) * IsomorphismPcGroup(niceaut);;
gap> aut2 := GroupByGenerators( GeneratorsOfGroup( aut ) );;
gap> SetIsHandledByNiceMonomorphism( aut2, true );
gap> SetNiceMonomorphism( aut2, nicer );
gap> NiceObject( aut2 ); # a pc group
Group([ f4, f3, f1*f2^2*f3*f4, f2^2*f3*f4 ])
\endexample
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.
%\exercise In analogy to `IsomorphismPcGroup', there is also the command
%`IsomorphismPermGroup'. Continuing the first example of this section,
%what is the difference between `IsomorphismPermGroup( grp )' and
%`NiceMonomorphism( grp )'?
%
%\answer `IsomorphismPermGroup( grp )' returns a bijective mapping, in
%particular its `Range' is a permutation group of size~8, whereas a nice
%monomorphism which is an operation homomorphism has as `Range' a full
%symmetric group. Also a nice monomorphism could be defined on a larger
%group. This is not the case in the example `grp', but the nice
%monomorphism of a $d$-dimensional matrix group over the finite field with
%$q$ elements is defined on the general linear group~$GL(d,q)$.
{\bf 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.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\Section{Further Information about Groups and Homomorphisms}
Groups and the functions for groups are treated in Chapter~"ref:Groups".
There are several chapters dealing with groups in specific representations,
for example Chapter~"ref:Permutation Groups" on permutation groups,
"ref:Polycyclic Groups" on polycyclic (including finite solvable) groups,
"ref:Matrix Groups" on matrix groups and "ref:Finitely Presented Groups" on
finitely presented groups.
Chapter~"ref:Group Actions" deals with group actions. Group
homomorphisms are the subject of Chapter~"ref:Group Homomorphisms".
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%
%E group.tex . . . . . . . . . . . . . . . . . . . . . . . . . ends here
distrib
>
Mandriva
>
2010.0
>
i586
>
media
>
contrib-release
>
by-pkgid
>
5e1854624d3bc613bdd0dd13d1ef9ac7
>
files
>
3675
