4
$\begingroup$

I am trying to create the following group $G=(\operatorname{SL}_2(8) \times C_2 \times C_2) \rtimes C_3$ where the $C_3$ acts simultaneously:
on $\operatorname{SL_2(8)}$ as the outer automorphism of order $3$
on $C_2\times C_2$ as the automorphism that permutes the three nonidentity elements

I tried the following instructions:

 gap> C:=CyclicGroup(2);
 gap> C:=DirectProduct(C,C);
 gap> G:=DirectProduct(SL(2,8),C);
 gap> A:=AutomorphismGroup(G);
 gap> I:=InnerAutomorphismsAutomorphismGroup(A);
 gap> B:=A/I;
 gap> S:=SylowSubgroup(B,3);
 gap> SemidirectProduct(S,G);


But sadly it gives me an error. I assume it is because of the quotient, but I do not know how I could "find" the correct $C_3$ action in $A$ without removing the inner automorphisms first. Is there a way of doing such a thing?

Edit: I get this error after the last line

 Error, usage: Image(<map>), Image(<map>,<elm>), Image(<map>,<coll>) called from
 Image( aut, PreImagesRepresentative( epi, i ) ) at /proc/cygdrive/C/gap4r8/lib/grppclat.gi:88 called from
 func( C[i] ) at /proc/cygdrive/C/gap4r8/lib/coll.gi:746 called from
 List( GeneratorsOfGroup( f ), function ( i )
  return Image( epi, Image( aut, PreImagesRepresentative( epi, i ) ) );
   end ) at /proc/cygdrive/C/gap4r8/lib/grppclat.gi:88 called from
 InducedAutomorphism( niso, i ) at /proc/cygdrive/C/gap4r8/lib/gprd.gi:1094      called from
 SemidirectProduct( G, IdentityMapping( G ), N ) at /proc/cygdrive/C/gap4r8/lib/gprd.gi:1071 called from
 ...  at line 15 of *stdin*
 you can 'quit;' to quit to outer loop, or
 you can 'return;' to continue
$\endgroup$
  • $\begingroup$ Isn't the group $S$ you find too large anyway? It seems like it should have a copy of each of the actions you want independently, giving it order at least $9$. $\endgroup$ – Tobias Kildetoft Jan 31 '18 at 12:51
  • $\begingroup$ Yes it has order 18. I wanted to construct the semidirect product and then look for a subgroup $\endgroup$ – AnalysisStudent0414 Jan 31 '18 at 12:53
  • $\begingroup$ Right. So it seems like you will need to ask for all elements of order $3$ in the group of automorphisms and check which one does what you want. $\endgroup$ – Tobias Kildetoft Jan 31 '18 at 12:56
  • $\begingroup$ Okay but the "SemidirectProduct(S,G)" part gives me an error, which is why I stopped (I added it to the question now). $\endgroup$ – AnalysisStudent0414 Jan 31 '18 at 13:02
  • $\begingroup$ Right, I assume that once you take the quotient, GAP forgets that it has an action on the group, so it can no longer form a semidirect product. This is why I said you will probably need to look directly in the group of automorphisms. $\endgroup$ – Tobias Kildetoft Jan 31 '18 at 13:05
7
$\begingroup$

What you are providing is a perfectly good description of the product as far as a textbook is concerned. Alas, GAP is really picky in that objects are not just "somehow" as you describe, but very exact. E.g. an automorphism of $G$ is not automatically an automorphism of $G\times H$ or of $G/N$. Typically this requires to attach suitable homomorphisms (which often are called ``natural'' or similar terms in a textbook). So in your case, I would create SL$_2(8)$ and $C_2\times C_2$ first, construct the automorphisms there, form the direct product and the corresponding automorphisms and so on.

This gives the following construction (there are shortcuts, it is deliberately detailled and thus boring). One obvious way to make it perform faster would be to represent both C and L by permutation groups so that the whole calculation can stay in the category of permutation groups.

First create $C_\times C_2$ and find an element of order 3 in the automorphism group.

