Grupos finitos de orden suma del orden de los elementos

Question

Dados dos grupos finitos $G, H$, vamos a decir que $G<_oH$ si

una. $|G|<|H|$

o

b. $|G|=|H|$ e $\displaystyle\sum_{g\in G} o(g)<\sum_{h\in H} o(h)$,

donde $o(g)$ indica el orden de los elementos $g$ (ha este orden de un nombre?).

¿Cuál es el más pequeño ejemplo (en este orden) de un par de nonisomorphic grupos que $G$ e $H$ son incomparables, es decir, que ellos tienen el mismo cardinal y la misma suma de los órdenes de los elementos?

Answer 1

La siguiente función de Arce (aquí el código requiere que el paquete Maple GroupTheory) toma como argumento un grupo y devuelve la suma de los pedidos de sus elementos:

sumOfOrders := G -> add(u, u in map(PermOrder, convert(Elements(G), list), G));

Esta función toma como argumento un entero positivo $n$ y devuelve el conjunto múltiple de las cantidades de los pedidos de elementos de los grupos de orden $n$:

sumOfOrdersList := n -> sort(map(sumOfOrders, AllSmallGroups(n)));

La comprobación de las órdenes más bajas manualmente nos encontramos con que los grupos incomparable en su sentido se producen por primera vez en la orden de 16: Ejecución sumOfOrdersList(16) muestra que hay tres grupos con suma $47$, tres con suma $55$ y dos con $87$.

(Cf. https://groupprops.subwiki.org/wiki/Groups_of_order_16 )

Answer 2

Alimentar el código siguiente a Magma(http://magma.maths.usyd.edu.au/calc/):

for grouporder in [1..24] do
  printf "Checking sum of order for groups or order %o:", grouporder;
  numgroup := NumberOfSmallGroups(grouporder);

  sset := [];
  for i in [1..numgroup] do
    sumorder := 0;
    G := SmallGroup(grouporder,i);
    for j in G do
      sumorder := sumorder + Order(j);
    end for;
    Append(~sset, sumorder);
  end for;

  sset;
  printf "\n";
end for;

Usted puede ver que hay dos grupos con "firma" $(16,47)$. Muchas gracias a Travis para señalarla. Dos de ellos no son abelian; han BRECHA id $(16,3)$ e $(16,13)$. Por favor, consulte la groupprop página para la descripción. La tercera es $\mathbb Z/4\mathbb Z \times (\mathbb Z/2\mathbb Z)^2$. Todos tienen 1 elemento de orden 1, 7 elementos de orden 2, y 8 elementos de orden 4.

También, hay tres grupos con "firma" $(16,55)$.

Los grupos son los siguientes:

$G_1 = (\mathbb Z/4\mathbb Z)^2$; $G_2 = \langle a, b \ | \ a^4 = b^4 = 1, ba = ab^3\rangle$ (el semi-producto directo de dos copias de $\mathbb Z/4\mathbb Z$), $G_3 = Q \times \mathbb Z/2\mathbb Z$, donde $Q$ es el grupo de cuaterniones. Todos tienen 1 elemento de orden 1, 3 elementos de orden 2, y 12 elementos de orden 4.

Edit: Esto es copiado de Travis comentario más abajo. Hay dos grupos de firma de $(16,87)$ así. Uno de ellos es el grupo abelian $\mathbb Z/8\mathbb Z \times \mathbb Z/2\mathbb Z$, y el otro es el no-grupo abelian con la BRECHA de ID $(16, 6)$ o también llamado $M_4(2)$. Ambos tienen 1, 3, 4, y 8 elementos de orden 1, 2, 4, y 8, respectivamente.

Answer 3

Para dar una respuesta en la que utiliza el software de código abierto se puede hacer esto en la BRECHA.

En primer lugar, la BRECHA de código basado en el de la respuesta por @Travis. Se ve muy similar.

gap> sumOfOrders := G -> Sum(List(G,Order));
function( G ) ... end
gap> sumOfOrdersList := n -> SortedList(List(AllSmallGroups(n),sumOfOrders));
function( n ) ... end
gap> List([1..16],sumOfOrdersList);
[ [ 1 ], [ 3 ], [ 7 ], [ 7, 11 ], [ 21 ], [ 13, 21 ], [ 43 ], 
  [ 15, 19, 23, 27, 43 ], [ 25, 61 ], [ 31, 63 ], [ 111 ], 
  [ 31, 33, 45, 49, 77 ], [ 157 ], [ 57, 129 ], [ 147 ], 
  [ 31, 39, 47, 47, 47, 55, 55, 55, 59, 67, 75, 87, 87, 171 ] ]

Se puede ver que la última lista contiene 47 tres veces. Ahora vamos a buscar los tres grupos:

gap> l:=AllSmallGroups(16,g->sumOfOrders(g)=47);
[ <pc group of size 16 with 4 generators>, 
  <pc group of size 16 with 4 generators>, 
  <pc group of size 16 with 4 generators> ]

y obtener su Id:

gap> List(l,IdGroup);
[ [ 16, 3 ], [ 16, 10 ], [ 16, 13 ] ]

Alguna noción acerca de su estructura puede ser obtenida por StructureDescription (que sin embargo no define el grupo de isomorfismo - ver aquí):

gap> List(l,StructureDescription);
[ "(C4 x C2) : C2", "C4 x C2 x C2", "(C4 x C2) : C2" ]

Si me gustaría ser menos suerte y no logran encontrar un ejemplo con una rápida exploración, probablemente escribir algo de código para más sistemático de búsqueda, que se vería el código de abajo, siguiendo las directrices de "Pequeños grupos de búsqueda" en la BRECHA de Software de Carpintería de la lección:

TestOneOrder:=function(n)
# find the smallest example among the groups of order n
local s,i,m,d,x;
# Calculate lists of sums of element orders.
# Avoid using AllSmallGroups(n) which potentially may be very large
s := List([1..NrSmallGroups(n)],i->Sum(List(SmallGroup(n,i),Order)));
if Length(Set(s))=NrSmallGroups(n) then
  # Sum of element orders uniquely defines each group
  return fail;
else
  # There are duplicates - find them first
  d := Filtered( Collected(s), x -> x[2] > 1 );
  # Find the minimal possible value of the sum of element orders
  m := Minimum( List( d, x-> x[1] ) );
  # Find positions of m in the list
  # Return the list of group IDs
  return List( Positions(s,m), x -> [n,x] );
fi;
end;

FindSmallestPair:=function(n)
# check all groups of order up to n
local i, res;
for i in [1..n] do
  # \r at the end of the print returns to the beginning of the line
  Print("Checking groups of order ", i, "\r");
  res := TestOneOrder(i);
  if res<>fail then
    # print new line before displaying the output 
    Print("\n");
    return res;
  fi;
od;
return fail;
end;    

La lectura de este código en la BRECHA, se podría obtener el mismo resultado como el siguiente:

gap> FindSmallestPair(20);
Checking groups of order 16
[ [ 16, 3 ], [ 16, 10 ], [ 16, 13 ] ]