[GAP Forum] Problem with certains nonsolvable groups...

[Thomas Breuer]

Dear GAP Forum,

Giulio Peruginelli wrote:

> I have a problem with two nonsolvable groups, (120, 35) and (504,156)
> Gap3 says the 1st is A5x2 (I don't know what x2 means...)
> and the 2nd one is PSL(2,8).
> 
> I computed the orders of its conjugacy classes two times and I obtain
> two different  results!
> 1st group:
> G:=SmallGroup(120,35);;
> C:=ConjugacyClasses(G);;
> l:=[];;
> for i in [1..Length(C)] do
>  l[i]:=Order(G, Representative(C[i]));
> od;
> l;
> [ 1, 2, 3, 6, 2, 2, 5, 10, 5, 10 ]
> (other result: [1,5,5,10,10, 3,6,2,2,2]).
> 
> [...]

It is documented that the ordering of conjugacy classes of two equal groups
may be different,
except that the identity element is always in the first class,
see ``ConjugacyClasses'' in the GAP Reference Manual.

More generally, there are several operations which do not guarantee the
same result when they are called several times with equal arguments.

One possible reason is that although the arguments for two calls are equal,
the known attributes stored in the arguments might be different
and thus GAP chooses different methods for the computation.

Another possible reason is that the method in question calls `Random',
which may yield different representatives of conjugacy classes
(or a different Sylow p subgroup) also when the same method is called.

In the example given,
the two different results arise in the following situations.

    gap> g:= SmallGroup( 120, 35 );;
    gap> c:= ConjugacyClasses( g );;
    gap> List( c, x -> Order( g, Representative( x ) ) );
    [ 1, 2, 3, 6, 2, 2, 5, 10, 5, 10 ]
    gap> g:= SmallGroup( 120, 35 );;
    gap> RationalClasses( g );;       # call this before `ConjugacyClasses'
    gap> c:= ConjugacyClasses( g );;
    gap> List( c, x -> Order( g, Representative( x ) ) );
    [ 1, 5, 5, 10, 10, 3, 6, 2, 2, 2 ]

> As you told me I use these two function in order to compute the
> representation of the
> automorphism group as permutation group on the set of the conjugacy classes
> of G 
> 
> OnClasses:=function(cl,g)
>   return ConjugacyClass(cl.group,Representative(cl)^g); 
> end; 
> 
> Aut:=function(G)
>    local AutomG, C ;
>       AutomG:=AutomorphismGroup(G);
>       C:=ConjugacyClasses(G);
>       return Operation(AutomG,C,OnClasses);
> end;

The solution is to create the group only once (and to store it in a local
variable),
to compute its conjugacy classes only once (and to store the list in a local
variable),
and then to refer to these variables whenever one needs a consistent
order of classes.

Of course this does *not* solve the problem that in another GAP session,
a different order of classes may be chosen.

> Where am I wrong? maybe I am using the 2 functions above in a wrong way...
> 
> by the way, in which order are the conjugacy classes of a finite group
> represented?
> I mean, which comes 1st, after the identity and so on? do you know if it's
> the same
> order used in magma?

As sketched above:
The point is that GAP does not support a unique ``standard'' ordering
of conjugacy classes of a group.
Creating a group twice from generators and calling `ConjugacyClasses'
for the two objects may give different lists of classes.

All the best,
Thomas Breuer