gap> C:=CyclicGroup(2);
<pc group of size 2 with 1 generators>
gap> C:=DirectProduct(C,C);
<pc group of size 4 with 2 generators>
gap> au:=AutomorphismGroup(C);
<group with 4 generators>
gap> Size(au);
6
gap> s:=SylowSubgroup(au,3);
gap> a1:=GeneratorsOfGroup(s)[1];
[ f1, f2 ] -> [ f1*f2, f1 ]

Then do the same with SL$_2(8)$. We want an outer automorphism and do a random search (one could take a pre-image under a natural homomorphism... but its messy enough as is)

gap> L:=SL(2,8);
SL(2,8)
gap> au:=AutomorphismGroup(L);
<group of size 1512 with 3 generators>
gap> inn:=InnerAutomorphismsAutomorphismGroup(au);
<group of size 504 with 2 generators>
gap> Size(au)/Size(inn);
3
gap> repeat r:=Random(au);until not r in inn and Order(r)=3;
gap> a2:=r;
CompositionMapping([... very messy]

Now we form the direct product and embedding and projection maps and constructs the automorphisms of this direct product induced by the two automorphisms by looking what they do to the generators of either direct factor (and trivial on the other factor)

gap> d:=DirectProduct(C,L);
<group of size 2016 with 4 generators>
gap> e1:=Embedding(d,1);;
gap> e2:=Embedding(d,2);;
gap> p1:=Projection(d,1);;
gap> p2:=Projection(d,2);;
gap> gen1:=GeneratorsOfGroup(Image(e1));
[ DirectProductElement( [ f1, [ [ Z(2)^0, 0*Z(2) ], [ 0*Z(2), Z(2)^0 ] ] ] ),
  DirectProductElement( [ f2, [ [ Z(2)^0, 0*Z(2) ], [ 0*Z(2), Z(2)^0 ] ] ] ) ]
gap> gen2:=GeneratorsOfGroup(Image(e2));;
gap> img1:=List(gen1,x->Image(e1,Image(a1,Image(p1,x))));
[ DirectProductElement( [ f1*f2, [ [ Z(2)^0, 0*Z(2) ], [ 0*Z(2),
    Z(2)^0 ] ] ] ), DirectProductElement( [ f1, [ [ Z(2)^0, 0*Z(2) ],
    [ 0*Z(2), Z(2)^0 ] ] ] ) ]
gap> au1:=GroupHomomorphismByImages(d,d,Concatenation(gen1,gen2),Concatenation(img1,gen2));
[ DirectProdu[... complicated]

gap> img2:=List(gen2,x->Image(e2,Image(a2,Image(p2,x))));;
gap> au2:=GroupHomomorphismByImages(d,d,Concatenation(gen1,gen2),Concatenation(gen1,img2));;
gap> Order(au1);
3
gap> Order(au2);
3

Both seem to be of right order. So now make a map from a new $C_3$ to the group generators by these two automorphisms that maps the generator to the product of the two automorphisms (as that is the action you want).

gap> z:=CyclicGroup(3);
gap> map:=GroupHomomorphismByImages(z,Group(au1,au2),[z.1],[au1*au2]);
[ f1 ] -> [...]

Finally we can form the semidirect product. GAP decided to represent it as a permutation group but it will have appropriate Embeddings and Projections that you can recover your original group.

gap> sdp:=SemidirectProduct(z,map,d);
<permutation group with 5 generators>
gap> Size(sdp);
6048

Uff! That was hard work. Now we know why the textbook is sloppy.

$\endgroup$
  • $\begingroup$ That was amazing, thank you so much. $\endgroup$ – AnalysisStudent0414 Feb 1 '18 at 12:54
  • $\begingroup$ @AnalysisStudent0414 Thank you for your kind comment. The trick is basically to explicitly include any homomorphism unless objects are clearly not just isomorphic but the same. (I've actually been pleasantly surprised that it all went through and we did not have to force different representations.) $\endgroup$ – ahulpke Feb 1 '18 at 15:17

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.