Een "mini-tutorial" voor GAP 4.3,
deel 1, berekeningen aan de subgroep G van de S₆ voortgebracht door
de twee 4-cykels a=(1,2,3,4) en b=(3,4,5,6)

Inleiding

gap> G:=Group((1,2,3,4)(3,4,5,6));
Permutation: cycles must be disjoint and duplicate-free
We zijn per ongeluk de komma tussen de twee 4-cykels vergeten. Kennelijk accepteert GAP alleen permutaties in disjuncte cykelsplitsing! Met behulp van de verticale pijltoetsen kunnen we reeds ingevoerde opdrachten weer opnieuw laten weergeven en desgewenst wijzigen. Onze fout is dus snel te herstellen. Maar, we kiezen voor een schone lei:

gap> quit
Doordat we de punt-komma vergeten zijn wordt de opdracht maar half uitgevoerd. Er verschijnt een z.g. halve prompt. We kunnen nu alsnog de punt-komma invoeren:
>;
en het GAP-scherm verdwijnt. We starten GAP opnieuw:

gap> a:=(1,2,3,4);; b:=(3,4,5,6);; G:=Group(a,b);
Group([ (1,2,3,4),(3,4,5,6) ])
Onze groep G wordt voortgebracht door een lijst van twee 4-cykels.
gap> b*a;
(1,2,3)(4,5,6)
Hieraan zien we dat de groepsbewerking * als "voor" uitgesproken moet worden. De permutaties (bijecties) werken van rechts op de elementen (uit {1,2,3,4,5,6}). Dus b*a= a "na" b in de zin van klassieke compositie van functies (die van links werken). We bepalen nu eerst het aantal elementen ofwel de orde ("Size", dus geen "Order") van onze groep G.
gap> Size(G);
120
De orde van G is 120=5!. [Daar (1,2,3)(4,5,6) orde 3 heeft en 3 de hoogste macht van 3 is, die een deler van 120 is, volgt direct (uit een Sylow-stelling, waar we later op terug komen), dat alle elementen van de orde 3 in G dezelfde cykelstructuur hebben (en dus geen 3-cykels zijn)]

Notaties: We herinneren aan het feit dat een groep G van rechts op zichzelf werkt door conjugatie. Preciezer: De afbeelding g --> W_g is een homomorfisme van G in de automorfismegroep (Aut(G),*) van G, als x W_g=g^-1*x*g [=g"na"x"na"g^-1, in klassieke zin]. GAP gebruikt de traditionele notatie x^g voor x W_g. Daarom wordt {x^g | g in G}, de conjugatieklasse van x in G, door GAP in zijn uitvoer afgekort weer gegeven door x^G. Merk op dat nu (c d)^g = c^g * d^g en x^(g * h) = (x^g)^h, maar vergeet niet, dat ^ ook nog voor het gewone machtsverheffen gebruikt wordt. Meer nog, GAP gebruikt dit symbool ook, maar dan als onder-index, in zijn uitvoer om de plaats van een vermoedelijke fout aan te geven.
gap> a^b;b^a;
(1,2,4,5)
(1,5,6,4)
Deze berekening kunt u natuurlijk uit het hoofd controleren door toepassing van het "Principe van naamverandering" .Toegepast op een cykel (1,2,3,...,n) geeft het g^-1*(1,2,...,n)*g = (g(1),g(2),...,g(n)).
gap> Sy1:=SylowSubgroup(G,3);
Group([ (1,6,2)(3,5,4)) ])
Hier zien we (nog eens) dat een Sylow 3-subgroep van G, d.w.z. een subgroep met als orde de maximale macht van 3 (hier 3¹=3) die in de orde |G| van G (hier 120) opgaat, voortgebracht wordt door een product van twee 3-cykels. Maar volgens een van de Sylow-stellingen zijn alle Sylow p-subgroepen (voor elke vaste priemdeler p van |G|) onderling geconjugeerd. Hun voortbrengers hebben dus in het bijzonder dezelfde cykelstructuur. De enige elementen van de orde 3 in G zijn dus, zoals gezegd, producten van twee 3-cykels. We analyseren verder.
gap> Normalizer(G,Sy1); Size(Normalizer(G,Sy1));
Group([ (1,6,2)(3,5,4), (2,6)(3,4), (1,3,6,5,2,4) ])
12
De normalisator N_G(H) van een ondergroep H van G in G is de maximale subgroep van G waarin H normaal is. In concreto: N_G(H) = {g in G | h^g in H voor alle h in H}. Een andere Sylow-stelling leert dat, met K een Sylow p-subgroep, het aantal Sylow p-subgroepen van G gelijk is aan de index [G:N_G(K)] en dit is op zijn beurt gelijk aan |G|/|N_G(K)|, volgens Lagrange. Bovendien is dit aantal altijd congruent 1 modulo p. In ons geval zijn er dus 120/12=10 Sylow 3-subgroepen en daarmee in totaal 20 producten van twee 3-cykels in G. Dit laatste kunnen we ook zien aan de centralisator C_G(Sy1)van Sy1 in G. Dit is de ondergroep van de normalisator van Sy1 in G bestaande uit die elementen van G, die Sy1 zelfs puntsgewijs vast laten. Er geldt immers algemeen, dat het aantal geconjugeerden van een element x in G gelijk is aan |G|/|C_G(V)|, met V de door x voortgebrachte cyclische subgroep van G. Hier heeft (1,6,2)(3,5,4) dus 120/6=20 geconjugeerden.
gap> Centralizer(G,Sy1);
Group([ (1,2,6)(3,4,5), (1,3,6,5,2,4) ])
gap> Centralizer(G,Sy1)=Group([ (1,3,6,5,2,4) ]);
true

