Add IsRegularPGroup

Unfortunately I am not aware of an efficient algorithm for this
in general. But the provided one at least performs reasonably for e.g.
the groups of order 3^7.

doc/manualbib.xml

@@ -2233,6 +2233,34 @@
  <other type="pages">225</other>
 </book></entry>
 
+<entry id="Hal34"><article>
+ <author>
+ <name><first>Philip</first><last>Hall</last></name>
+ </author>
+ <title>A contribution to the theory of groups of prime-power order</title>
+ <journal>Proceedings of the London Mathematical Society</journal>
+ <year>1934</year>
+ <volume>s2-36</volume>
+ <number>1</number>
+ <pages>29&ndash;95</pages>
+ <url>https://doi.org/10.1112/plms/s2-36.1.29</url>
+ <other type="doi">10.1112/plms/s2-36.1.29</other>
+</article></entry>
+
+<entry id="Hal36"><article>
+ <author>
+ <name><first>Philip</first><last>Hall</last></name>
+ </author>
+ <title>On a Theorem of Frobenius</title>
+ <journal>Proceedings of the London Mathematical Society</journal>
+ <year>1936</year>
+ <volume>s2-40</volume>
+ <number>1</number>
+ <pages>468&ndash;501</pages>
+ <url>https://doi.org/10.1112/plms/s2-40.1.468</url>
+ <other type="doi">10.1112/plms/s2-40.1.468</other>
+</article></entry>
+
 <entry id="Hal36"><article>
  <author>
  <name><first>Philip</first><last>Hall</last></name>

doc/ref/groups.xml

@@ -351,6 +351,7 @@ as they depend on a parameter.
 <#Include Label="IsSubsetLocallyFiniteGroup">
 <#Include Label="IsPGroup">
 <#Include Label="IsPowerfulPGroup">
+<#Include Label="IsRegularPGroup">
 <#Include Label="PrimePGroup">
 <#Include Label="PClassPGroup">
 <#Include Label="RankPGroup">

lib/grp.gd

@@ -439,11 +439,8 @@ DeclareOperation( "KnowsHowToDecompose", [ IsGroup, IsList ] );
 DeclareProperty( "IsPGroup", IsGroup );
 InstallTrueMethod( IsGroup, IsPGroup );
 
-InstallSubsetMaintenance( IsPGroup,
- IsGroup and IsPGroup, IsGroup );
-
-InstallFactorMaintenance( IsPGroup,
- IsGroup and IsPGroup, IsObject, IsGroup );
+InstallSubsetMaintenance( IsPGroup, IsPGroup, IsGroup );
+InstallFactorMaintenance( IsPGroup, IsPGroup, IsObject, IsGroup );
 
 InstallTrueMethod( IsPGroup, IsGroup and IsTrivial );
 InstallTrueMethod( IsPGroup, IsGroup and IsElementaryAbelian );
@@ -458,7 +455,7 @@ InstallTrueMethod( IsPGroup, IsGroup and IsElementaryAbelian );
 ##
 ## <Description>
 ## <Index Key="PowerfulPGroup">Powerful <M>p</M>-group</Index>
-## A finite p-group <A>G</A> is said to be a <E>powerful <M>p</M>-group</E>
+## A finite <M>p</M>-group <A>G</A> is said to be a <E>powerful <M>p</M>-group</E>
 ## if the commutator subgroup <M>[<A>G</A>,<A>G</A>]</M> is contained in
 ## <M><A>G</A>^{p}</M> if the prime <M>p</M> is odd, or if
 ## <M>[<A>G</A>,<A>G</A>]</M> is contained in <M><A>G</A>^{4}</M>
@@ -475,12 +472,42 @@ InstallTrueMethod( IsPGroup, IsGroup and IsElementaryAbelian );
 DeclareProperty( "IsPowerfulPGroup", IsGroup );
 InstallTrueMethod( IsPGroup, IsPowerfulPGroup );
 
