## Cape Coast, Ghana - August 2003

WASS: Lecture 1.
Enrico ROGORA
Version 0.2, 21th August 2003

Consider a cube and enumerate its vertices {1,2,3,4,5,6,7,8}
(Front face, clockwise, starting  upper left, 1,2,3,4;
Back face, clockwise, starting upper left, {5,6,7,8} .
We consider the set of orthogonal tranformations about its center.
To each of them we can associate a permutation of the set of vertices.
For example
rx: a 90 degree clockwise rotation about
the axes from the front face to the back face through its center
can be described by the permutation (1,2,3,4)(5,6,7,8)
ry: a 90 degree clockwise rotation about
the  axes from the left face to the right face  through its center
can be described by the permutation (1,4,8,5)(2,3,7,6)
rz: a 90 degree clockwise rotation about
the  axes from the upper face to the lower face  through its center
can be described by the permutation (1,5,6,2)(4,8,7,3)

Define the three permutations with GAP
`gap> rx:=(1,2,3,4)(5,6,7,8);`
`gap> ry:=(1,4,8,5)(2,3,7,6); `
`gap> rz:=(1,5,6,2)(4,8,7,3);`

We first consider the groups generated by the three rotations
`gap> Gx:=Group(rx);`
`gap> Gy:=Group(ry);`
`gap> Gz:=Group(rz);`

Of course these are three cyclic groups

`gap>  IsCyclic(Gx);`

Hence abelian

`gap>  IsAbelian(Gx);`

How many elements does Gx have?

`gap>  Size(Gx);`

This is the same as the order of its generator

`gap> Order(rx);`

We can take the union of these three groups and the group generated by
rx, ry, rz.

`gap> GG:=Union(Gx,Gy,Gz); `
`gap> G:=Group(rx,ry,rz);`

G is strictly bigger than GG. In fact the latter
contains only element which are power of generators
but not elements like rx*ry as we can check with the
following commands

`gap> rx*ry in GG;`
`gap> rx*ry in GG;`

We now address ourselves the following problem.
Given an element of G how can we explicitely express it as a word in
the generators of G?

First, to look at all elements of G, we can use

`gap> ele:=Elements(G);`

This returns a list. To extract its eighth, say,
just do

`gap> e:=ele;`

If we want to express this element, say, as a word in the given generators
we can first build the free group on three letters

`gap> F:=FreeGroup("x","y","z");`

Then we define the homomorphism which sends the generators of F
into the generators of G

`gap> hom:=GroupHomomorphismByImagesNC(F,G,GeneratorsOfGroup(F),GeneratorsOfGroup(G));`

and find an element of F which is sent to it by the
morphism hom

`gap> q:=PreImagesRepresentative(hom, e);`

The last step is simply to translate
x into rx, y into ry and z into rz in
this last element q and we get a representation (of course not unique)
of e as aword in the generators. For example, if
q=x*y, then p=rx*ry.

`gap> (1,5)(2,6)(3,7)(4,8) in G; `

`gap> Size(Group(rx,ry,rz,(1,5)(2,6)(3,7)(4,8)));`

It is not hard to prove that G exausts all the simmetries of the cube which
are rotations. There are also reflections. If we want add them all it is sufficient
to add one to the generators, for example  (1,5)(2,6)(3,7)(4,8)

What we have done so far is to "represent" the group
of rotation of the cube as a group of permutations, i.e. a
subgroup of the symmetric group with eight elements.
It is possible to choose a different representation of
this same group as a group of simmetries in less elements.
It is enough, for example to consider the action induced over
the 6 faces of the cube, which we can enumerate like this.

Front          1
Back          6
Right          3
Left          4
Bottom      5
Upper          2

In terms of this new representation we get,

`gap>  Rx:=(2,3,5,4);`
`gap>  Ry:=(1,2,6,5);`
`gap>  Rz:=(1,3,6,4);`

The group generated by these element is now a subgroup of the group
of simmetries over six elements.

`gap> G2:=Group(Rx,Ry,Rz);`

For checking with gap that the two groups are indeed isomorphic
we first build an homomorphism betwwen them that sends the generators
rx, ry, rz into Rx, Ry, Rz
and then we check that is isomorphism is injective and surjective.
This is done with the following commanda

`gap> hom:=GroupHomomorphismByImagesNC(G,G2,GeneratorsOfGroup(G),GeneratorsOfGroup(G2));`
`gap> Kernel(hom);`
`gap> Image(hom);`

The Kernel is only the identity and the image coincides with G2