Merge pull request #878 from hulpke/additions

New Functionality: Cannon/Holt automorphisms, Intermediate subgroups

The code has been stable in the last week in my own tests as well as in the automated tests, performance improvements are significant over the previous cases.
I expect that it might resulty in representative changes in manual examples involving specific representatives.

lib/grp.gd

@@ -921,6 +921,25 @@ DeclareOperation( "ChiefSeriesUnderAction", [ IsGroup, IsGroup ] );
 ##
 DeclareOperation( "ChiefSeriesThrough", [ IsGroup, IsList ] );
 
+#############################################################################
+##
+#F  RefinedSubnormalSeries( <ser>, <n> )
+##
+##  <#GAPDoc Label="RefinedSubnormalSeries">
+##  <ManSection>
+##  <Oper Name="RefinedSubnormalSeries" Arg='ser,n'/>
+##
+##  <Description>
+##  If <A>ser</A> is a subnormal series of a group <A>G</A>, and <A>n</A> is a
+##  normal subgroup, this function returns the series obtained by refining with
+##  <A>n</A>, that is closures and intersections are inserted at the appropriate
+##  place.
+##  </Description>
+##  </ManSection>
+##  <#/GAPDoc>
+##
+DeclareGlobalFunction( "RefinedSubnormalSeries" );
+
 
 #############################################################################
 ##
@@ -1783,6 +1802,29 @@ DeclareAttribute( "MinimalNormalSubgroups", IsGroup );
 ##
 DeclareAttribute( "NormalSubgroups", IsGroup );
 
+#############################################################################
+##
+#A  CharacteristicSubgroupsLib( <G> )
+##
+##  <#GAPDoc Label="CharacteristicSubgroupsLib">
+##  <ManSection>
+##  <Attr Name="CharacteristicSubgroupsLib" Arg='G'/>
+##
+##  <Description>
+##  returns a list of all characteristic subgroups of <A>G</A>, that is
+##  subgroups that are invariant under all automorphisms.
+##  <Example><![CDATA[
+##  gap> g:=SymmetricGroup(4);;NormalSubgroups(g);
+##  [ Sym( [ 1 .. 4 ] ), Group([ (2,4,3), (1,4)(2,3), (1,3)(2,4) ]), 
+##    Group([ (1,4)(2,3), (1,3)(2,4) ]), Group(()) ]
+##  ]]></Example>
+##  <P/>
+##  </Description>
+##  </ManSection>
+##  <#/GAPDoc>
+##
+DeclareAttribute( "CharacteristicSubgroupsLib", IsGroup );
+
 
 #############################################################################
 ##

lib/grp.gi

@@ -642,6 +642,45 @@ InstallMethod( ChiefSeries,
     G -> ChiefSeriesUnderAction( G, G ) );
 
 
+#############################################################################
+##
+#M  RefinedSubnormalSeries( <ser>,<n> ) 
+##
+InstallGlobalFunction("RefinedSubnormalSeries",function(ser,sub)
+local new,i,c;
+  new:=[];
+  i:=1;
+  if not IsSubset(ser[1],sub) then
+    sub:=Intersection(ser[1],sub);
+  fi;
+  while i<=Length(ser) and IsSubset(ser[i],sub) do
+    Add(new,ser[i]);
+    i:=i+1;
+  od;
+  while i<=Length(ser) and not IsSubset(sub,ser[i]) do
+    c:=ClosureGroup(sub,ser[i]);
+    if Size(new[Length(new)])>Size(c) then
+      Add(new,c);
+    fi;
+    if Size(new[Length(new)])>Size(ser[i]) then
+      Add(new,ser[i]);
+    fi;
+    sub:=Intersection(sub,ser[i]);
+    i:=i+1;
+  od;
+  if Size(sub)<Size(new[Length(new)]) and i<=Length(ser) and Size(sub)>Size(ser[i]) then
+    Add(new,sub);
+  fi;
+  while i<=Length(ser) do
+    Add(new,ser[i]);
+    i:=i+1;
+  od;
+  Assert(1,ForAll([1..Length(new)-1],x->Size(new[x])<>Size(new[x+1])));
+  return new;
+end);
+
+
+
 #############################################################################
 ##
 #M  CommutatorFactorGroup( <G> )  . . . .  commutator factor group of a group