Stel nu dat we later (bij voorbeeld na wat foutmeldingen) nog eens een Sylow 3-subgroep opvragen. Dan kan onze berekening er, in eerste instantie, best anders uitzien.
gap> Sy2:=SylowSubgroup(G,3);
Group([ (1,5,6)(2,3,4) ])
gap> Normalizer(G,Sy2);
Group([ (1,5,6)(2,3,4), (2,4)(5,6), (1,2)(3,6)(4,5) ])
gap> Size(Normalizer(G,Sy2));
12
gap> Centralizer(G,Sy2);
Group([ (1,2,5,3,6,4) ])
Een specifiek element in de normalisator, maar niet in de centralisator, is bij voorbeeld (2,4)(5,6). Conjugatie hiermee voert (1,5,6)(2,3,4) in zijn inverse over.
gap> ((1,5,6)(2,3,4))^((2,4)(5,6));
(1,6,5)(2,4,3)
Vervolgens bepalen we de (relevante) conjugatieklassen direct.
gap> ccG:=ConjugacyClasses(G);
[ ()^G, (3,4,5,6)^G, (3,5)(4,6)^G, (2,3,4,6,5)^G, (1,2)(3,4)(5,6)^G, (1,2,3)(4,5,6)^G, (1,2,3,5,4,6)^G ])
Dit is een lijst van conjugatieklassen van G, maar de klassen zijn slechts "afgekort", door middel van representanten, weergegeven. Op zo'n lijst kunnen we een aantal bewerkingen uitvoeren, net zo als Maple dat doet met behulp van de operator "map". In het vervolg zien we dat "Order" gereserveerd is voor de orde van elementen van een groep en dat er inderdaad 20 elementen in de conjugatieklasse van (1,2,3)(4,5,6) liggen.
gap> List(ccG,c->Order(Representative(c)));
[ 1, 4, 2, 5, 2, 3, 6 ]
gap> List(ccG,c->Size(c));
[ 1, 30, 15, 24, 10, 20, 20 ]
Dit kan iets korter:
gap> List(ccG,Size);
[ 1, 30, 15, 24, 10, 20, 20 ]
gap> clG33:=First(ccG,c->Size(c)=20);
(1,2,3)(4,5,6)^G
Als voorbereiding op deel 2 van onze mini-tutorial bepalen we vast de 10 in G aanwezige producten van drie disjuncte 2-cykels. Met de opdracht "Set" wordt een lijst omgezet in een verzameling. In GAP is dit een gesorteerde lijst, zonder "dubbele".
gap> clG222:=ccG[5];
(1,2)(3,4)(5,6)^G
gap> AsList(clG222);
[ (1,2)(3,4)(5,6), (1,2)(3,6)(4,5), (1,3)(2,5)(4,6), (1,3)(2,6)(4,5), (1,4)(2,6)(3,5), (1,4)(2,3)(5,6), (1,5)(2,3)(4,6), (1,5)(2,4)(3,6), (1,6)(2,4)(3,5), (1,6)(2,5)(3,4) ]
gap> Set(AsList(clG222));
[ (1,2)(3,4)(5,6), (1,2)(3,6)(4,5), (1,3)(2,5)(4,6), (1,3)(2,6)(4,5), (1,4)(2,3)(5,6), (1,4)(2,6)(3,5), (1,5)(2,3)(4,6), (1,5)(2,4)(3,6), (1,6)(2,4)(3,5), (1,6)(2,5)(3,4) ]
Bij het lexicografisch sorteren is nu (1,4)(2,3)(5,6) voor (1,4)(2,6)(3,5) gezet. Tenslotte controleren we nog eens dat de voortbrengers van Sy2 en Sy1, d.w.z. (1,5,6)(2,3,4) en (1,2,3)(4,5,6), inderdaad geconjugeerd zijn.
gap> AsList(ccG[6]);; (1,5,6)(2,3,4) in Set(AsList(ccG[6]));
true
Het listen van de volledige conjugatieklasse hebben we onderdrukt. In plaats daarvan hebben we de operator "in" gebruikt [die staat voor "element van"].