Integrarse como un subgrupo

Question

Supongamos que tengo dos grupos finitos $G$ $H$ (no demasiado grande: digamos que sus pedidos son alrededor de $10000$ $100$ respectivamente, y la orden de $H$ divide el orden de $G$). Estos pueden ser representados como grupos de permutaciones con conocidos, bastante pequeña, conjuntos de generadores. Me gustaría saber, si es posible, un subgrupo de $G$ isomorfo a $H$. Y si esto no es posible, me gustaría encontrar un subgrupo $K$ $G$ con un homomorphism de $H$ a $K$ tener un kernel como sea posible. Cómo se podría ir sobre esto?

Answer 1

Hay varias maneras que usted podría intentar esto, y encontrar el método más eficaz para los tipos de grupos que están interesados en poder disponer de alguna experimentación. Una forma sería la de comenzar por la búsqueda de todos (conjugacy clases de) subgrupos de $G$ de fin de dividir $|H|$ y, a continuación, prueba de ellos en orden decreciente de tamaño para ser cocientes de $H$.

Mi inclinación sería probar primero el simple método de apenas computación todos los homomorphisms forma$H$$G$. Traté de que en el Magma con un par de grupos de fo y funcionó muy rápidamente. Hay un Magma de la función ${\mathtt {Homomorphisms}}$, que calcula la homomorphisms de un finitely presentado al grupo a un grupo finito, hasta conjugacy de la imagen. Encuentra surjective homomorphisms por defecto, pero no es una opción para apagarla. Aquí está una randomish ejemplo con $G$ a un simple grupo de orden $20160$ $H$ un grupo de orden $120$.

Estoy seguro de que usted puede hacer un cálculo similar en la BRECHA, pero yo soy un poco menos familiarizado con las funciones pertinentes, así que espero que alguien pueda ayudarte con eso. O usted podría escribir en el foro del GAP de la lista de correo.

> G:=PSL(3,4);                                 
> H:=SmallGroup(120,30);
> H:=FPGroup(H);
> time homs:=Homomorphisms(H,G:Surjective:=false);
   Time: 0.220
> [ Order(Kernel(h)) : h in homs ];
  [ 120, 60, 60, 20, 60, 30, 30, 30, 30, 30, 30, 30, 30, 12, 12, 15, 15,
    15, 15, 15, 15 ]

Así, en este ejemplo, el cálculo de homomorphisms llevó $0.220$ segundos, y el más pequeño de los núcleos tienen el fin de $12$.

Aquí está otro ejemplo con el mismo $G$:

> H:=SmallGroup(120,5); 
> H:=FPGroup(H);
> time homs:=Homomorphisms(H,G:Surjective:=false);
  Time: 0.040
> [ Order(Kernel(h)) : h in homs ];
  [ 120, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 ]

El grupo $H$ había ${\rm SL}(2,5)$ y se ha encontrado homomorphisms a $A_5$.

De hecho ahora veo que $G$ no tiene subgrupos de orden $120$, así que quizás esta fue una mala elección!

Añadido posterior: he experimentado un poco más, y ahora veo que el enfoque anterior es demasiado ingenuo y funciona muy mal para algunos tipos de grupos de $G$. He intentado

>   G:=DirectProduct(SmallGroup(100,2),SmallGroup(100,5));
>   H:=SmallGroup(100,4);

y el homomorphism cálculo no termina en diez minutos. Sin embargo, el enfoque alternativo de la primera búsqueda de los subgrupos de $G$ de fin de dividir $|H|$ funcionaba bien. Aquí es cómo lo hice.

