Merge pull request #683 from hulpke/additions

Collection of enhancements.

Merge as tests succeeded.

grp/simple.gd

@@ -118,7 +118,7 @@ DeclareGlobalFunction("SimpleGroupsIterator");
 ##  <#/GAPDoc>
 DeclareGlobalFunction("ClassicalIsomorphismTypeFiniteSimpleGroup");
 
-DeclareAttribute("DataAboutSimpleGroup",IsGroup);
+DeclareAttribute("DataAboutSimpleGroup",IsGroup,"mutable");
 
 #############################################################################
 ##

lib/clashom.gi

@@ -1150,6 +1150,14 @@ local cs,	# chief series of G
 	  Thom:=Thom*ActionHomomorphism(T1,MovedPoints(T1),"surjective");
 	fi;
 	T1:=Image(Thom,T[1]);
+	if IsPermGroup(T1) and
+	  NrMovedPoints(T1)>SufficientlySmallDegreeSimpleGroupOrder(Size(T1)) then
+	  Thom:=Thom*SmallerDegreePermutationRepresentation(T1);
+	  Info(InfoHomClass,1,"reduced simple degree ",NrMovedPoints(T1),
+	    " ",NrMovedPoints(Image(Thom)));
+	  T1:=Image(Thom,T[1]);
+	fi;
+
 	autos:=List(GeneratorsOfGroup(S),
 		  i->GroupHomomorphismByImagesNC(T1,T1,GeneratorsOfGroup(T1),
 		    List(GeneratorsOfGroup(T1),

lib/grp.gd

@@ -4341,6 +4341,40 @@ DeclareGlobalFunction("Group_PseudoRandom");
 
 DeclareGlobalFunction("GroupEnumeratorByClosure");
 
+############################################################################
+##
+#O  LowIndexSubgroups( <G>, <index> )
+##
+##  <#GAPDoc Label="LowIndexSubgroups">
+##  <ManSection>
+##  <Oper Name="LowIndexSubgroups"
+##   Arg='G, index'/>
+##  <Oper Name="LowIndexSubgroups" Arg='G, index'/>
+##
+##  <Description>
+##  These operations computes representatives of the conjugacy classes of
+##  subgroups of the group <A>G</A> that 
+##  index less than or equal to
+##  <A>index</A>.
+##  <P/>
+##  For finitely presented groups this operation simply defaults to
+##  <C>LowIndexSubgroupsFpGroup</C>. In other cases, it uses repeated
+##  calculation of maximal subgroups.
+##  <P/>
+##  <Example><![CDATA[
+##  gap> g:=TransitiveGroup(18,950);;
+##  gap> l:=LowIndexSubgroups(g,20);;Collected(List(l,x->Index(g,x)));
+##  [ [ 1, 1 ], [ 2, 1 ], [ 5, 1 ], [ 6, 1 ], [ 10, 2 ], [ 12, 3 ], [ 15, 1 ], 
+##    [ 16, 2 ], [ 18, 1 ], [ 20, 9 ] ]
+##  ]]></Example>
+##  <P/>
+##  </Description>
+##  </ManSection>
+##  <#/GAPDoc>
+##
+DeclareOperation( "LowIndexSubgroups",
+    [ IsGroup, IsPosInt ] );
+
 #############################################################################
 ##
 #E

lib/grpfp.gi

@@ -3099,6 +3099,13 @@ InstallMethod(LowIndexSubgroupsFpGroup, "subgroups of full fp group",
   [IsSubgroupFpGroup and IsWholeFamily,IsSubgroupFpGroup,IsPosInt],0,
   DoLowIndexSubgroupsFpGroupViaIterator );
 
+InstallMethod(LowIndexSubgroups, "FpFroups, using LowIndexSubgroupsFpGroup",
+  true,
+  [IsSubgroupFpGroup,IsPosInt],
+  # rank higher than method for finit groups using maximal subgroups
+  SIZE_FLAGS(WITH_HIDDEN_IMPS_FLAGS(FLAGS_FILTER(IsGroup and IsFinite))),
+  LowIndexSubgroupsFpGroup );
+
 InstallOtherMethod(LowIndexSubgroupsFpGroup,
   "subgroups of full fp group, with exclusion list", IsFamFamXY,
   [IsSubgroupFpGroup and IsWholeFamily,IsSubgroupFpGroup,IsPosInt,IsList],0,

lib/grplatt.gi

@@ -2747,6 +2747,34 @@ local dom,n,t,map;
   return [map,t];
 end);
 
+BindGlobal("TomExtensionNames",function(r)
+local n,pool,ext,sz,lsz,t,f,i;
+  if IsBound(r.tomExtensions) then
+    return t.tomExtensions;
+  fi;
+  n:=r.tomName;
+  pool:=[n];
+  ext:=[];
+  sz:=fail;
+  for i in pool do
+    t:=TableOfMarks(i);
+    if t<>fail then
+      lsz:=Maximum(OrdersTom(t));
+      if sz=fail then sz:=lsz;fi;
+      if lsz>sz then
+	Add(ext,[lsz/sz,i{[Length(n)+2..Length(i)]}]);
+      fi;
+      for f in FusionsTom(t) do
+	if f[1]{[1..Minimum(Length(f[1]),Length(n))]}=n and not f[1] in pool then
+	  Add(pool,f[1]);
+	fi;
+      od;
+    fi;
+  od;
+  r!.tomExtensions:=ext;
+  return ext;
+end);
+
 InstallMethod(TomDataAlmostSimpleRecognition,"generic",true,
   [IsGroup],0,
 function(G)
@@ -2766,7 +2794,7 @@ local T,t,hom,inf,nam,i,aut;
   # simple group
   if Index(G,T)=1 then
     t:=TableOfMarks(nam);
-    if not HasUnderlyingGroup(t) then
+    if t=fail or not HasUnderlyingGroup(t) then
       Info(InfoLattice,2,"Table of marks has no group");
       return fail;
     fi;
@@ -2779,8 +2807,8 @@ local T,t,hom,inf,nam,i,aut;
     return [hom,t];
   fi;
 
-  #extension
-  inf:=Filtered(inf.allExtensions,i->i[1]=Index(G,T));
+  #extensions (as far as tom knows)
+  inf:=Filtered(TomExtensionNames(inf),i->i[1]=Index(G,T));
   for i in inf do
     t:=TableOfMarks(Concatenation(nam,".",i[2]));
     if t<>fail and HasUnderlyingGroup(t) then

lib/permdeco.gi

@@ -15,7 +15,11 @@ function( G )
 local   pcgs,r,hom,A,iso,p,i;
 
   r:=RadicalGroup(G);
-  hom:=NaturalHomomorphismByNormalSubgroup(G,r);
+  if Size(r)=1 then
+    hom:=IdentityMapping(G);
+  else
+    hom:=NaturalHomomorphismByNormalSubgroup(G,r);
+  fi;
 
   pcgs := TryPcgsPermGroup( G,r, false, false, true );
   if not IsPcgs( pcgs )  then

lib/stbcbckt.gi

@@ -2832,14 +2832,20 @@ end );
 ##
 #M  PartitionStabilizerPermGroup(<G>,<part>)
 ##
+##  This really should be a backtrack on its own
 InstallGlobalFunction( PartitionStabilizerPermGroup, function(G,part)
-local pl,i,p,W,op,S;
+local pl,single,i,p,W,op,S;
 
   # first separate the sets of different lengths
   pl:=Set(List(part,Length));
+  single:=[];
   for i in [1..Length(pl)] do
     pl[i]:=Filtered(part,j->Length(j)=pl[i]);
-    G:=Stabilizer(G,Set(Concatenation(pl[i])),OnSets);
+    Add(single,Set(Concatenation(pl[i])));
+  od;
+  SortBy(single,Length);
+  for i in single do
+    G:=Stabilizer(G,i,OnSets);
   od;
 
   # now pl is a list of lists of sets of the same length, sorted in

tst/teststandard/grplatt.tst

@@ -174,6 +174,19 @@ gap> Collected(List(NormalSubgroups(g),Size));
 [ [ 1, 1 ], [ 2, 1 ], [ 4, 3 ], [ 8, 7 ], [ 16, 15 ], [ 32, 27 ], [ 64, 55 ], 
   [ 128, 87 ], [ 256, 115 ], [ 512, 195 ], [ 1024, 267 ], [ 2048, 283 ], 
   [ 4096, 227 ], [ 8192, 155 ], [ 16384, 31 ], [ 32768, 1 ] ]
+gap> Length(MaximalSubgroupClassReps(PSL(5,11)));
+16
+gap> g:=Group(
+> [ (3,5,4)(7,8,9)(10,18,14)(11,20,17)(12,21,15)(13,19,16)(22,32,41)(24,36,
+>     29)(25,40,33)(26,28,37)(30,42,34)(31,35,39),
+>   (1,2,7,3,11,10,6)(4,15,20,21,13,18,9)(5,19,17,16,12,14,8)(22,34,39,40,29,
+>     32,28)(23,27,33,37,42,35,38)(24,26,36,30,31,25,41),
+>   (7,8,9)(10,14,18)(11,16,21)(12,17,19)(13,15,20)(22,28,29)(24,32,37)(25,40,
+>     33)(26,36,41)(31,39,35), (1,38)(2,23)(3,42)(4,34)(5,30)(6,27)(7,33)(8,
+>     40)(9,25)(10,35)(11,37)(12,36)(13,22)(14,39)(15,29)(16,32)(17,26)(18,
+>     31)(19,41)(20,28)(21,24) ]);;
+gap> Length(MaximalSubgroupClassReps(g));
+6
 
 # thats all, folks
 gap> STOP_TEST( "grplatt.tst", 413800000);