• A Matrix Group is a group where the elements are matrices, and the group operation is matrix multiplication.

• To create a Matrix Group in GAP, you use the function Group function, providing the list of generating matrices.

gap> m1 := [[1, 1], [0, 1]];
[ [ 1, 1 ], [ 0, 1 ] ]
gap> m2 := [[1, 0], [1, 1]];
[ [ 1, 0 ], [ 1, 1 ] ]
gap> G := Group(m1, m2);
Group([ [ [ 1, 1 ], [ 0, 1 ] ], [ [ 1, 0 ], [ 1, 1 ] ] ])

• Note that the function Group can construct infinite groups.
• In our example

gap> Order(m1);
infinity

• And clearly

gap> Order(G);
infinity

• Caution! Not always we will be able to determine whether an element has
  finite order or not!

General linear group and Special linear group

• The General Linear Group, denoted by , is the group of all invertible matrices of a given size, with matrix multiplication as the group operation.
  • In GAP,use the command GL(n, F), where n is the dimension of the matrices and F is the underlying field.
• The Special Linear Group, denoted by , is the subgroup of consisting of matrices with determinant .
  • In GAP, this is defined by SL(n, F).

gap> GL2 := GeneralLinearGroup(2, GF(3));
GL(2, GF(3))
gap> SL2 := SpecialLinearGroup(2, GF(3));
SL(2, GF(3))

• Here the command GF(3) defines the finite field with three elements.

Aside: Finite fields

• For every prime and every positive integer there is one and only one field (up to isomorphism) of order .
  • In GAP this field is denoted by GF(p^n).
• Recall that the set of nonzero elements in GF(p^n) form a cyclic group of order under multiplication.
  • In GAP a generator of this cyclic group is denoted by Z(p^n)
  • The remaining elements of are expressed in terms of Z(p^m) for a divisor of .
  • In GAP the function Z returns a generator of the multiplicative group of the finite field with elements.

• Let's define in GAP.

gap> F := GF(2^4);
GF(2^4)
gap> Elements(F);
[ 0*Z(2), Z(2)^0, Z(2^2), Z(2^2)^2, Z(2^4), Z(2^4)^2, Z(2^4)^3, Z(2^4)^4,
  Z(2^4)^6, Z(2^4)^7, Z(2^4)^8, Z(2^4)^9, Z(2^4)^11, Z(2^4)^12, Z(2^4)^13,
  Z(2^4)^14 ]

• Careful! Z(p^n)^m is not the same as Z(p^(mn)).
  • Z(p^n) is an element in of multiplicative order .
  • Z(p^n)^m is the th power of this element.
  • Z(p^(mn)) is a generator of so of multiplicative order .

gap> Order(Z(2^4));
15
gap> Order(Z(2^2)^2);
3

