New Functionality: Cannon/Holt automorphisms and others

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