> S := [s`subgroup : s in Subgroups(G : OrderDividing := Order(H)) ];
> S := Reverse(S);
> H:=FPGroup(H);
> for s in S do                                                          
    homs := Homomorphisms(H,s);  
    if #homs ne 0 then "Found homomorphism, kernel size", #Kernel(homs[1]); 
      break;
  end if; end for;
Found homomorphism, kernel size 25

Answer 2

Para complementar Derek respuesta con un ejemplo en la BRECHA, los tres primeros bloques de comandos desde arriba se ven casi idénticos. Tenga en cuenta que H se toma en el policíclicos representación (si uno necesita un fp-grupo, en BRECHA el comando sería Image(IsomorphismFrGroup(H):

gap> G:=PSL(3,4);                                 
Group([ (3,4,5)(7,9,8)(10,14,18)(11,17,20)(12,15,21)(13,16,19), (1,2,6,7,11,3,
10)(4,14,8,15,16,20,13)(5,18,9,19,21,17,12) ])
gap> H:=SmallGroup(120,30);
<pc group of size 120 with 5 generators>
gap> homs:=AllHomomorphismClasses(H,G);; time;
235
gap> List(homs, h -> Order(Kernel(h)));
[ 120, 60, 60, 15, 15, 15, 30, 30, 30, 60, 30, 30, 15, 15, 15, 30, 30, 30, 12, 
  12, 20 ]

A continuación, podría utilizar la BRECHA de la función AllHomomorphism, pero puede ser más eficaz el uso de AllHomomorphismClasses que se devuelve a los representantes de todos homomorphisms de $H$ $G$$H$- conjugacy:

gap> H:=SmallGroup(120,5); 
Group([ (1,2,4,8)(3,6,9,5)(7,12,13,17)(10,14,11,15)(16,20,21,24)
(18,22,19,23), (1,3,7)(2,5,10)(4,9,13)(6,11,8)(12,16,20)(14,18,22)(15,19,23)
(17,21,24) ])
gap> homs:=AllHomomorphismClasses(H,G);; time;
97
gap> List(homs, h -> Order(Kernel(h)));
[ 120, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 ]

Los Grupos Pequeños de la Biblioteca se incluye tanto la BRECHA y el MAGMA. Es crucial que no sólo la sintaxis es similar, si no idéntica, pero la numeración es la misma:

gap> G:=DirectProduct(SmallGroup(100,2),SmallGroup(100,5));
<pc group of size 10000 with 8 generators>
gap> H:=SmallGroup(100,4);
<pc group of size 100 with 4 generators>

Para la última parte, uno podría usar LatticeByCyclicExtension para dar el límite superior en el orden del subgrupo, o el uso de SubgroupsSolvableGroup con varios tipos de SizeConsiderFunctions. Si solo voy a usar SubgroupsSolvableGroup sin ningún tipo de limitaciones, me tarda 40 segundos en ejecutar a través de todos los representantes de las clases conjugacy de los subgrupos de $G$ y todas las clases de homomorphisms para encontrar todos los posibles tamaños de kernels (time es el tiempo de CPU del último comando en milisegundos):

gap> S:=SubgroupsSolvableGroup(G);;
gap> S:=Reversed(S);;
gap> kernelsizes:=[];
[  ]
gap> for s in S do                                                          
>     homs := AllHomomorphismClasses(H,s);
>     for h in homs do
>       AddSet( kernelsizes, Size( Kernel( h ) ) ); 
>     od;
> od; time;
39546
gap> kernelsizes;
[ 25, 50, 100 ]

Ahora un enfoque alternativo que utiliza LatticeByCyclicExtension y busca sólo los subgrupos de orden dividiendo 100:

gap> l:=LatticeByCyclicExtension( G,
> function(G) return Size(G) in DivisorsInt((Size(H))); end);
<subgroup lattice of <pc group of size 10000 with 8 generators>, 722 classes, 
722 subgroups, restricted under further condition l!.func>
gap> classes:=ConjugacyClassesSubgroups(l);;
gap> S:=List(classes,Representative);;
gap> Set(List(S,Size));
[ 1, 2, 4, 5, 10, 20, 25, 50, 100 ]
gap> S:=Reversed(S);;
gap> for s in S do                                                          
>     homs := AllHomomorphismClasses(H,s);
>     phi := First( homs, h -> Size(Kernel(h)) = 25 );
>     if phi <> fail then
>         Print("Found homomorphism, kernel size 25 :\n", phi, "\n");
>         break;
>     fi; 
> od;time;
Found homomorphism, kernel size 25 :
Pcgs([ f1, f2, f3, f4 ]) -> [ f3*f5, f3*f6, <identity> of ..., 
  <identity> of ... ]
31

Así, nos encontramos con la primera de tales homomorphisms inmediatamente. De hecho, hemos

gap> phi;
[ f1, f2, f3, f4 ] -> [ f3*f5, f3*f6, <identity> of ..., <identity> of ... ]
gap> Size(Kernel(phi));
25