Implement IsMinimalNonmonomial for nonsolvable grp

The previous implementation followed van der Waall in only handling
solvable groups. Indeed in the paper,
[MR507832](https://mathscinet.ams.org/mathscinet-getitem?mr=507832)
van der Waall says the nonsolvable groups can easily be disposed
of using Thompson's N-groups papers, however he does not state the
result.

Luckily most of the minimal simple groups are also minimal
non-monomial. The exception is just PSL(3,3) which contains a subgroup
isomorphic to the non-monomial group SL(2,3). The groups of the form
PSL(2,q) are handled by Dickson's classification of their subgroups,
all of which are metabelian or non-solvable. Since the non-solvable
subgroups are eliminated by being minimal simple, we have only
monomial subgroups. The Suzuki groups require a short argument,
given in the source. Suzuki 1960 lists the maximal subgroups, and all
but the Sylow 2-normalizer are metabelian. The Sylow 2-normalizer's
characters are described in sufficient detail in the paper to ensure
they are monomial.

I included a commented out "IsMNMNaive" that checks all the
conditions. I ran this for 10 or 20 minutes on the small, perfect,
and primitive group libraries.

lib/ctblmono.gi

@@ -2176,6 +2176,76 @@ InstallMethod( IsMinimalNonmonomial,
     return false;
 end );
 
+InstallMethod( IsMinimalNonmonomial,
+    "for a non-solvable group",
+    [ IsGroup ],
+    function( K )
+
+    local info, q, p, f;
+
+    if IsSolvableGroup(K) then
+      TryNextMethod();
+    fi;
+
+    # Monomial groups are solvable. A minimal-nonmonomial group by
+    # definition has every proper quotient and every proper subgroup
+    # monomial, hence a non-solvable minimal-nonmonomial group must
+    # have every proper subgroup and every proper quotient be solvable.
+    # If [G,G] were proper, it would have to be solvable, and thus G
+    # solvable, hence G is perfect. If G had any proper normal subgroups
+    # then the quotient would have to be both perfect and solvable, so
+    # G must be simple.
+    if not IsSimpleGroup(K) then
+      return false;
+    fi;
+
+    # Indeed, it must be minimal simple as classified by Corollary 1 in
+    # Thompson's 1968 N-Groups paper, doi:10.1090/S0002-9904-1968-11953-6
+    # * PSL(2,2^f) for f prime, and all such are minimal-non-M groups
+    # * PSL(2,3^f) for f an odd prime, and all such are minimal-non-M groups
+    # * PSL(2,p) for p a prime congruent to 2 or 3 mod 5, and all such are m-n-M
+    # * PSL(3,3) which is NOT a minimal-non-M group (contains SL(2,3))
+    # * Sz(2^f) for f an odd prime, and all such are minimal-non-M groups
+    #
+    # The minimal-non-M part follows from the fact that metabelian groups
+    # are monomial groups.
+    # * For PSL(2,q) Dickson classified their subgroups; the maximal ones are
+    #   either metabelian (hence monomial) or non-solvable; but this latter case
+    #   is ruled out here by being minimal simple; hence these groups are minimal
+    #   non-monomial.
+    # * For PSL(3,3) a subgroup isomorphic to SL(2,3) is not an M-group
+    # * For Sz(q), Suzuki 1960 shows that maximal subgroups are either the
+    #   normalizer H of a Sylow 2-group Q, or one of a few metabelian groups.
+    #   The characters of H are calculated in section 11, page 126, and
+    #   are all induced from the monomial group Q.
+    #   As an induced character can only be irreducible if the original
+    #   character was irreducible, and every irreducible of Q is induced
+    #   from a linear, and induction from that subgroup of Q and then to
+    #   H is the same as induction directly to H, we get that every
+    #   character of H is induced from a linear character (q-1 from H itself,
+    #   1 from Q, and 2 from a subgroup of Q). I.e., H is monomial.
+    #
+    info := IsomorphismTypeInfoFiniteSimpleGroup(K);
+    if info.series = "A" then
+      return info.parameter = 5; # A5 = PSL(2,4) is minimal non-monomial
+    elif info.series = "L" then
+      if info.parameter[1] = 2 then # GAP reports PSL(3,2)=PSL(2,7) as [2,7]
+        q := info.parameter[2];
+        p := SmallestRootInt(q);
+        f := LogInt(q,p);
+        if p = 2 and IsPrimeInt(f) then return true;
+        elif p = 3 and IsOddInt(f) and IsPrimeInt(f) then return true;
+        elif p = q and 0 = (p^2+1) mod 5 then return true;
+        fi;
+      fi;
+    elif info.series = "2B" then
+      q := info.parameter;
+      f := LogInt(q,2);
+      return IsPrimeInt(f);
+    fi;
+    return false;
+end);
+
 
 #############################################################################
 ##

tst/teststandard/ctblmono.tst

@@ -0,0 +1,60 @@
+gap> START_TEST("ctblmono.tst");
+
+#
+# the following test comes from https://github.com/gap-system/gap/issues/4452
+# this used to give method not found for non-solvable groups
+#
+gap> IsMinimalNonmonomial(SL(2,3));
+true
+gap> IsMinimalNonmonomial(GL(2,3));
+false
+gap> IsMinimalNonmonomial(PSL(2,4));
+true
+gap> IsMinimalNonmonomial(PGL(2,5));
+false
+gap> IsMinimalNonmonomial(PSL(2,7));
+true
+gap> IsMinimalNonmonomial(PSL(2,8));
+true
+gap> IsMinimalNonmonomial(PSL(2,9));
+false
+gap> IsMinimalNonmonomial(PSL(2,11));
+false
+gap> IsMinimalNonmonomial(PSL(2,27));
+true
+gap> IsMinimalNonmonomial(PSL(3,3));
+false
+gap> IsMinimalNonmonomial(Sz(8));
+true
+gap> g := Sz(512);; SetIsSolvableGroup(g,false);; IsMinimalNonmonomial(g);
+false
+
+# To avoid more silly mistakes, the following tests were also run
+# Since they take several minutes, I have left them commented out
+# gap> IsMNMNaive := g ->
+# > (IsMonomialGroup(g)=false) # not monomial itself
+# > and ForAll( NormalSubgroups(g), n -> Size(n) = 1 or
+# > IsMonomialGroup(g/n) ) # every proper quotient is monomial
+# > and ForAll( MaximalSubgroupClassReps(g), IsMonomialGroup) # quicker
+# > and ForAll( ConjugacyClassesSubgroups(g), c -> # every proper subgroup
+# > Size( Representative(c) ) = Size(g) or IsMonomialGroup(Representative(c)));;
+# gap> for n in [1..767] do
+# > if IsPrimePowerInt(n) then continue; fi;
+# > if NrSmallGroups(n) > 2000 then continue; fi;
+# > for k in [1..NrSmallGroups(n)] do
+# > sg := SmallGroup(n,k);
+# > Assert(0, IsMNMNaive(sg) = IsMinimalNonmonomial(sg) );
+# > od; od;
+# gap> for n in SizesPerfectGroups() do
+# > for k in [1..NrPerfectLibraryGroups(n)] do
+# > pg := PerfectGroup(IsPermGroup,n,k);
+# > Assert(0, IsMNMNaive(pg) = IsMinimalNonmonomial(pg) );
+# > od; od;
+# gap> for pg in PrimitiveGroupsIterator(NrMovedPoints,[1..20],IsSolvableGroup,false) do
+# > if IsNaturalAlternatingGroup(pg) or IsNaturalSymmetricGroup(pg) then continue; fi;
+# > if Size(pg) > 10^6 then continue; fi;
+# > Assert(0, IsMNMNaive(pg) = IsMinimalNonmonomial(pg) );
+# > od;
+
+#
+gap> STOP_TEST( "ctblmono.tst", 1);