Normalisers of simple groups

lib/gpprmsya.gd

@@ -159,6 +159,30 @@ DeclareAttribute("OrbitStabilizingParentGroup",IsPermGroup);
 
 DeclareGlobalFunction("NormalizerParentSA");
 
+#############################################################################
+##
+#F NormalizerOfSimpleGroupInSymmetricGroup( <T>, [,<aut>]) )
+##
+## <ManSection>
+## <Func Name="NormalizerOfSimpleGroupInSymmetricGroup" Arg='T [,aut]'/>
+##
+## <Description>
+## Let <C>G</C> be the symmetric group on the moved points of <A>T</A>.
+## For a non-abelian finite simple group <A>T</A>, this function returns the
+## normalizer of <A>T</A> in <C>G</C>.
+## To this end it determines which elements of the outer automorphism group of
+## <A>T</A> can be induced by conjugation with elements of <C>G</C>.<P/>
+##
+## The optional argument <A>aut</A>, must be the automorphism group of
+## <A>T</A>. If <A>aut</A> is not given and <A>T</A> does not know its
+## automorphism group, then computing its automorphism group might be very
+## slow. Note that it is not checked whether <A>aut</A> is indeed
+## the automorphism group of <A>T</A>.<P/>
+##
+## The generating set for the normalizer might be big. Thus calling
+## <Ref Attr="SmallGeneratingSet"/> on the result might be sensible.
+##
+DeclareGlobalName("NormalizerOfSimpleGroupInSymmetricGroup");
 #############################################################################
 ##
 #F  MaximalSubgroupsSymmAlt( <grp> [,<onlyprimitive>] )

lib/gpprmsya.gi

@@ -1418,6 +1418,49 @@ local P;
   fi;
 end);
 
+
+BindGlobal( "NormalizerOfSimpleGroupInSymmetricGroup",
+function( T, aut... )
+    local centraliser, out_reps, rep, lifts;
+    if IsAbelian( T ) then 
+        ErrorNoReturn("<T> must be a non-abelian group");
+    elif Length( aut ) = 1 then
+        aut := aut[ 1 ];
+    elif Length( aut ) > 1 then
+        ErrorNoReturn( "Usage: ",
+        "RepresentativesOuterAutomorphismGroup(T,",
+        "[aut, [,ordercenter]]);" );
+    fi;
+    #T is a non-abelian simple group, so |Z(T)|=1
+    if Length( aut ) = 0 then
+      out_reps := RepresentativesOuterAutomorphismGroup( T );
+    else
+      out_reps := RepresentativesOuterAutomorphismGroup(
+         T, aut, 1 );
+    fi;
+    lifts := [ ];
+    #TODO: Only add lifts that are not already contained in the
+    #already found partial normaliser.
+    for rep in out_reps do
+        if IsConjugatorAutomorphism( rep ) then
+            Add( lifts, ConjugatorOfConjugatorIsomorphism( rep ) );
+        fi;
+    od;
+    # TODO: Info
+    Print("#I: Computed all lifts.\n");
+    if IsPrimitive( T ) then
+        centraliser := TrivialGroup( IsPermGroup );
+    else
+        #TODO: Warning: Undocumented function. Maybe from Serres: Thm 6.1.6?
+        centraliser := CentralizerTransSymmCSPG(T, StabChainMutable(T));
+    fi;
+    return Group( Concatenation(
+        GeneratorsOfGroup( T ),
+        GeneratorsOfGroup( centraliser ),
+        lifts
+    ) );
+end);
+DeclareSynonym("NormaliserOfSimpleGroupInSymmetricGroup", NormalizerOfSimpleGroupInSymmetricGroup);
 InstallMethod( NormalizerOp, "subgp of natural symmetric group",
     IsIdenticalObj, [ IsNaturalSymmetricGroup, IsPermGroup ], 0,
     DoNormalizerSA);

lib/morpheus.gd

@@ -586,3 +586,32 @@ DeclareOperation("GQuotients",[IsGroup,IsGroup]);
 DeclareOperation("IsomorphicSubgroups",[IsGroup,IsGroup]);
 
 DeclareGlobalFunction("PatheticIsomorphism");