• Let's try to understand GAP's notation focusing on .
  • Assume the multiplicative group of nonzero elements si generated by (in GAP's notation is Z(2^4)).
  • So .
  • has one and only one subfield of order with dividing .
    • Order → .
    • Order →
  • In GAP, is Z(2^4)^5 = Z(2^2) and Z(2^4)^10 = Z(2^2)^2.

gap> Z(2^4)^5;
Z(2^2)
gap> Z(2^4)^10;
Z(2^2)^2

How to find all subgroups of a group?

• GAP also provides the function AllSubgroups to list all subgroups of a group.

gap> GL2 := GeneralLinearGroup(2, GF(3));
GL(2, GF(3))
gap> Order(GL2);
48
gap> Size(AllSubgroups(GL2));
55

• However, AllSubgroups can become inefficient for large groups.
• In the example, AllSubgroups would give us a list of subgroups.

• The concept of conjugacy classes of subgroups can be useful to work with subgroups in GAP.
• Recall that two subgroups and are conjugate in if , for some .
• In GAP, we use the function ConjugacyClassesSubgroups.

gap> GL2 := GeneralLinearGroup(2, GF(3));
GL(2, GF(3))
gap> Size(ConjugacyClassesSubgroups(GL2));
16

• We can select a specific conjugacy class from the list to explore it.

gap> c := cc[3];
Group([ [ [ Z(3), 0*Z(3) ], [ 0*Z(3), Z(3)^0 ] ] ])^G
gap> Size(c);
12
gap> Representative(c);
Group([ [ [ Z(3), 0*Z(3) ], [ 0*Z(3), Z(3)^0 ] ] ])
gap> AsList(c);
[ Group([ [ [ 0*Z(3), Z(3)^0 ], [ Z(3)^0, 0*Z(3) ] ] ]),
  Group([ [ [ 0*Z(3), Z(3) ], [ Z(3), 0*Z(3) ] ] ]),
  Group([ [ [ Z(3)^0, 0*Z(3) ], [ 0*Z(3), Z(3) ] ] ]),
  Group([ [ [ Z(3)^0, 0*Z(3) ], [ Z(3)^0, Z(3) ] ] ]),
  Group([ [ [ Z(3)^0, 0*Z(3) ], [ Z(3), Z(3) ] ] ]),
  Group([ [ [ Z(3)^0, Z(3)^0 ], [ 0*Z(3), Z(3) ] ] ]),
  Group([ [ [ Z(3)^0, Z(3) ], [ 0*Z(3), Z(3) ] ] ]),
  Group([ [ [ Z(3), 0*Z(3) ], [ 0*Z(3), Z(3)^0 ] ] ]),
  Group([ [ [ Z(3), 0*Z(3) ], [ Z(3)^0, Z(3)^0 ] ] ]),
  Group([ [ [ Z(3), 0*Z(3) ], [ Z(3), Z(3)^0 ] ] ]),
  Group([ [ [ Z(3), Z(3)^0 ], [ 0*Z(3), Z(3)^0 ] ] ]),
  Group([ [ [ Z(3), Z(3) ], [ 0*Z(3), Z(3)^0 ] ] ]) ]

• In the example,
  • We select the third element in the list of conjugacy classes of subgroups, c := cc[3];.
  • Size(c) tells us how many elements are in the class c.
  • With Representative function, we obtain a representative of this conjugacy class.
  • With AsList we list all the subgroups in this conjugacy class.

Group actions

• A group action is a triple , where is a group, a set and a function that is compatible with the group.
• Caution! In GAP, groups always act from the right! I.e. .
• Now we explore group actions in different situations.
• Let's explore acting by right multiplication on the set of right cosets of on .

gap> S3 := SymmetricGroup(3);;
gap> A3 := AlternatingGroup(3);;
gap> omega := RightCosets(S3, A3);
[ RightCoset(Alt( [ 1 .. 3 ] ),()), RightCoset(Alt( [ 1 .. 3 ] ),(2,3)) ]
gap> OrbitsDomain(S3, omega, OnRight);
[ [ RightCoset(Alt( [ 1 .. 3 ] ),()), RightCoset(Alt( [ 1 .. 3 ] ),(2,3)) ] ]
gap> IsTransitive(S3, omega, OnRight);
true

• Let's study the natural action of the dihedral group of order eight on the vertex set of the square.

gap> D8 := DihedralGroup(IsPermGroup, 8);;
gap> GeneratorsOfGroup(D8);
[ (1,2,3,4), (2,4) ]
gap> IsTransitive(D8, [1..4]);
true

• We can compute the stabiliser of the vertex .

gap> Stabilizer(D8, 1);
Group([ (2,4) ])

• We can use the function Filtered to find the elements of that act trivially, also called core of the action.

gap> Filtered(D8, g->ForAll([1..4], x -> x^g = x));
[ () ]

• So the action is faithful, i.e. the only element acting trivially is the identity.

• Let's now consider acting on , where .
• We study the natural action (by right multiplication) of on :

gap> G := GL(2, 5);; # Here GL(2, 5) is the same as GL(2, GF(5))
gap> omega := AsList(GF(5)^2);;
gap> v := Random(omega);
[ Z(5), Z(5)^0 ]
gap> Orbit(G, v);
[ [ Z(5), Z(5)^0 ], [ Z(5)^2, Z(5)^0 ], [ Z(5), Z(5) ], [ Z(5)^3, Z(5)^0 ],
  [ 0*Z(5), Z(5)^2 ], [ Z(5)^2, Z(5) ], [ Z(5)^0, Z(5) ], [ Z(5)^0, Z(5)^0 ],
  [ Z(5)^0, Z(5)^3 ], [ Z(5)^0, 0*Z(5) ], [ Z(5)^3, Z(5) ],
  [ Z(5)^2, Z(5)^2 ], [ Z(5), Z(5)^3 ], [ Z(5), 0*Z(5) ], [ 0*Z(5), Z(5)^3 ],
  [ Z(5)^3, Z(5)^2 ], [ Z(5), Z(5)^2 ], [ Z(5)^2, Z(5)^3 ], [ 0*Z(5), Z(5) ],
  [ Z(5)^2, 0*Z(5) ], [ Z(5)^0, Z(5)^2 ], [ Z(5)^3, Z(5)^3 ],
  [ Z(5)^3, 0*Z(5) ], [ 0*Z(5), Z(5)^0 ] ]
gap> Stabilizer(G, v);
Group([ [ [ Z(5)^0, Z(5) ], [ 0*Z(5), Z(5) ] ],
  [ [ Z(5)^2, Z(5)^0 ], [ Z(5)^2, Z(5)^2 ] ] ])
gap> StructureDescription(last);
"C5 : C4"

• We can use the function Action to obtain the image of the group homomorphism induced by the action.

gap> Action(G, GF(5)^2, OnPoints);
Group([ (6,11,16,21)(7,12,17,22)(8,13,18,23)(9,14,19,24)(10,15,20,25),
  (2,16,9)(3,21,15)(4,6,17)(5,11,23)(7,22,10)(8,12,13)(14,18,19)(20,24,25) ])

• One can use the function ActionHomomorphism to construct the natural homo-
  morphism induced by the action.

gap> f := ActionHomomorphism(G, GF(5)^2, OnPoints);
<action homomorphism>
gap> Image(f) = Action(G, GF(5)^2, OnPoints);
true

Homomorphisms

• The function GroupHomomorphismByImages returns the group homomorphism constructed by specifying the values of the map on a given set of generators.
• If such homomorphism doesn't exist, then the function returns fail.
• Properties of group homomorphisms can be studied with
  • Image,
  • IsInjective,
  • IsSurjective,
  • Kernel,
  • PreImage.

• Let's consider the map , that maps every transposition of to .
• This map extends to a homomorphism from to .
• Let's implement it in GAP.

gap> S4 := SymmetricGroup(4);;
gap> S3 := SymmetricGroup(3);;
gap> f := GroupHomomorphismByImages(S4, S3,\
> [(1,2),(1,3),(1,4),(2,3),(2,4),(3,4)],\
> [(1,2),(1,2),(1,2),(1,2),(1,2),(1,2)]);
[ (1,2), (1,3), (1,4), (2,3), (2,4), (3,4) ] ->
[ (1,2), (1,2), (1,2), (1,2), (1,2), (1,2) ]

• Now we can explore this homomorphism.
• Let's compute the size of the kernel.

gap> Size(Kernel(f));
12

• So we expect the homomorphism to be non-injective

gap> IsInjective(f);
false

• Let's compute the size of the image.

gap> Size(Image(f));
2

• So we expect the homomorphism to be non-surjective.

gap> IsSurjective(f);
false

• We can use the operator ^ to compute the image of a particular element.

gap> (1,3)^f;
(1,2)
gap> (1,2,3)^f;
()

• a normal subgroup of .
• The canonical homomorphism can obtained in GAP with the function NaturalHomomorphismByNormalSubgroup.

gap> C12 := CyclicGroup(IsPermGroup, 12);
Group([ (1,2,3,4,5,6,7,8,9,10,11,12) ])
gap> g := GeneratorsOfGroup(C12)[1];
(1,2,3,4,5,6,7,8,9,10,11,12)
gap> N := Subgroup(C12, [g^6]);;
gap> f := NaturalHomomorphismByNormalSubgroup(C12, N);
[ (1,2,3,4,5,6,7,8,9,10,11,12) ] -> [ f1 ]

• The function GeneratorsOfGroup returns a list of generators.

• The function GQuotients allows us to determine whether a given group is an epimorphic image of another one.
• For example is an epimorphic image of .

gap> S3 := SymmetricGroup(3);;
gap> S4 := SymmetricGroup(4);
Sym( [ 1 .. 4 ] )
gap> GQuotients(S4, S3);
[ [ (3,4), (1,2,3) ] -> [ (2,3), (1,2,3) ] ]

• GQuotients computes all epimorphisms from S4 onto S3.
• This classifies all factor groups of S4 which are isomorphic to S3.

• In fact, if is isomorphic to where .

gap> f := GQuotients(S4, S3)[1];
[ (2,3), (1,2,4) ] -> [ (2,3), (1,2,3) ]
gap> N := Kernel(f);
Group([ (1,4)(2,3), (1,2)(3,4) ])
gap> Elements(N);
[ (), (1,2)(3,4), (1,3)(2,4), (1,4)(2,3) ]
gap> S4/N = S3;
false
gap> IsomorphismGroups(S4/N, S3);
[ f1, f2 ] -> [ (2,3), (1,2,3) ]

• Note that = failed in recognise that, as abstract group, the two groups are the same.

The automorphism group

• The function AutomorphismGroup computes the automorphism group of a finite group, i.e. the group of all isomorphisms of the group to itself.
• The automorphisms of a group of the form , where , are the inner automorphisms of .
• The function IsInnerAutomorphism checks whether a given automorphism is inner.
• Let's explore the automorphism group of .

gap> aut := AutomorphismGroup(S3);
<group of size 6 with 2 generators>
gap> IsAbelian(aut);
false

• Now let's write a code to check that for every automorphism of is inner.

gap> for n in [2..5] do
>    G := SymmetricGroup(n);;
>    if ForAll(AutomorphismGroup(G), IsInnerAutomorphism) then
>       Print("Each automorphism of S", n, " is inner.\n");
>    fi;
> od;
Each automorphism of S2 is inner.
Each automorphism of S3 is inner.
Each automorphism of S4 is inner.
Each automorphism of S5 is inner.

• It is known that there are automorphism of that are not inner.
• Let's use GAP to find one.

gap> S6 := SymmetricGroup(6);;
gap> f := First(AutomorphismGroup(S6), x -> not IsInnerAutomorphism(x));
[ (1,2)(3,5)(4,6), (1,2,3,4,5) ] -> [ (5,6), (1,2,3,4,5) ]

• Here the function First returns the first occurrence in the list satisfying the condition.
• The automorphism that maps and is not inner.

• We use InnerAutomorphismGroup to construct the inner automorphism of a given group.

gap> S6 := SymmetricGroup(6);;
gap> aut := AutomorphismGroup(S6);;
gap> inn := InnerAutomorphismGroup(S6);:

• Let's check that aut/inn is the cyclic group with two elements.

gap> Size(aut/inn);
2

• The following conjecture, proposed by Schreier in 1926.

• This is now known to be true as a result of the classification of finite simple groups.

• Let's use GAP to test the conjecture for some simple groups.

• First we write a function to compute the outer automorphism group:

gap> OuterAutomorphismGroup := function(g)
>    return AutomorphismGroup(g)/InnerAutomorphismGroup(g);
> end;
function( g ) ... end

• We note that in the conjecture the assumption of being simple is needed.

gap> G := ElementaryAbelianGroup(25); #  It's C_5 x C_5, clearly not simple
gap> IsSolvable(OuterAutomorphismGroup(G));
false

• Now we write a function to test Schreier conjecture on simple groups.

gap> SchreierConjecture := function(g)
>    if not IsSimple(g) then
>       return fail;
>    else
>       return IsSolvable(OuterAutomorphismGroup(g));
>    fi;
> end;
function( g ) ... end

• Now let's check the conjecture for the alternating group .

gap> SchreierConjecture(AlternatingGroup(5));
true

• If we try with the elementary abelian group of order , the function returns fail.

gap> SchreierConjecture(ElementaryAbelianGroup(25));
fail

• AllHomomorphisms constructs the set of all group homomorphisms from a group to another.
• AllEndomorphisms constructs the set of endomorphism of a group.
• Let's compute the number of endomorphism of .

gap> S3 := SymmetricGroup(3);;
gap> Size(AllEndomorphisms(S3));
10

Direct product of groups

• Given two groups and the direct product is the group defined on the cartesian product with multiplication defined component-wise:

• In GAP we use DirectProduct to define the direct product.

gap> S3 := SymmetricGroup(3);;
gap> D8 := DihedralGroup(8);;
gap> S3xD8 := DirectProduct(S3, D8);
<group of size 48 with 5 generators>

• Embedding gives the canonical embedding.
• We can check for instance that it is injective but not surjective.

gap> i_S3 := Embedding(S3xD8, 1);
MappingByFunction( Sym( [ 1 .. 3 ] ), <group of size 48 with
5 generators>, function( elm ) ... end )
gap> IsInjective(i_S3);
true
gap> IsSurjective(i_S3);
false

• Projection gives the canonical projection.
• We can check that it is surjective but not injective.

gap> p_D8 := Projection(S3xD8, 2);
MappingByFunction( <group of size 48 with 5 generators>, <pc group of size
8 with 3 generators>, function( elm ) ... end )
gap> IsSurjective(p_D8);
true
gap> IsInjective(p_D8);
false
gap> Image(i_S3) = Kernel(p_D8);
true

• Let's use the direct product to construct two groups that have all elements of the same order but are not isomorphic.

gap> C4 := CyclicGroup(IsPermGroup, 4);;
gap> C2 := CyclicGroup(IsPermGroup, 2);;
gap> Q8 := QuaternionGroup(8);;
gap> C4xC4 := DirectProduct(C4, C4);;
gap> C2xQ8 := DirectProduct(C2, Q8);;
gap> Collected(List(C4xC4, Order));
[ [ 1, 1 ], [ 2, 3 ], [ 4, 12 ] ]
gap> Collected(List(C2xQ8, Order));
[ [ 1, 1 ], [ 2, 3 ], [ 4, 12 ] ]

• Here Q8 is the Quaternion Group. It is a non-abelian group of order , isomorphic to the set of units of quaternions under multiplication.

• The two groups we constructed are not isomorphic since one is abelian and the other one is not.

gap> IsAbelian(C4xC4);
true
gap> IsAbelian(C2xQ8);
false

Semidirect product of groups

• Given two groups and and a group homomorphism , we can construct a new group , called the semidirect product of and with respect to , defined on the cartesian product as follows:

• SemidirectProduct(H, phi, G) allows us to construct the semidirect product .

• Consider the cyclic group of order and the cyclic group of order .
• Let's construct the semidirect product , where , .

gap> C7 := CyclicGroup(7);;
gap> C2 := CyclicGroup(2);;
gap> f := GroupHomomorphismByFunction(C7, C7, x->Inverse(x));;
gap> f in AutomorphismGroup(C7);
true
gap> Order(f);
2
gap> g := GeneratorsOfGroup(C2)[1];;
gap> phi := GroupHomomorphismByImages(C2, AutomorphismGroup(C7), [g], [f]);;
gap> G := SemidirectProduct(C2, phi, C7);;

• Now we can check that is indeed isomorphic to the dihedral group .

gap> IsomorphismGroups(G, DihedralGroup(14));
[ f1, f2 ] -> [ f1, f2 ]
gap> StructureDescription(G);
"D14"

• We can still use Embedding and Projection for the canonical maps

gap> i_C2 := Embedding(G, 1);;
gap> StructureDescription(Image(i_C2));
"C2"
gap> p := Projection(G);;
gap> StructureDescription(Image(p));
"C2"

• Let's conclude constructing all possible semidirect products (up to isomorphism) of and .

gap> C2 := CyclicGroup(2);;
gap> C4xC4 := DirectProduct(CyclicGroup(4), CyclicGroup(4));;
gap> hom := AllHomomorphisms(C2, AutomorphismGroup(C4xC4));;
gap> list := [];;
gap> for phi in hom do
> Add(list, SemidirectProduct(C2, phi, C4xC4));
> od;
gap> Size(list);
28
gap> Set(list, IdSmallGroup);
[ [ 32, 11 ], [ 32, 21 ], [ 32, 24 ], [ 32, 25 ], [ 32, 31 ], [ 32, 33 ],
  [ 32, 34 ] ]

Key Commands (1)

• Group(mat1, mat2, ...) - Create matrix group.
• GL(n, F) - General Linear Group.
• SL(n, F) - Special Linear Group.
• GF(p^n) - Finite field.
• Order(el) - Order of element.
• GeneratorsOfGroup(G) - Group generators.
• AllSubgroups(G) - All subgroups
• ConjugacyClassesSubgroups(G) - Conjugacy classes of subgroups.
• Representative(c) - Representative of a conjugacy class.
• AsList(c) - List elements of conjugacy class.

Key Commands (2)

• Orbit(G, x) - Orbit under action.
• IsTransitive(G, omega) - Is transitive?
• Action(G, Omega, OnPoints) - Action group.
• ActionHomomorphism(G, Omega, OnPoints) - Action homomorphism.
• GroupHomomorphismByImages(G, H, gensG, images) - Define homomorphism
• Image(f) - Image
• Kernel(f) - Kernel
• IsInjective(f) - Is injective?
• IsSurjective(f) - Is surjective?
• AutomorphismGroup(G) - Automorphism group.

Thanks!