Performance additions to generic 2-cohomology and Automorphism group/Isomorphism test

lib/csetgrp.gi

@@ -330,16 +330,29 @@ local o,b,img,G1,c,m,mt,hardlimit,gens,t,k,intersize;
     return fail;
   fi;
 
-  # old code -- obsolete
-
   c:=ValueOption("refineChainActionLimit");
   if IsInt(c) then
     hardlimit:=c;
   else
     hardlimit:=1000000;
   fi;
 
-  if Index(G,U)>hardlimit then return fail;fi;
+  if Index(G,U)>hardlimit/10
+   and ValueOption("callinintermediategroup")<>true then
+    # try the `AscendingChain` mechanism
+    c:=AscendingChain(G,U:cheap,refineIndex:=QuoInt(IndexNC(G,U),2),
+      callinintermediategroup);
+    if Length(c)>2 then
+      return First(c,x->Size(x)>Size(U));
+    fi;
+  fi;
+
+  if Index(G,U)>hardlimit then 
+    Info(InfoWarning,1,
+      "will have to use permutation action of degree bigger than ", hardlimit);
+  fi;
+
+  # old code -- obsolete
 
   if IsPermGroup(G) and Length(GeneratorsOfGroup(G))>3 then
     G1:=Group(SmallGeneratingSet(G));

lib/gpfpiso.gi

@@ -1124,7 +1124,6 @@ local iso,fp,n,dec,homs,mos,i,j,ffp,imo,m,k,gens,fm,mgens,rules,
 
     reduce:=function(w)
     local red,i,p,pool,wn;
-#ow:=w;
       w:=LetterRepAssocWord(w);
       repeat
         i:=1;
@@ -1288,7 +1287,7 @@ end);
 
 # special method for pc groups, basically just writing down the pc
 # presentation
