Cape Coast, Ghana - August 2003
WASS: Lecture 2.
Enrico ROGORA
Version 0.1, 21th August 2003
Among the basic types which gap can deal with are truth values,
gap> true and false;
They are important to check if something is true or not. For example.
gap> h:=((1,2)*(1,3,4));
gap> g:=((1,2)(3,4,5));
gap> Comm(g,h)=Inverse(g)*Inverse(h)*g*h;
gap> IsAbelian(Group(g,h));
The GAP system contains a huge library of finite groups
already built in.
GAP allows you to build a great number of groups with a single command.
We have seen one already, for making a free group with three generators.
Now we show how to build some Basic Groups. For a complete account
see the reference Manual, section 48
As we have already seen there may be different presentations of
the same group.
Cyclic groups
gap> CyclicGroup(IsPermGroup,5);
gap> Elements(last);
gap> CyclicGroup(IsMatrixGroup,5)
gap> Elements(last);
Abelian Groups
gap> AbelianGroup(IsPermGroup,[2,2,3]);
gap> IsCyclic(AbelianGroup(IsPermGroup,[2,3]));
gap> G:=AbelianGroup(IsPermGroup,[2,3]);
gap> Filtered(Elements(G),x->Order(x)=6);
Dihedral groups
gap> DihedralGroup(IsPermGroup,8);
Symmetric and alternating groups
gap> s4:=SymmetricGroup(4);
gap> a4:=AlternatingGroup(4);
gap> Size(Elements(a4));
gap> l:=List(Elements(a4),x->Order(x));
gap> Set(l);
gap> Filtered(Elements(a4),x->Order(x)=3);
A group is simple if it has no nontrivial normal subgroups.
gap> IsSimple(a4);
Exercise: prove that a4 has a unique maximal normal subgroup
isomorphic to Z2xZ2
(Hint: N:= MaximalNormalSubgroups(a4)[1];)
gap> Size(Elements(a4));
Commutator Subgroup
If G and H are two groups
of elements in the same family, this
operation returns the group generated by all
commutators [ g, h ] =
g-1 h-1 g h
gap> CommutatorSubgroup(Group((1,2,3),(1,2)),Group((2,3,4),(3,4)));
Derived Subgroup.
Is the commutator of G with itself It is normal in G and the
factor group G/Der(G) is the largest abelian factor group of G.
A group is perfect if it equals its derived subgroup
gap> IsPerfect(a4);
Exercise: Prove that a4 is the derived subgroup of s4.
gap> A4:=DerivedSubgroup(s4);
a4 and A4 coincide
gap> Set(List(Elements(A4),x->SignPerm(x)));
It is not possible to find an explicit isomorphism as above
since the generators are not "compatible";
gap> hom:=GroupHomomorphismByImages(a4,A4,GeneratorsOfGroup(a4),GeneratorsOfGroup(A4));
NOTE: In general, to give a morphism of groups between two groups G and
G',
is enough to assign to each generator in a generating system of G its
image
in G' PROVIDED THAT ALL RELATIONS WHICH HOLDS AMONG THE GENERATORS
CONTINUE
TO HOLD THEIR ASSIGNED IMAGES
Cosets
CosetTable:=function(g,n)
local x,y,tmp;
tmp:=Flat(List(RightCosets(g,n),x->Elements(x)));
PrintArray(List(tmp,x->List(tmp,y->
Position(RightCosets(g,n),x*y*n))));
end;
Conjugate subgroups
gap> G:=SymmetricGroup(5);
gap> H:=Subgroup(G,[(1,2),((1,3)(2,4))]);
gap> IsNormal(G,H);
gap> ConjugateSubgroups(G,H);
Conjugacy Classes
gap> ccl:=ConjugacyClasses(s4);
Note that the classes are in bijective correspondence with Ferrer
Diagrams
gap> Elements(ccl[2]);
We want study the function which assign to each n the number of
conjugacy classes
of the symmetric group in n elements
gap> for n in [1..10] do
> Print(Size(ConjugacyClasses(SymmetricGroup(i))));
> Print("\n");
> od;
Exercise:
Study the dependence on n of the class with
the greatest number of elements
gap> for n in [1..10] do
> ccl:=ConjugacyClasses(SymmetricGroup(n));
> l:=List(ccl,x->Size(x));
> Print(Maximum(l));
> Print("\n");
> od;
In the next example we want to calculate a subgroup of
the alternating group over 8 elements, then its normalizer and finally
determine the structure of the extension.
gap> a8:=AlternatingGroup(8)
gap> el1:=(1,2)(3,4)(5,6)(7,8);
gap> el2:=(1,3)(2,4)(5,7)(6,8);
gap> el3:=(1,5)(2,6)(3,7)(4,8);
gap> elab:=Group(el1,el2,el3);
gap> Size(elab);
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;
The normalizer in a group of a given subgroup is the stabilizer of
that group under the conjugate action
i.e the set of elements in G such that Inverse(g)*H*g=H
gap> norm := Normalizer( a8, elab );; Size( norm );
Now that we have the subgroup norm of order 1344 and its subgroup elab,
we want to look at its factor (quotient) group, or better to the
short exact sequence
0->elab>->norm->>f->0
and in particular to the epimorphism hom and its image f
gap> hom := NaturalHomomorphismByNormalSubgroup( norm, elab );
gap> f := Image( hom );
gap> Size( f );
Note: the sequence means that the total space norm is fibred over
f and its fibres are cosets of elab.
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 );
gap> x := (1,8,3,5,7,6,2);; Image( hom, x );
gap> coset := PreImages( hom, last );
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> Elements(coset)[3]/Elements(coset)[5] in elab;
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 ); IsomorphismTypeInfoFiniteSimpleGroup( f );
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 L3(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 L3(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 L3(2).
gap> op := Action( norm, elab );
gap> IsSubgroup( a8, op ); IsSubgroup( norm, op );
gap> IsTrivial( Intersection( elab, op ) );
gap> SetName( norm, "2^3:L_3(2)" );
Exercises:
1. Given a 2-cycle (a,b) and a 3-cycle (c,d,e) in S(5),
when is S5 generated by the two given cycle?
Same when the second cycle is a 4-cycle.
Same when the second cycle is a 5-cycle
2. Guess the cardinality of a minimal set of generators for Symmetric
Group over n elements