+
+############################################################################
+##
+#F RepresentativesOuterAutomorphismGroup(<G>, [,<aut>])
+##
+## <#GAPDoc Label="RepresentativesOuterAutomorphismGroup">
+## <ManSection>
+## <Func Name="RepresentativesOuterAutomorphismGroup" 
+## Arg='G, [,aut [, ordercenter]]'\>
+## 
+## <Description>
+## For a finite group <A>G</A> this function returns a sorted list which
+## contains one representative for each element of the outer automorphism
+## group of <A>G</A>.<P/>
+##
+## This function performs a random search in the automorphism group of <A>G</A>
+## and thus currently is only efficient if the outer automorphism group is very
+## small.<P/>
+##
+## The optional argument <A>aut</A> must be the automorphism group of <A>G</A>.
+## Note that it is not checked whether <A>aut</A> is indeed the automorphism
+## group of <A>G</A>.<P/>
+##
+## The optional argument <A>ordercenter</A> must be the order of the center of
+## <A>G</A>.
+## /Description>
+## </ManSection>
+## <#/GAPDoc>
+DeclareGlobalName("RepresentativesOuterAutomorphismGroup");

lib/morpheus.gi

@@ -3005,3 +3005,41 @@ local cl,cnt,bg,bw,bo,bi,k,gens,go,imgs,params,emb,clg,sg,vsu,c,i;
   Info(InfoMorph,1,Length(emb)," found -> ",Length(cl)," homs");
   return cl;
 end);
+
+# For a discussion on how to improve this function, see
+# https://github.com/gap-system/gap/pull/4100
+BindGlobal("RepresentativesOuterAutomorphismGroup", 
+function(G, args...)
+  local aut, order_out, out_reps, candidate, rep, i, ordercenter;
+  if Length(args) = 1 then
+    aut := args[1];
+  elif Length(args) = 0 then
+    aut := AutomorphismGroup(G);
+  elif Length(args) = 2 then
+    aut := args[1];
+    ordercenter := args[2];
+  else 
+    ErrorNoReturn("Usage: ",
+    "RepresentativesOuterAutomorphismGroup(G[, aut[, ordercenter]]);");
+  fi;
+  if not IsBound(ordercenter) then 
+    ordercenter := Size(Center(G));
+  fi;
+  if not HasSize(aut) then 
+    Print("#I: RepresentativesOuterAutomorphismGroup: Don't know the order of <aut>. Computing the order", 
+    " might be slow.\n");
+  fi;
+  # We have |Inn(G)| = |G/Z(G)|
+  order_out := Size(aut) / (Size(G) / ordercenter); 
+  out_reps := [ One(aut) ];
+  while Size(out_reps) < order_out do
+    candidate := PseudoRandom(aut);
+    for i in [ 1 .. Length(out_reps) ] do       
+      rep := out_reps[ i ];
+      if not IsInnerAutomorphism(candidate / rep) then 
+        AddSet(out_reps, candidate);
+      fi;
+    od;
+  od;
+  return out_reps;
+end);

tst/testinstall/grpperm.tst

@@ -94,4 +94,15 @@ gap> Index(sym,b);
 3603600
 gap> Length(ContainedConjugates(sym,a,b));
 5
+
+# NormalizerOfSimpleGroupInSymmetricGroup
+gap> NormalizerOfSimpleGroupInSymmetricGroup( AlternatingGroup(5)) = Normaliser( SymmetricGroup(5), AlternatingGroup(5));
+#I: Computed all lifts.
+true
+gap> NormalizerOfSimpleGroupInSymmetricGroup( PSL(2,7)) = Normaliser( SymmetricGroup(8), PSL(2,7));
+#I: Computed all lifts.
+true
+gap> NormalizerOfSimpleGroupInSymmetricGroup( PSU(3,3)) = Normalizer( SymmetricGroup(91), PSU(3,3));
+#I: Computed all lifts.
+true
 gap> STOP_TEST( "grpperm.tst", 1);

tst/testinstall/morpheus.tst

@@ -58,6 +58,18 @@ G (size 6)
 S (1 gens, size 3)
  | Z(3)
 1 (size 1)
+gap> Size(RepresentativesOuterAutomorphismGroup( CyclicGroup(5))) = 4;
+#I: RepresentativesOuterAutomorphismGroup: Don't know the order of <aut>. Comp\
+uting the order might be slow.
+true
+gap> Size(RepresentativesOuterAutomorphismGroup( CyclicGroup(5), AutomorphismGroup(CyclicGroup(5)))) = 4;
+#I: RepresentativesOuterAutomorphismGroup: Don't know the order of <aut>. Comp\
+uting the order might be slow.
+true
+gap> Size(RepresentativesOuterAutomorphismGroup( CyclicGroup(5), AutomorphismGroup(CyclicGroup(5)),5)) = 4;
+#I: RepresentativesOuterAutomorphismGroup: Don't know the order of <aut>. Comp\
+uting the order might be slow.
+true
 
 # that's all, folks
 gap> STOP_TEST( "morpheus.tst", 1);