-InstallMethod(ConfluentMonoidPresentationForGroup,"generic",
+InstallMethod(ConfluentMonoidPresentationForGroup,"pc",
   [IsGroup and IsFinite and IsPcGroup],
 function(G)
 local pcgs,iso,fp,i,j,gens,numi,ord,fm,fam,mword,k,r,addrule,a,e,m;

lib/grp.gd

@@ -1035,20 +1035,26 @@ DeclareAttribute( "CommutatorFactorGroup", IsGroup );
 #############################################################################
 ##
 #A  CompositionSeries( <G> )
+#A  CompositionSeriesThrough( <G>, <normals> )
 ##
 ##  <#GAPDoc Label="CompositionSeries">
 ##  <ManSection>
 ##  <Attr Name="CompositionSeries" Arg='G'/>
+##  <Oper Name="CompositionSeriesThrough" Arg='G, normals'/>
 ##
 ##  <Description>
 ##  A composition series is a subnormal series which cannot be refined.
 ##  This attribute returns <E>one</E> composition series (of potentially many
-##  possibilities).
+##  possibilities). The variant <Ref Oper="CompositionSeriesThrough"/> takes
+##  as second argument a list <A>normals</A> of normal subgroups of the
+##  group, and returns a composition series that incorporates these normal
+##  subgroups.
 ##  </Description>
 ##  </ManSection>
 ##  <#/GAPDoc>
 ##
 DeclareAttribute( "CompositionSeries", IsGroup );
+DeclareOperation( "CompositionSeriesThrough", [IsGroup,IsList] );
 #T and for module?
 
 

lib/grp.gi

@@ -939,6 +939,64 @@ InstallMethod( CompositionSeries,
     "for simple group", true, [IsGroup and IsSimpleGroup], 100,
     S->[S,TrivialSubgroup(S)]);
 
+InstallMethod(CompositionSeriesThrough,"intersection/union",IsElmsColls,
+  [IsGroup and IsFinite,IsList],0,
+function(G,normals)
+local cs,i,j,pre,post,c,new,rev;
+  cs:=CompositionSeries(G);
+  # find normal subgroups not yet in
+  normals:=Filtered(normals,x->not x in cs);
+  # do we satisfy by sheer dumb luck?
+  if Length(normals)=0 then return cs;fi;
+
+  SortBy(normals,x->-Size(x));
+  # check that this is a valid series
+  Assert(0,ForAll([2..Length(normals)],i->IsSubset(normals[i-1],normals[i])));
+
+  # Now move series through normals by closure/intersection
+  for j in normals do
+    # first in cs that does not contain j
+    pre:=PositionProperty(cs,x->not IsSubset(x,j));
+    # first contained in j. 
+    post:=PositionProperty(cs,x->Size(j)>=Size(x) and IsSubset(j,x));
+
+    # if j is in the series, then pre>post. pre=post impossible
+    if pre<post then
+      # so from pre to post-1 needs to be changed
+      new:=cs{[1..pre-1]};
+
+      rev:=[j];
+      i:=post-1;
+      repeat
+        if not IsSubset(rev[Length(rev)],cs[i]) then
+          c:=ClosureGroup(cs[i],j);
+          if Size(c)>Size(rev[Length(rev)]) then
+            # proper down step
+            Add(rev,c);
+          fi;
+        fi;
+        i:=i-1;
+        # at some point this must reach j, then no further step needed
+      until Size(c)=Size(cs[pre-1]) or i<pre; 
+      Append(new,Filtered(Reversed(rev),x->Size(x)<Size(cs[pre-1])));
+
+      i:=pre;
+      repeat
+        if not IsSubset(cs[i],new[Length(new)]) then
+          c:=Intersection(cs[i],j);
+          if Size(c)<Size(new[Length(new)]) then
+            # proper down step
+            Add(new,c);
+          fi;
+        fi;
+        i:=i+1;
+      until Size(c)=Size(cs[post]);
+    fi;
+    cs:=Concatenation(new,cs{[post+1..Length(cs)]});
+  od;
+  return cs;
+end);
+
 
 #############################################################################
 ##

lib/grplatt.gd

@@ -449,21 +449,29 @@ DeclareGlobalFunction("LowLayerSubgroups");
 
 #############################################################################
 ##
-#O  ContainedConjugates(<G>,<A>,<B>)
+#O  ContainedConjugates(<G>,<A>,<B>[,<onlyone>])
 ##
 ##  <#GAPDoc Label="ContainedConjugates">
 ##  <ManSection>
-##  <Oper Name="ContainedConjugates" Arg='G, A, B'/>
+##  <Oper Name="ContainedConjugates" Arg='G, A, B [,onlyone]'/>
 ##
 ##  <Description>
 ##  For <M>A,B \leq G</M> this operation returns representatives of the <A>A</A>
 ##  conjugacy classes of subgroups that are conjugate to <A>B</A> under <A>G</A>.
 ##  The function returns a list of pairs of subgroup and conjugating element.
+##  If the optional fourth argument <A>onlyone</A> is given as <A>true</A>,
+##  then only one pair (or <A>fail</A> if none exists) is returned.
 ##  <Example><![CDATA[
 ##  gap> g:=SymmetricGroup(8);;
-##  gap> a:=TransitiveGroup(8,47);;b:=TransitiveGroup(8,7);;
+##  gap> a:=TransitiveGroup(8,47);;b:=TransitiveGroup(8,9);;
 ##  gap> ContainedConjugates(g,a,b);
-##  [ [ Group([ (1,4,2,5,3,6,8,7), (1,3)(2,8) ]), (2,4,5,3)(7,8) ] ]
+##  [ [ Group([ (1,8)(2,3)(4,5)(6,7), (1,3)(2,8)(4,6)(5,7), (1,5)(2,6)(3,7)(4,8),
+##          (4,5)(6,7) ]), () ],
+##    [ Group([ (1,8)(2,3)(4,5)(6,7), (1,5)(2,6)(3,7)(4,8), (1,3)(2,8)(4,6)(5,7),
+##          (2,3)(6,7) ]), (2,4)(3,5) ] ]
+##  gap> ContainedConjugates(g,a,b,true);
+##  [ Group([ (1,8)(2,3)(4,5)(6,7), (1,3)(2,8)(4,6)(5,7), (1,5)(2,6)(3,7)(4,8),
+##      (4,5)(6,7) ]), () ]
 ##  ]]></Example>
 ##  </Description>
 ##  </ManSection>

lib/grplatt.gi

@@ -3187,21 +3187,22 @@ local act,offset,G,lim,cond,dosub,all,m,i,j,new,old;
   return all;
 end);
 
-#############################################################################
-##
-#F  ContainedConjugates( <G>, <A>, <B> )
-##
-InstallMethod(ContainedConjugates,"finite groups",IsFamFamFam,[IsGroup,IsGroup,IsGroup],0,
-function(G,A,B)
-local l,N,dc,gens,i;
+DoContainedConjugates:=function(arg)
+local G,A,B,onlyone,l,N,dc,gens,i;
+  G:=arg[1];
+  A:=arg[2];
+  B:=arg[3];
+  if Length(arg)>3 then onlyone:=arg[4]; else onlyone:=false;fi;
+
   if not IsFinite(G) and IsFinite(A) and IsFinite(B) then
      TryNextMethod();
   fi;
   if not IsSubset(G,A) and IsSubset(G,B) then
     Error("A and B must be subgroups of G");
   fi;
   if Size(A) mod Size(B)<>0 then
-    return []; # cannot be contained by order
+    # cannot be contained by order
+    if onlyone then return fail;else return [];fi;
   fi;
 
   l:=[];
@@ -3211,15 +3212,30 @@ local l,N,dc,gens,i;
     gens:=SmallGeneratingSet(B);
     for i in dc do
       if ForAll(gens,x->x^i[1] in A) then
+        if onlyone then return [B^i[1],i[1]];fi;
         Add(l,[B^i[1],i[1]]);
       fi;
     od;
+    if onlyone then return fail;fi;
     return l;
+  elif onlyone then
+    l:=DoConjugateInto(G,A,B,true);
+    if IsIdenticalObj(FamilyObj(l),FamilyObj(One(G))) then return [B^l,l];
+    else return fail;fi;
   else
     l:=DoConjugateInto(G,A,B,false);
     return List(l,x->[B^x,x]);
   fi;
-end);
+end;
+
+#############################################################################
+##
+#F  ContainedConjugates( <G>, <A>, <B> )
+##
+InstallMethod(ContainedConjugates,"finite groups",IsFamFamFam,
+  [IsGroup,IsGroup,IsGroup],0,DoContainedConjugates);
+InstallOtherMethod(ContainedConjugates,"onlyone",IsFamFamFamX,
+  [IsGroup,IsGroup,IsGroup,IsBool],0,DoContainedConjugates);
 
 #############################################################################
 ##

lib/morpheus.gi

@@ -2675,7 +2675,8 @@ local m;
       # the group is a good part
       # sizeable radical
       or Size(RadicalGroup(G))^2>Size(G)
-      or ValueOption("forcetest")=true) then
+      or ValueOption("forcetest")=true) and 
+      ValueOption("forcetest")<>"old" then
     # In place until a proper implementation of Cannon/Holt isomorphism is
     # done
     return PatheticIsomorphism(G,H);