@@ -4965,6 +5004,13 @@ function(G,U)
   return AsList(ConjugacyClassSubgroups(G,U));
 end);
 
+#############################################################################
+##
+#M  CharacteristicSubgroupsLib( <G> )
+##
+InstallMethod(CharacteristicSubgroupsLib,"use automorphisms",true,[IsGroup],
+  G->Filtered(NormalSubgroups(G),x->IsCharacteristicSubgroup(G,x)));
+
 InstallTrueMethod( CanComputeSize, HasSize );
 
 InstallMethod( CanComputeIndex,"by default impossible unless identical",

lib/grplatt.gi

@@ -2306,9 +2306,70 @@ local rt,op,a,l,i,j,u,max,subs;
   return rec(subgroups:=List(a,i->ClosureGroup(U,rt{i})),inclusions:=max);
 end);
 
+InstallMethod(IntermediateSubgroups,"blocks for coset operation",
+  IsIdenticalObj, [IsGroup,IsGroup],
+  1, # better than previous if index larger
+function(G,U)
+local uind,subs,incl,i,j,k,m,gens,t,c,p;
+  if (not IsFinite(G)) and Index(G,U)=infinity then
+    TryNextMethod();
+  fi;
+  uind:=IndexNC(G,U);
+  if uind<200 then
+    TryNextMethod();
+  fi;
+  subs:=[G]; #subgroups so far
+  incl:=[];
+  i:=1;
+  gens:=SmallGeneratingSet(U);
+  while i<=Length(subs) do
+    # find all maximals containing U
+    m:=MaximalSubgroupClassReps(subs[i]);
+    m:=Filtered(m,x->IndexNC(subs[i],U) mod IndexNC(subs[i],x)=0);
+    Info(InfoLattice,1,"Subgroup ",i,", Order ",Size(subs[i]),": ",Length(m),
+      " maxes");
+    for j in m do
+      t:=RightTransversal(subs[i],Normalizer(subs[i],j)); # conjugates
+      for k in t do
+        if ForAll(gens,x->k*x/k in j) then
+	  # U is contained in j^k
+	  c:=j^k;
+	  Assert(1,IsSubset(c,U));
+	  #is it U?
+	  if uind=IndexNC(G,c) then
+	    Add(incl,[0,i]);
+	  else
+	    # is it new?
+	    p:=PositionProperty(subs,x->IndexNC(G,x)=IndexNC(G,c) and
+	      ForAll(GeneratorsOfGroup(c),y->y in x));
+	    if p<>fail then 
+	      Add(incl,[p,i]);
+	    else
+	      Add(subs,c);
+	      Add(incl,[Length(subs),i]);
+	    fi;
+	  fi;
+	fi;
+      od;
+    od;
+    i:=i+1;
+  od;
+  # rearrange
+  c:=List(subs,x->IndexNC(x,U));
+  p:=Sortex(c);
+  subs:=Permuted(subs,p);
+  subs:=subs{[1..Length(subs)-1]}; # remove whole group
+  for i in incl do
+    if i[1]>0 then i[1]:=i[1]^p; fi;
+    if i[2]>0 then i[2]:=i[2]^p; fi;
+  od;
+  Sort(incl);
+  return rec(inclusions:=incl,subgroups:=subs);
+end);
+
 InstallMethod(IntermediateSubgroups,"normal case",
   IsIdenticalObj, [IsGroup,IsGroup],
-  1,# better than the previous method
+  2,# better than the previous methods
 function(G,N)
 local hom,F,cl,cls,lcl,sub,sel,unsel,i,j,rmNonMax;
   if not IsNormal(G,N) then

lib/grpnames.gd

@@ -130,6 +130,25 @@ DeclareOperation( "NormalComplementNC", [IsGroup, IsGroup]);
 ##
 DeclareAttribute( "DirectFactorsOfGroup", IsGroup );
 
+#############################################################################
+##
+#A  CharacteristicFactorsOfGroup( <G> ) . decomposition into a direct product
+##
+##  <#GAPDoc Label="CharacteristicFactorsOfGroup">
+##  <ManSection>
+##  <Attr Name="CharacteristicFactorsOfGroup" Arg="G"/>
+##
+##  <Description>
+##    For a finite group this function returns a list 
+##    of characteristic subgroups [<A>G1</A>, .., <A>Gr</A>] such
+##    that <A>G</A> = <A>G1</A> x .. x <A>Gr</A> and none of the <A>Gi</A>
+##    is a direct product of characteristic subgroups.
+##  </Description>
+##  </ManSection>
+##  <#/GAPDoc>
+##
+DeclareAttribute( "CharacteristicFactorsOfGroup", IsGroup );
+
 #############################################################################
 ##
 #F  DirectFactorsOfGroupFromList( <G>, <Ns>, <MinNs> )

lib/grpnames.gi

@@ -458,6 +458,45 @@ InstallMethod(DirectFactorsOfGroup, "generic method", true,
     return DirectFactorsOfGroupFromList(G, Ns, MinNs);
   end);
 
+InstallMethod(CharacteristicFactorsOfGroup, "generic method", true,
+                        [ IsGroup ], 0,
+function(G)
+local Ns,MinNs,sel,a,sz,j,gs,g,N;
+
+  Ns := ShallowCopy(CharacteristicSubgroupsLib(G));
+  SortBy(Ns,Size);
+  MinNs:=[];
+  sel:=[2..Length(Ns)-1];
+  while Length(sel)>0 do
+    a:=sel[1];
+    sz:=Size(Ns[a]);
+    RemoveSet(sel,sel[1]);
+    Add(MinNs,Ns[a]);
+    for j in ShallowCopy(sel) do
+      if Size(Ns[j])>sz and Size(Ns[j]) mod sz=0 and IsSubset(Ns[j],Ns[a]) then
+	RemoveSet(sel,j);
+      fi;
+    od;
+  od;
+
+  if Length(MinNs)= 1 then
+    # size of MinNs is an upper bound to the number of components
+    return [ G ];
+  fi;
+
+  gs := [ ];
+  for N in MinNs do
+    g := First(GeneratorsOfGroup(N), g -> g<>One(N));
+    if g <> fail then
+      AddSet(gs, g);
+    fi;
+  od;
+  # normal subgroup containing all minimal subgroups cannot have complement
+  Ns := Filtered(Ns, N -> not IsSubset(N, gs));
+
+  return DirectFactorsOfGroupFromList(G, Ns, MinNs);
+end);
+
 InstallGlobalFunction( DirectFactorsOfGroupFromList,
 
   function ( G, NList, MinList )

lib/morpheus.gi

@@ -234,7 +234,8 @@ end);
 ##
 # try to find a small faithful action for an automorphism group
 InstallGlobalFunction(AssignNiceMonomorphismAutomorphismGroup,function(au,g)
-local hom, allinner, gens, c, ran, r, cen, img, dom, u, subs, orbs, cnt, br, bv, v, val, o, i, comb, best;
+local hom, allinner, gens, c, ran, r, cen, img, dom, u, subs, orbs, cnt, br, bv,
+v, val, o, i, comb, best,actbase;
 
   hom:=fail;
   allinner:=HasIsAutomorphismGroup(au) and IsAutomorphismGroup(au);
@@ -378,10 +379,14 @@ local hom, allinner, gens, c, ran, r, cen, img, dom, u, subs, orbs, cnt, br, bv,
 	  fi;
 	od;
       else
+	actbase:=ValueOption("autactbase");
+	if actbase=fail then
+	  actbase:=[g];
+	fi;
 	repeat
 	  cnt:=cnt+1;
 	  repeat
-	    r:=Random(g);
+	    r:=Random(Random(actbase));
 	  until not r in u;
 	  # force prime power order
 	  if not IsPrimePowerInt(Order(r)) then
@@ -1924,11 +1929,15 @@ local A;
     if HasIsFrattiniFree(G) and IsFrattiniFree(G) then
       A:=AutomorphismGroupFrattFreeGroup(G);
     else
-      A:=AutomorphismGroupSolvableGroup(G);
+      # currently autactbase does not work well, as the representation might
+      # change.
+      A:=AutomorphismGroupSolvableGroup(G:autactbase:=fail);
     fi;
   elif Size(RadicalGroup(G))=1 and IsPermGroup(G) then
     # essentially a normalizer when suitably embedded 
     A:=AutomorphismGroupFittingFree(G);
+  elif Size(RadicalGroup(G))>1 then
+    A:=AutomGrpSR(G);
   else
     A:=AutomorphismGroupMorpheus(G);
   fi;
@@ -2017,10 +2026,21 @@ local m;
       and IsSolvableGroup(G) and Size(G) <= 2000 then
       return IsomorphismSolvableSmallGroups(G,H);
     fi;
-  elif Length(ConjugacyClasses(G))<>Length(ConjugacyClasses(H)) then
+  elif AbelianInvariants(G)<>AbelianInvariants(H) then
+    return fail;
+  elif Collected(List(ConjugacyClasses(G),
+          x->[Order(Representative(x)),Size(x)]))
+	<>Collected(List(ConjugacyClasses(H),
+	  x->[Order(Representative(x)),Size(x)])) then
     return fail;
   fi;
 
+  if Length(AbelianInvariants(G))>3 and Size(RadicalGroup(G))>1 then
+    # In place until a proper implementation of Cannon/Holt automorphism is
+    # made available.
+    return PatheticIsomorphism(G,H);
+  fi;
+
   m:=Morphium(G,H,false);
   if IsList(m) and Length(m)=0 then
     return fail;

lib/permdeco.gi

@@ -20,6 +20,15 @@ local   pcgs,r,hom,A,iso,p,i;
   else
     hom:=NaturalHomomorphismByNormalSubgroup(G,r);
   fi;
+
+  A:=Image(hom);
+  if IsPermGroup(A) and NrMovedPoints(A)/Size(A)*Size(Socle(A))
+      >SufficientlySmallDegreeSimpleGroupOrder(Size(A)) then
+    A:=SmallerDegreePermutationRepresentation(A);
+    Info(InfoGroup,3,"Radical factor degree reduced ",NrMovedPoints(Image(hom)),
+         " -> ",NrMovedPoints(Image(A)));
+    hom:=hom*A;
+  fi;
 
   pcgs := TryPcgsPermGroup( G,r, false, false, true );
   if not IsPcgs( pcgs )  then

lib/read5.g

@@ -198,6 +198,7 @@ ReadLib( "schursym.gi");
 # files dealing with nice monomorphism
 ReadLib( "grpnice.gi"  );
 
+ReadLib( "autsr.gi"    );
 ReadLib( "morpheus.gi" );
 ReadLib( "grplatt.gi"  );
 ReadLib( "oprtglat.gi" );

tst/teststandard/bugfix.tst

@@ -10,6 +10,14 @@ gap> DeclareGlobalVariable("foo73");
 gap> InstallValue(foo73,true);
 Error, InstallValue: value cannot be immediate, boolean or character
 
+# Reported by Sohail Iqbal on 2008/10/15, added by AK on 2010/10/03
+gap> f:=FreeGroup("s","t");; s:=f.1;; t:=f.2;;
+gap> g:=f/[s^4,t^4,(s*t)^2,(s*t^3)^2];;
+gap> CharacterTable(g);
+CharacterTable( <fp group of size 16 on the generators [ s, t ]> )
+gap> Length(Irr(g));
+10
+
 ##  Check if ConvertToMatrixRepNC works properly. BH
 ##
 gap> mat := [[1,0,1,1],[0,1,1,1]]*One(GF(2));
@@ -1779,14 +1787,6 @@ gap> y:= [ [ Z(3)^0, 0*Z(3) ], [ 0*Z(3), Z(9) ] ];;
 gap> IsConjugate( G, x, y );
 true
 
-# Reported by Sohail Iqbal on 2008/10/15, added by AK on 2010/10/03
-gap> f:=FreeGroup("s","t");; s:=f.1;; t:=f.2;;
-gap> g:=f/[s^4,t^4,(s*t)^2,(s*t^3)^2];;
-gap> CharacterTable(g);
-CharacterTable( <fp group of size 16 on the generators [ s, t ]> )
-gap> Length(Irr(g));
-10
-
 # 2010/10/06 (TB)
 gap> EU(7,2);
 -1