diff --git a/lib/grp.gd b/lib/grp.gd index 81e258b629..5f7da2c918 100644 --- a/lib/grp.gd +++ b/lib/grp.gd @@ -3287,6 +3287,45 @@ KeyDependentOperation( "SylowComplement", IsGroup, IsPosInt, "prime" ); KeyDependentOperation( "HallSubgroup", IsGroup, IsList, ReturnTrue ); +############################################################################# +## +#F NormalHallSubgroupsFromSylows( [, ] ) +## +## +## +## +## +## Computes all normal Hall subgroups, that is all normal subgroups +## N for which the size of N is relatively prime to the +## index of N in G. +## +## Sometimes it is not desirable to compute all normal Hall subgroups. The +## user can express such a wish by using the method "any". +## Then NormalHallSubgroupsFromSylows returns a nontrivial normal Hall +## subgroup, if there is one, and returns fail, otherwise. +## +## +## +DeclareGlobalFunction( "NormalHallSubgroupsFromSylows", [ IsGroup ] ); + + +############################################################################# +## +#A NormalHallSubgroups( ) +## +## +## +## +## +## Returns a list of all normal Hall subgroups, that is of all normal +## subgroups N for which the size of N is relatively prime +## to the index of N in G. +## +## +## +DeclareAttribute( "NormalHallSubgroups", IsGroup ); + + ############################################################################# ## #O NrConjugacyClassesInSupergroup( , ) diff --git a/lib/grp.gi b/lib/grp.gi index c9e687ca70..5114ec27d4 100644 --- a/lib/grp.gi +++ b/lib/grp.gi @@ -2813,6 +2813,127 @@ InstallMethod (HallSubgroupOp, "test trivial cases", true, end); +############################################################################# +## +#M NormalHallSubgroups( ) +## +InstallGlobalFunction( NormalHallSubgroupsFromSylows, function( arg ) + + local G, method, primes, edges, i, j, S, N, UpSets, part, U, NHs; + + if Length(arg) = 1 and IsGroup(arg[1]) then + G := arg[1]; + method := "all"; + elif Length(arg) = 2 and IsGroup(arg[1]) and arg[2] in ["all", "any"] then + G := arg[1]; + method := arg[2]; + else + Error("usage: NormalHallSubgroupsFromSylows( [, ] )"); + fi; + if HasNormalHallSubgroups(G) then + if method = "any" then + for N in NormalHallSubgroups(G) do + if not IsTrivial(N) and G<>N then + return N; + fi; + od; + return fail; + else + return NormalHallSubgroups(G); + fi; + elif method ="any" and Length(ComputedHallSubgroups(G))>0 then + i := 0; + while i < Length(ComputedHallSubgroups(G)) do + i := i+2; + N := ComputedHallSubgroups(G)[i]; + if N <> fail and IsNormal(G, N) then + return N; + fi; + od; + # no need to factor Size(G) if G is a p-group + elif IsTrivial(G) or IsPGroup(G) then + SetNormalHallSubgroups(G, Set([ TrivialSubgroup(G), G ])); + if method = "any" then + return fail; + else + return Set([ TrivialSubgroup(G), G ]); + fi; + ## ? might take a long time to check if G is simple ? + # simple groups have no nontrivial normal subgroups + elif IsSimpleGroup(G) then + SetNormalHallSubgroups(G, Set([ TrivialSubgroup(G), G ])); + if method = "any" then + return fail; + else + return Set([ TrivialSubgroup(G), G ]); + fi; + fi; + primes := PrimeDivisors(Size(G)); + edges := []; + S := []; + # create edges of directed graph + for i in [1..Length(primes)] do + # S[i] is the normal closure of the Sylow subgroup for primes[i] + if IsNilpotentGroup(G) then + S[i] := SylowSubgroup(G, primes[i]); + else + S[i] := NormalClosure(G, SylowSubgroup(G, primes[i])); + fi; + if IsNilpotentGroup(G) then + edges[i] := [i]; + else + edges[i] := []; + # factoring Size(S[i]) probably takes more time + for j in [1..Length(primes)] do + # i -> j is an edge if Size(S[i]) has prime divisor primes[j] + if Size(S[i]) mod primes[j] = 0 then + AddSet(edges[i], j); + fi; + od; + fi; + if method = "any" and edges[i] = [i] then + return S[i]; + fi; + od; + # compute the reachable points from every point of the digraph + # and then collapse same sets + # the relation defined by edges is already reflexive + UpSets := Set(Successors(TransitiveClosureBinaryRelation( + BinaryRelationOnPoints(edges)))); + NHs := [ TrivialSubgroup(G), G ]; + for part in IteratorOfCombinations(UpSets) do + U := Union(part); + # trivial subgroup and G should not be added again + if U <> [] and U <> [1..Length(primes)] then + N := TrivialSubgroup(G); + for i in Union(part) do + N := ClosureGroup(N, S[i]); + od; + if method = "any" then + return N; + else + AddSet(NHs, N); + fi; + fi; + od; + if method = "any" then + SetNormalHallSubgroups(G, Set([ TrivialSubgroup(G), G ])); + return fail; + else + SetNormalHallSubgroups(G, NHs); + return NHs; + fi; +end); + +InstallMethod( NormalHallSubgroups, + "by normal closure of Sylow subgroups", true, + [ IsGroup and CanComputeSizeAnySubgroup and IsFinite ], 0, + + function( G ) + return NormalHallSubgroupsFromSylows(G, "all"); + end ); + + ############################################################################ ## #M SylowComplementOp (,

) diff --git a/tst/testinstall/opers/NormalHallSubgroups.tst b/tst/testinstall/opers/NormalHallSubgroups.tst new file mode 100644 index 0000000000..6a81908bf1 --- /dev/null +++ b/tst/testinstall/opers/NormalHallSubgroups.tst @@ -0,0 +1,78 @@ +gap> START_TEST("NormalHallSubgroups.tst"); +gap> for G in AllGroups(60) do Print(List(NormalHallSubgroups(G), IdGroup), "\n"); od; +[ [ 1, 1 ], [ 5, 1 ], [ 3, 1 ], [ 15, 1 ], [ 12, 1 ], [ 60, 1 ] ] +[ [ 1, 1 ], [ 3, 1 ], [ 5, 1 ], [ 15, 1 ], [ 20, 1 ], [ 60, 2 ] ] +[ [ 1, 1 ], [ 3, 1 ], [ 5, 1 ], [ 15, 1 ], [ 60, 3 ] ] +[ [ 1, 1 ], [ 3, 1 ], [ 5, 1 ], [ 15, 1 ], [ 4, 1 ], [ 12, 2 ], [ 20, 2 ], + [ 60, 4 ] ] +[ [ 1, 1 ], [ 60, 5 ] ] +[ [ 1, 1 ], [ 3, 1 ], [ 5, 1 ], [ 15, 1 ], [ 20, 3 ], [ 60, 6 ] ] +[ [ 1, 1 ], [ 3, 1 ], [ 5, 1 ], [ 15, 1 ], [ 60, 7 ] ] +[ [ 1, 1 ], [ 3, 1 ], [ 5, 1 ], [ 15, 1 ], [ 60, 8 ] ] +[ [ 1, 1 ], [ 5, 1 ], [ 4, 2 ], [ 12, 3 ], [ 20, 5 ], [ 60, 9 ] ] +[ [ 1, 1 ], [ 3, 1 ], [ 5, 1 ], [ 20, 4 ], [ 15, 1 ], [ 60, 10 ] ] +[ [ 1, 1 ], [ 5, 1 ], [ 3, 1 ], [ 12, 4 ], [ 15, 1 ], [ 60, 11 ] ] +[ [ 1, 1 ], [ 3, 1 ], [ 5, 1 ], [ 15, 1 ], [ 60, 12 ] ] +[ [ 1, 1 ], [ 4, 2 ], [ 3, 1 ], [ 12, 5 ], [ 5, 1 ], [ 20, 5 ], [ 15, 1 ], + [ 60, 13 ] ] +gap> for G in AllGroups(60) do primes := PrimeDivisors(Size(G)); l := []; for pi in IteratorOfCombinations(primes) do N := HallSubgroup(G, pi); if N<>fail and IsGroup(N) and IsNormal(G, N) then AddSet(l, N); fi; od; if l <> NormalHallSubgroups(G) then Print(IdGroup(G), "\n"); fi; od; +gap> List(AllSmallGroups(168), G -> List(NormalHallSubgroups(G), Size)); +[ [ 1, 7, 21, 56, 168 ], [ 1, 8, 7, 21, 56, 168 ], [ 1, 7, 3, 21, 24, 168 ], + [ 1, 3, 7, 21, 56, 168 ], [ 1, 3, 7, 21, 168 ], + [ 1, 3, 7, 21, 8, 24, 56, 168 ], [ 1, 7, 21, 56, 168 ], + [ 1, 7, 21, 56, 168 ], [ 1, 7, 21, 56, 168 ], [ 1, 7, 21, 56, 168 ], + [ 1, 7, 21, 56, 168 ], [ 1, 3, 7, 21, 168 ], [ 1, 3, 7, 21, 168 ], + [ 1, 3, 7, 21, 168 ], [ 1, 3, 7, 21, 168 ], [ 1, 3, 7, 21, 168 ], + [ 1, 3, 7, 21, 168 ], [ 1, 3, 7, 21, 168 ], [ 1, 8, 7, 21, 56, 168 ], + [ 1, 8, 7, 21, 56, 168 ], [ 1, 8, 7, 21, 56, 168 ], + [ 1, 7, 8, 24, 56, 168 ], [ 1, 7, 8, 56, 168 ], [ 1, 3, 7, 21, 56, 168 ], + [ 1, 3, 7, 21, 56, 168 ], [ 1, 3, 7, 21, 56, 168 ], + [ 1, 3, 7, 21, 56, 168 ], [ 1, 3, 7, 21, 56, 168 ], + [ 1, 7, 3, 21, 24, 168 ], [ 1, 7, 3, 21, 24, 168 ], + [ 1, 7, 3, 21, 24, 168 ], [ 1, 7, 3, 21, 24, 168 ], + [ 1, 7, 3, 21, 24, 168 ], [ 1, 3, 7, 21, 168 ], [ 1, 3, 7, 21, 168 ], + [ 1, 3, 7, 21, 168 ], [ 1, 3, 7, 21, 168 ], [ 1, 3, 7, 21, 168 ], + [ 1, 3, 7, 21, 8, 24, 56, 168 ], [ 1, 3, 7, 21, 8, 24, 56, 168 ], + [ 1, 3, 7, 21, 8, 24, 56, 168 ], [ 1, 168 ], [ 1, 8, 56, 168 ], + [ 1, 3, 8, 24, 56, 168 ], [ 1, 7, 24, 168 ], [ 1, 7, 168 ], + [ 1, 7, 56, 21, 168 ], [ 1, 7, 56, 168 ], [ 1, 7, 56, 168 ], + [ 1, 3, 7, 21, 168 ], [ 1, 8, 7, 56, 21, 168 ], [ 1, 7, 8, 24, 56, 168 ], + [ 1, 8, 7, 56, 168 ], [ 1, 3, 7, 56, 21, 168 ], [ 1, 7, 3, 24, 21, 168 ], + [ 1, 3, 7, 21, 168 ], [ 1, 8, 3, 24, 7, 56, 21, 168 ] ] +gap> for G in AllGroups(168) do primes := PrimeDivisors(Size(G)); l := []; for pi in IteratorOfCombinations(primes) do N := HallSubgroup(G, pi); if N<>fail and IsGroup(N) and IsNormal(G, N) then AddSet(l, N); fi; od; if l <> NormalHallSubgroups(G) then Print(IdGroup(G), "\n"); fi; od; +gap> List(AllPrimitiveGroups(DegreeAction, 8), G -> List(NormalHallSubgroups(G), Size)); +[ [ 1, 56, 8 ], [ 1, 168, 56, 8 ], [ 1, 1344 ], [ 1, 168 ], [ 1, 336 ], + [ 1, 20160 ], [ 1, 40320 ] ] +gap> List(NormalHallSubgroups(PrimitiveGroup(8,2)), Size); +[ 1, 168, 56, 8 ] +gap> Positions(List(AllTransitiveGroups(DegreeAction, 6), G -> NormalHallSubgroupsFromSylows(G, "any")), fail); +[ 7, 8, 11, 12, 14, 15, 16 ] +gap> N := PSL(2,32);; aut := SylowSubgroup(AutomorphismGroup(N),5);; +gap> G := SemidirectProduct(aut, N);; +gap> Size(NormalHallSubgroupsFromSylows(G, "any")); +32736 +gap> A4 := AlternatingGroup(4);; +gap> HallSubgroup(A4, [2])=Group((1,2)(3,4),(1,3)(2,4)); +true +gap> HallSubgroup(A4, [3]);; Length(ComputedHallSubgroups(A4)); +4 +gap> NormalHallSubgroupsFromSylows(A4, "any")=Group((1,2)(3,4),(1,3)(2,4)); +true +gap> D := DihedralGroup(8);; NormalHallSubgroupsFromSylows(D, "any"); +fail +gap> HasNormalHallSubgroups(D); +true +gap> NormalHallSubgroupsFromSylows(D)=[TrivialSubgroup(D), D]; +true +gap> NormalHallSubgroupsFromSylows(D, "any"); +fail +gap> D := DihedralGroup(12);; +gap> List(NormalHallSubgroups(D), Size); +[ 1, 3, 12 ] +gap> Size(NormalHallSubgroupsFromSylows(D, "any")); +3 +gap> NormalHallSubgroupsFromSylows(Group(()), "any"); +fail +gap> Length(NormalHallSubgroups(Group(()))); +1 +gap> STOP_TEST("NormalHallSubgroups.tst", 10000);