Conjugacy classes of PSL(6,7)

Question

I need the conjugacy class sizes of projective special linear group PSL(6,7). I couldn't find it by using GAP. Could someone find it?

Answer 1

The runtime of straightforward calculation of conjugacy classes of PSL(n,7) using ConjugacyClasses seems to depend on $n$ exponentially. Here there are some initial values and runtimes:

\begin{equation} \begin{array}{l|lllll} n & |G| & Nr.classes & Runtime \\ \hline 2 & 168 & 6 & \lt 0,01s \\ 3 & 1876896 & 22 & 0,5s \\ 4 & 2317591180800 & 217 & 37s \\ 5 & 187035198320488089600 & 2792 & 644m \\ 6 & 61637759336805268655956377600 & 3324 & ? \end{array} \end{equation}

For $n=6$, if it would be e.g. $1000$ times longer than $n=5$, it would already take more than a year, so one should employ a better approach - see Alexander's answer which takes just half an hour.

Remark: Note that for groups whose character table available in the GAP character table library, there is another way to get such information without actual calculations: see my answer to the question "the number of all orders of elements in HS (Higman-Sims group) with GAP".

Remark 2: For classical groups, there are functions NrConjugacyClassesName where Name is one of $GU$, $SL$, $SU$, $PGL$, $PGU$, $PSL$, $PSU$ etc. using the formulas for the number of conjugacy classes from Macdonald, I. G., Numbers of conjugacy classes in some finite classical groups, Bull. Austral. Math. Soc., 23 (1) (1981), 23–48 - see Conjugacy Classes in Classical Groups from the GAP manual.

Answer 2

There is a GAP function NrConjugacyClassesPSL that returns the number of classes in essentially no time. For the actual class representatives, I am not aware of a special function for PSL, but there is one (based on polynomials and normal forms) for SL. So the best approach is probably to piggy-back on this one. By adapting the code one most likely could write down class representatives directly for the projective image, the following approach is a poor man's version that simply takes the classes of SL, maps the representatives in the projective image and tests for conjugacy (with some minimal accounting by sizes of classes and preimages and the possible fusion of classes, using normal form theory). If $SL\cong PSL$, of course no fusion needs to take place. This is implemented by the following function (much improved version 2):

ClassesProjectiveImage:=function(G)
local dom,act,PG,cl,c,i,r,s,sel,p,z,a,x,prop,fus,f,reps,repi,repo,zel,fcl,
      real,goal,good,e;

  # elementary divisors for GL-class identification
  x:=X(DefaultFieldOfMatrixGroup(G),1);
  prop:=y->Set(Filtered(ElementaryDivisorsMat(y-x*y^0),
              y->DegreeOfUnivariateLaurentPolynomial(y)>0));

  # compute real fusion
  real:=function(set)
  local new,i,a,b;
    new:=[];
    for i in set do
      if i in set then # might have been removed by now
        b:=ConjugacyClass(PG,repi[i]);
        a:=Filtered(set,x->x<>i and repi[x] in b);
        a:=Union(a,[i]);
        fcl[a[1]]:=b;
        Add(new,a);
        set:=Difference(set,a);
      fi;
    od;
    return new;
  end;

  dom:=NormedVectors(DefaultFieldOfMatrixGroup(G)^Length(One(G)));
  act:=ActionHomomorphism(G,dom,OnLines,"surjective");
  PG:=Image(act); # this will be PSL etc.
  StabChainMutable(PG);; # needed anyhow and will speed up images under act
  z:=Size(Centre(G));
  zel:=Filtered(Elements(Centre(G)),x->Order(x)>1);
  cl:=ConjugacyClasses(G);
  if IsNaturalGL(G) then
    goal:=NrConjugacyClassesPGL(Length(One(G)),
          Size(DefaultFieldOfMatrixGroup(G)));
  elif IsNaturalSL(G) then
    goal:=NrConjugacyClassesPSL(Length(One(G)),
          Size(DefaultFieldOfMatrixGroup(G)));
  else
    goal:=Length(cl); # this is too loose, but upper limit
  fi;

  s:=[]; # count how much of pre-images we still need to account for
  sel:=[];
  reps:=List(cl,Representative);
  repi:=List(reps,x->ImagesRepresentative(act,x));
  repo:=List(repi,Order);
  e:=List(reps,prop);

  sel:=[1..Length(cl)];
  fcl:=[]; # cached factor group classes
  if z=1 then
    fus:=List(sel,x->[x]);
  else
    # fuse maximally under centre multiplication
    fus:=[];
    while Length(sel)>0 do
      a:=sel[1]; sel:=sel{[2..Length(sel)]};
      p:=Union(e{[a]},List(zel,x->prop(reps[a]*x)));
      f:=Filtered(sel,x->e[x] in p and repo[a]=repo[x]);
      sel:=Difference(sel,f);
      AddSet(f,a);
      Add(fus,f);
    od;

    # separate those that clearly cannot fuse fully
    good:=[];
    for i in Filtered(fus,x->Length(x)>z or z mod Length(x)<>0) do
      a:=real(i);
      fus:=Union(Filtered(fus,x->x<>i),a);
      good:=Union(good,a); # record that we properly tested
    od;

    # now go through and test properly and fuse, unless we reached the
    # proper class number
    for i in fus do
      if not i in good and Length(fus)<goal then
        # fusion could split up -- test
        a:=real(i);
        fus:=Union(Filtered(fus,x->x<>i),a);
      fi;
    od;
  fi;

  # now fusion is good -- form classes
  c:=[];
  for i in fus do
    if IsBound(fcl[i[1]]) then
      a:=fcl[i[1]];
    else
      a:=ConjugacyClass(PG,repi[i[1]]);
    fi;
    Add(c,a);
    f:=Sum(cl{i},Size)/z;
    SetSize(a,f);
  od;

  SetConjugacyClasses(PG,c);
  return [act,PG,c];
end;

To use it, you call ClassesProjectiveImage(SL(dim,field));; and you get as result a list of length 3, [action homomorphism SL->PSL, PSL, class list].

It finds the 3324 classes of PSL(6,7) and their sizes (but just that, not actual generators of the centralizers) in about 30 minutes on my computer.