-#Quotients of powerful of powerful p groups are powerful
+#Quotients of powerful p-groups are powerful
 InstallFactorMaintenance( IsPowerfulPGroup,
  IsPowerfulPGroup, IsGroup, IsGroup );
 #abelian p-groups are powerful
 InstallTrueMethod( IsPowerfulPGroup, IsFinite and IsPGroup and IsAbelian );
-InstallTrueMethod( IsPGroup, IsPowerfulPGroup );
+
+#############################################################################
+##
+#P IsRegularPGroup( <G> ) . . . . . . . . . . is a group a regular p-group ?
+##
+## <#GAPDoc Label="IsRegularPGroup">
+## <ManSection>
+## <Prop Name="IsRegularPGroup" Arg='G'/>
+##
+## <Description>
+## <Index Key="RegularPGroup">Regular <M>p</M>-group</Index>
+## A finite <M>p</M>-group <A>G</A> is said to be a <E>regular <M>p</M>-group</E>
+## if for all <M>a,b</M> in <A>G</A>, one has <M>a^p b^p = (ab^p) c^p</M>
+## where <M>c</M> is an element of the derived subgroup of the group generated
+## by <M>a</M> and <M>b</M> (see&nbsp;<Cite Key="Hal34"/>).
+## <Ref Prop="IsRegularPGroup"/> returns <K>true</K> if <A>G</A> is a
+## regular <M>p</M>-group, and <K>false</K> otherwise.
+## <E>Note: </E>This function returns <K>true</K> if <A>G</A> is the trivial
+## group.
+## </Description>
+## </ManSection>
+## <#/GAPDoc>
+##
+DeclareProperty( "IsRegularPGroup", IsGroup );
+InstallTrueMethod( IsPGroup, IsRegularPGroup );
+
+InstallSubsetMaintenance( IsRegularPGroup, IsRegularPGroup, IsGroup );
+InstallFactorMaintenance( IsPGroup, IsRegularPGroup, IsObject, IsGroup );
+
+#abelian p-groups are regular
+InstallTrueMethod( IsRegularPGroup, IsFinite and IsPGroup and IsAbelian );
 
 #############################################################################
 ##

lib/grp.gi

@@ -428,6 +428,93 @@ InstallMethod( IsPowerfulPGroup,
  end);
 
 
+#############################################################################
+##
+#M IsRegularPGroup( <G> ) . . . . . . . . . . is a group a regular p-group ?
+##
+InstallMethod( IsRegularPGroup,
+ [ IsGroup ],
+function( G )
+local p, hom, reps, a, b, ap_bp, ab_p, H;
+
+ if not IsPGroup(G) then
+ return false;
+ fi;
+
+ p:=PrimePGroup(G);
+ if p = 2 then
+ # see [Hup67, Satz 10.3 a)]
+ return IsAbelian(G);
+ elif p = 3 and DerivedLength(G) > 2 then
+ # see [Hup67, Satz 10.3 b)]
+ return false;
+ elif Size(G) <= p^p then
+ # see [Hal34, Corollary 14.14], [Hall, p. 183], [Hup67, Satz 10.2 b)]
+ return true;
+ elif NilpotencyClassOfGroup(G) < p then
+ # see [Hal34, Corollary 14.13], [Hall, p. 183], [Hup67, Satz 10.2 a)]
+ return true;
+ elif IsCyclic(DerivedSubgroup(G)) then
+ # see [Hup67, Satz 10.2 c)]
+ return true;
+ elif Exponent(G) = p then
+ # see [Hup67, Satz 10.2 d)]
+ return true;
+ elif p = 3 and RankPGroup(G) = 2 then
+ # see [Hup67, Satz 10.3 b)]: at this point we know that the derived
+ # subgroup is not cyclic, hence G is not regular
+ return false;
+ elif Size(G) < p^p * Size(Agemo(G,p)) then
+ # see [Hal36, Theorem 2.3], [Hup67, Satz 10.13]
+ return true;
+ elif Index(DerivedSubgroup(G),Agemo(DerivedSubgroup(G),p)) < p^(p-1) then
+ # see [Hal36, Theorem 2.3], [Hup67, Satz 10.13]
+ return true;
+ fi;
+
+ # Fallback to actually check the defining criterion, i.e.:
+ # for all a,b in G, we must have that a^p*b^p/(a*b)^p in (<a,b>')^p
+
+ # It suffices to pick 'a' among conjugacy class representatives.
+ # Moreover, if 'a' is central then the criterion automatically holds.
+ # For z,z'\in Z(G), if the criterion holds for (a,b) iff it holds for (az,bz').
+ # We thus choose 'a' among lifts of conjugacy class representatives in G/Z(G).
+ hom := NaturalHomomorphismByNormalSubgroup(G, Center(G));
+ reps := ConjugacyClasses(Image(hom));
+ reps := List(reps, Representative);
+ reps := Filtered(reps, g -> not IsOne(g));
+ reps := List(reps, g -> PreImagesRepresentative(hom, g));
+
+ for b in Image(hom) do
+ b := PreImagesRepresentative(hom, b);
+ for a in reps do
+ # if a and b commute the regularity condition automatically holds
+ if a*b = b*a then continue; fi;
+
+ # regularity is also automatic if a^p * b^p = (a*b)^p
+ ap_bp := a^p * b^p;
+ ab_p := (a*b)^p;
+ if ap_bp = ab_p then continue; fi;
+
+ # if the subgroup generated H by a and b is itself regular, we are also
+ # done. However we don't use recursion, here, as H may be equal to G;
+ # and also we have to be careful to not be use too expensive code here.
+ # But a quick size check is certainly fine.
+ H := Subgroup(G, [a,b]);
+ if Size(H) <= p^p then continue; fi;
+
+ # finally the full check
+ H := DerivedSubgroup(H);
+ if not (ap_bp / ab_p) in Agemo(H, p) then
+ return false;
+ fi;
+ od;
+ od;
+ return true;
+
+end);
+
+
 #############################################################################
 ##
 #M PrimePGroup . . . . . . . . . . . . . . . . . . . . . prime of a p-group

