Construir un producto semidirecto en GAP

Question

Estoy tratando de crear el siguiente grupo de $G=(\operatorname{SL}_2(8) \times C_2 \times C_2) \rtimes C_3$ cuando la $C_3$ actúa simultáneamente:
en $\operatorname{SL_2(8)}$ como el exterior automorphism de orden $3$
en $C_2\times C_2$ como el automorphism que permutes los tres elementos nonidentity

He probado las siguientes instrucciones:

 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);

Pero, lamentablemente, me da un error. Supongo que es porque el cociente, pero no sé cómo podría "encontrar" la correcta $C_3$ acción en $A$ sin quitar el interior de automorfismos de primera. Es allí una manera de hacer tal cosa?

Edit: me sale este error después de la última línea

 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

Answer 1

Lo que están ofreciendo es una perfectamente buena descripción del producto, como mucho como un libro de texto de que se trate. Por desgracia, la BRECHA es realmente exigente en el que los objetos no son sólo "de alguna manera" tal como la describe, pero muy exacta. E. g. un automorphism de $G$ no es automáticamente un automorphism de $G\times H$ o de $G/N$. Normalmente, esto requiere adjuntar adecuado homomorphisms (que a menudo son llamados `naturales" o términos similares en un libro de texto). Así que en tu caso, me gustaría crear SL$_2(8)$ $C_2\times C_2$ en primer lugar, la construcción de los automorfismos de ahí, de forma directa el producto y el correspondiente automorfismos y así sucesivamente.

Esto le da la siguiente construcción (hay atajos, es deliberadamente detallada y por lo tanto aburrido). Una manera obvia de hacer que funcione más rápido sería representar tanto la C y la L por la permutación de grupos, de modo que todo el cálculo puede permanecer en la categoría de permutación de grupos.

Crear primero $C_\times C_2$ y encontrar un elemento de orden 3 en el automorphism grupo.

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 ]

Luego hacer lo mismo con SL$_2(8)$. Queremos un exterior automorphism y hacer una búsqueda al azar (uno podría tener una pre-imagen bajo un natural homomorphism... pero desordenado suficiente como es)

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]

Ahora formamos el producto directo y la incrustación y la proyección de mapas y construcciones de los automorfismos de este producto directo inducida por los dos automorfismos mirando lo que hacen los generadores de factor directo (y trivial en el otro 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

Ambos parecen ser de orden correcto. Así que ahora hacer un mapa de una nueva $C_3$ para el grupo de los generadores por estos dos automorfismos que se asigna el generador para el producto de los dos automorfismos (como que es la acción que usted desea).

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

Finalmente podemos formar la semidirect producto. GAP decidió representar como una permutación de grupo pero se han apropiado Embeddings y Projections de que puede recuperar su grupo original.

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

Uff! Que era el trabajo duro. Ahora sabemos por qué el libro de texto es descuidado.