Improvements to automorphisms/isomorphisms of solvable group

lib/grppcaut.gi

@@ -1306,7 +1306,9 @@ InstallGlobalFunction(AutomorphismGroupSolvableGroup,function( G )
         B := NormalizingReducedGL( spec, s, n, M,B );
         # A and B will not be used later, so it is no problem to
         # replace them by other groups with fewer generators
-        B:=SubgroupNC(B,SmallGeneratingSet(B));
+        if Length(GeneratorsOfGroup(B))>4 then
+          B:=SubgroupNC(B,SmallGeneratingSet(B));
+        fi;
 
         if weights[s][2] = 1 then
             #Info( InfoAutGrp, 2,"compute reduced gl ");
@@ -1515,8 +1517,14 @@ InstallGlobalFunction(AutomorphismGroupFrattFreeGroup,function( G )
 
     # go over to perm rep
     Info( InfoAutGrp, 2, "compute perm rep ");
-    iso := IsomorphismPermGroup( A );
+    if Length(AbelianInvariants(F))>4 then
+      # likely the element action is best anyhow
+      iso := ActionHomomorphism(A,Elements(Group(gensF)),"surjective");;
+    else
+      iso := IsomorphismPermGroup( A );
+    fi;
     P   := Image( iso );
+    if HasSize(A) then SetSize(P,Size(A));fi;
 
     # compute subgroup
     Info( InfoAutGrp, 2, "compute subgroup ");
@@ -1525,7 +1533,7 @@ InstallGlobalFunction(AutomorphismGroupFrattFreeGroup,function( G )
         imgs := List( gensF, y -> y ^ k );
         aut := GroupHomomorphismByImagesNC( F, F, gensF, imgs );
         # CheckAuto( aut );
-        Add( gensU, Image( iso, aut ) );
+        Add( gensU, ImagesRepresentative( iso, aut ) );
     od;
     U := SubgroupNC( P, gensU );
     hom := GroupHomomorphismByImagesNC( K, U, gensK, gensU );

lib/grppcext.gi

@@ -361,8 +361,12 @@ local ag, p1iso, agp, p2iso, DP, p1, p2, gens, genimgs, triso,s,i,u,opt,
       SetSize(ag,s);
     fi;
     IsGroupOfAutomorphismsFiniteGroup(ag);
-    p1iso:=IsomorphismPermGroup(ag);
-    agp:=Image(p1iso);
+    # go nice route to avoid an abelian method getting in the way
+    p1iso:=NiceMonomorphism(ag);
+    if not IsPermGroup(Image(p1iso)) then
+      p1iso:=IsomorphismPermGroup(ag);
+    fi;
+    agp:=Image(p1iso,ag);
 
     # are both groups solvable?
     p2iso:=IsomorphismPermGroup(DirectProductInfo(D).groups[2]);
@@ -502,7 +506,8 @@ end);
 InstallGlobalFunction( CompatiblePairs, function( arg )
 local G, M, Mgrp, oper, A, B, D, translate, gens, genimgs, triso, K, K1,
   K2, f, tmp, Ggens, pcgs, l, idx, u, tup,Dos,elmlist,preimlist,pows,
-  baspt,newimgs,i,j,basicact,neu,K1nontriv,epi,hf,pool,modulehom,test;
+  baspt,newimgs,i,j,basicact,neu,K1nontriv,epi,hf,pool,modulehom,test,
+  direct;
 
     # catch arguments
     if Length(arg)>2 and IsGroupOfAutomorphismsFiniteGroup(arg[1]) and
@@ -517,20 +522,48 @@ local G, M, Mgrp, oper, A, B, D, translate, gens, genimgs, triso, K, K1,
     Mgrp := GroupByGenerators( M.generators );
     Ggens:=Pcgs(G);
     oper:=fail;
-    if IsPcgs(Ggens) and Length(Ggens)=Length(M.generators) then
-      oper := GroupHomomorphismByImagesNC( G, Mgrp, Ggens, M.generators );
-    elif Length(arg)=2 then
+
+    direct:=false;
+
+    if A=fail and Length(arg)=2 then
       # search through automorphism group for projection image and reps,
       # then add module automorphisms
       gens:=GeneratorsOfGroup(G);
       if A=fail then
         Info( InfoCompPairs, 1, "    CompP: compute aut group");
         A:=AutomorphismGroup(G);
       fi;
-      triso:=IsomorphismPermGroup(A);
+      u:=fail;
+      if Size(A)>1 then
+        direct:=true;
+      fi;
+
+    elif A=fail and Length(arg)=3 and HasDirectProductInfo(arg[3])
+      and IsGroupOfAutomorphismsFiniteGroup(Image(Projection(arg[3],1))) then
+
+      A:=Image(Projection(arg[3],1));
+      B:=Image(Projection(arg[3],2));
+      u:=B;
+      gens:=GeneratorsOfGroup(G);
+      if Size(A)>1 and Size(B)>1 and Size(A)*Size(B)>1000 then
+        direct:=true;
+      fi;
+
+    elif IsPcgs(Ggens) and Length(Ggens)=Length(M.generators) then
+      oper := GroupHomomorphismByImagesNC( G, Mgrp, Ggens, M.generators );
+    fi;
+
+    if direct then
+      triso:=NiceMonomorphism(A:autactbase:=fail);
+      if not IsPermGroup(Image(triso)) then
+        triso:=IsomorphismPermGroup(A:autactbase:=fail);
+      fi;
+
       pool:=[];
       modulehom:=GroupHomomorphismByImages(G,Group(M.generators),
         gens,M.generators);
+      M.isMTXModule:=true;
+      M.IsOverFiniteField:=true;
       test:=function(perm)
       local aut,imgs,mat;
         aut:=PreImagesRepresentative(triso,perm);
@@ -569,14 +602,28 @@ local G, M, Mgrp, oper, A, B, D, translate, gens, genimgs, triso, K, K1,
         A:=GroupWithGenerators(pool);
         SetSize(A,Size(K)*Size(B));
       fi;
-      return A;
+
+      # make sure the B-part is OK
+      if u<>fail then
+        B:=List(GeneratorsOfGroup(A),x->x[2]);
+        B:=Group(B);
+        if not IsSubset(u,B) then
+          Info(InfoCompPairs,1," projection wrong, go normal");
+        else
+          return A;
+        fi;
+      else
+        return A;
+      fi;
+
     fi;
 
     if oper=fail then
       Ggens:=GeneratorsOfGroup(G);
       oper := GroupHomomorphismByImagesNC( G, Mgrp, Ggens, M.generators );
     fi;
 
+
     # automorphism groups of G and M
     if Length( arg ) = 2 then
         if A=fail then
@@ -839,7 +886,8 @@ local G, M, Mgrp, oper, A, B, D, translate, gens, genimgs, triso, K, K1,
             tmp := StabilizerOp( D, rec(hashfun:= lst->lst*pows),tup,
               gens,newimgs, f );
           else
-            tmp := Stabilizer( D, tup,gens,genimgs, f );
+            #tmp := Stabilizer( D, tup,gens,genimgs, f );
+            tmp := SubnormalOrbitExtension( D, false, tup,gens,genimgs, f );
           fi;
         else
           tmp := Stabilizer( D, tup,gens,genimgs, f );

lib/morpheus.gi

@@ -475,6 +475,11 @@ local hom, gens, c, ran, r, cen, img, u, orbs,
       Error("illegal actbase given!");
     fi;
     baddegree:=RootInt(Sum(actbase,Size)^2,3);
+    if IsPcGroup(g) then
+      # for pc groups action and storage is cheaper, and there are more
+      # classes
+      baddegree:=Maximum(List(actbase,Size));
+    fi;
   else
     baddegree:=RootInt(Size(g)^3,4);
   fi;
@@ -1926,13 +1931,68 @@ local combi,Gr,Gcl,Ggc,Hr,Hcl,bg,bpri,x,dat,
     fi;
     result.inner:=inns;
   else
+    dat:=ValueOption("costlimit");
+    if IsInt(dat) and Product(List(combi,x->Sum(x,Size)))>dat then
+      Info(InfoMorph,2,"Morpheus seems to be to costly: ",
+        Product(List(combi,x->Sum(x,Size)))," vs ",dat);
+      return -1; # not fail, as this is valid
+    fi;
     result:=MorClassLoop(H,combi,result,7);
   fi;
 
   return result;
 
 end);
 
+
+#############################################################################
+##
+#F  AutOrderAbelian( <L> ) . . order of Aut(A), A the abelian group with
+##                             cyclic factors given by the prime powers <L>
+##
+##  function written by claude, based on formula in HillarRhea07,
+##  DOI 10.1080/00029890.2007.11920485
+##
+AutOrderAbelian := function( L )
+local total, primes, p, q, exps, e, f, power, num, den, c, t;
+
+  for q in L do
+    if not IsInt( q ) or q <= 1 or not IsPrimePowerInt( q ) then
+      Error( "<L> must be a list of prime powers" );
+    fi;
+  od;
+
+  total  := 1;
+  primes := Set( List( L, q -> FactorsInt( q )[1] ) );
+
+  for p in primes do
+
+    # exponents of the p-primary part
+    exps := List( Filtered( L, q -> q mod p = 0 ), q -> LogInt( q, p ) );
+
+    # |End(A_p)| = p^( sum_{i,j} min(e_i,e_j) )
+    power := 0;
+    for e in exps do
+      for f in exps do
+        power := power + Minimum( e, f );
+      od;
+    od;
+
+    # times prod_k |GL_{m_k}(F_p)| / p^{m_k^2}, kept integral throughout
+    num := p^power;
+    den := 1;
+    for c in Collected( exps ) do        # c = [ exponent, multiplicity ]
+      for t in [ 1 .. c[2] ] do
+        num := num * ( p^t - 1 );
+        den := den * p^t;
+      od;
+    od;
+    total := total * ( num / den );
+  od;
+
+  return total;
+end;
+
 #############################################################################
 ##
 #F  AutomorphismGroupAbelianGroup(<G>)
@@ -2050,6 +2110,7 @@ local i,j,k,l,m,o,nl,nj,max,r,e,au,p,gens,offs;
     SetIsGroupOfAutomorphismsFiniteGroup(au,true);
   fi;
 
+  SetSize(au,AutOrderAbelian(List(gens,Order)));
   return au;
 end);
 
@@ -2932,6 +2993,19 @@ local m;
       or Size(SolvableRadical(G))^2>Size(G)
       or ValueOption("forcetest")=true) and
       ValueOption("forcetest")<>"old" then
+
+    # catch 2-generator groups with few images
+    if Length(SmallGeneratingSet(G))=2 then
+      # 2^28 is an experimental limit from some examples
+      m:=Morphium(G,H,false:costlimit:=Minimum(Size(G)^2,2^28));
+      if IsList(m) and Length(m)=0 then
+        return fail;
+      elif m<>-1 then
+        # otherwise it just failed
+        return m;
+      fi;
+    fi;
+
     # In place until a proper implementation of Cannon/Holt isomorphism is
     # done
     return PatheticIsomorphism(G,H);