tst/testinstall/pgroups.tst

@@ -168,37 +168,59 @@ true
 gap> JenningsSeries(CyclicGroup(4));
 [ <pc group of size 4 with 2 generators>, Group([ f2 ]), 
  Group([ <identity> of ... ]) ]
+
+#
 gap> G:=CyclicGroup(9);;
 gap> HasIsPowerfulPGroup(G);
 true
 gap> IsPowerfulPGroup(G);
 true
+gap> HasIsRegularPGroup(G);
+true
+gap> IsRegularPGroup(G);
+true
+
+#
 gap> G:=CyclicGroup(10);;
 gap> IsPowerfulPGroup(G);
 false
+gap> IsRegularPGroup(G);
+false
+
+#
 gap> G:=SmallGroup(243,11);;
 gap> HasIsPowerfulPGroup(G);
 false
 gap> IsPowerfulPGroup(G);
 true
+gap> HasIsRegularPGroup(G);
+false
+gap> IsRegularPGroup(G);
+true
 gap> N:=NormalSubgroups(G)[3];;
 gap> H:=FactorGroup(G,N);;
 gap> HasIsPowerfulPGroup(H);
 true
 gap> IsPowerfulPGroup(H);
 true
 gap> myList:=AllSmallGroups(5^4);;
-gap> Number(myList,g->IsPowerfulPGroup(g));
+gap> Number(myList,IsPowerfulPGroup);
 9
+gap> Number(myList,IsRegularPGroup);
+15
 gap> newList:=AllSmallGroups(5^4);;
 gap> for g in newList do
 > RankPGroup(g);
 > Agemo(g,5);
 > od;
-gap> Number(newList,g->IsPowerfulPGroup(g));
+gap> Number(newList,IsPowerfulPGroup);
 9
 gap> myList:=AllSmallGroups(2^4);;
-gap> Number(myList,g->IsPowerfulPGroup(g));
+gap> Number(myList,IsPowerfulPGroup);
+6
+gap> Number(myList,IsPowerfulPGroup);
 6
 gap> g:=AbelianGroup(ListWithIdenticalEntries(2000,2));;
+
+#
 gap> STOP_TEST("pgroups.tst", 1);