diff --git a/lib/ctblmono.gd b/lib/ctblmono.gd
index fb6cee51c9..210f94bf52 100644
--- a/lib/ctblmono.gd
+++ b/lib/ctblmono.gd
@@ -545,7 +545,9 @@ DeclareProperty( "IsMonomialNumber", IsPosInt );
 ##  whether the irreducible character <A>chi</A> or the group <A>G</A>,
 ##  respectively, is monomial.
 ##  Here <Q>cheap</Q> means in particular that no computations of character
-##  tables are involved.
+##  tables are involved,
+##  and it is <E>not</E> checked whether <A>chi</A> is a character and
+##  irreducible.
 ##  The return value is a record with components
 ##  <List>
 ##  <Mark><C>isMonomial</C></Mark>
@@ -572,7 +574,7 @@ DeclareProperty( "IsMonomialNumber", IsPosInt );
 ##  it is linear, or if its codegree is a prime power,
 ##  or if its group knows to be monomial,
 ##  or if the factor group modulo the kernel can be proved to be monomial by
-##  <Ref Attr="TestMonomialQuick" Label="for a character"/>.
+##  <Ref Attr="TestMonomialQuick" Label="for a group"/>.
 ##  <P/>
 ##  <Example><![CDATA[
 ##  gap> TestMonomialQuick( Irr( S4 )[3] );
@@ -699,9 +701,9 @@ TestMonomialUseLattice := 1000;
 ##  <Prop Name="IsSubnormallyMonomial" Arg='chi' Label="for a character"/>
 ##
 ##  <Description>
-##  A character of the group <M>G</M> is called <E>subnormally monomial</E>
-##  (SM for short) if it is induced from a linear character of a subnormal
-##  subgroup of <M>G</M>.
+##  An irreducible character of the group <M>G</M> is called
+##  <E>subnormally monomial</E> (<E>SM</E> for short) if it is induced
+##  from a linear character of a subnormal subgroup of <M>G</M>.
 ##  A group <M>G</M> is called SM if all its irreducible characters are SM.
 ##  <P/>
 ##  <Ref Attr="TestSubnormallyMonomial" Label="for a group"/> returns
diff --git a/lib/ctblmono.gi b/lib/ctblmono.gi
index a94acce9a5..09844eeab5 100644
--- a/lib/ctblmono.gi
+++ b/lib/ctblmono.gi
@@ -146,7 +146,7 @@ InstallMethod( Delta,
 ##
 #M  IsBergerCondition( <chi> )  . . . . . . . . . . . . . . . for a character
 ##
-InstallOtherMethod( IsBergerCondition,
+InstallMethod( IsBergerCondition,
     "for a class function",
     [ IsClassFunction ],
     function( chi )
@@ -292,6 +292,8 @@ InstallMethod( IsBergerCondition,
 ##
 #F  TestHomogeneous( <chi>, <N> )
 ##
+##  This works also for reducible <chi>.
+##
 InstallGlobalFunction( TestHomogeneous, function( chi, N )
 
     local t,        # character table of `G'
@@ -314,6 +316,11 @@ InstallGlobalFunction( TestHomogeneous, function( chi, N )
                                            N );
     fi;
 
+    if Length( cl ) = 1 then
+      return rec( isHomogeneous := true,
+                  comment       := "restriction to trivial subgroup" );
+    fi;
+
     t:= UnderlyingCharacterTable( chi );
     classes:= SizesConjugacyClasses( t );
     norm:= Sum( cl, c -> classes[c] * values[c]
@@ -357,6 +364,10 @@ end );
 ##
 #M  TestQuasiPrimitive( <chi> ) . . . . . . . . . . . . . . . for a character
 ##
+##  This works also for reducible <chi>.
+##  Note that a representation affording <chi> maps the centre of <chi>
+##  to scalar matrices.
+##
 InstallMethod( TestQuasiPrimitive,
     "for a character",
     [ IsCharacter ],
@@ -366,7 +377,6 @@ InstallMethod( TestQuasiPrimitive,
           t,        # character table of `chi'
           nsg,      # list of normal subgroups of `t'
           cen,      # centre of `chi'
-          allhomog, # are all restrictions up to now homogeneous?
           j,        # loop over normal subgroups
           testhom,  # test of homogeneous restriction
           test;     # result record
@@ -379,10 +389,8 @@ InstallMethod( TestQuasiPrimitive,
 
     # Linear characters are primitive.
     if values[1] = 1 then
-
       test:= rec( isQuasiPrimitive := true,
                   comment          := "linear character" );
-
     else
 
       t:= UnderlyingCharacterTable( chi );
@@ -412,31 +420,21 @@ InstallMethod( TestQuasiPrimitive,
       nsg:= ClassPositionsOfNormalSubgroups( t );
       nsg:= Filtered( nsg, x -> IsSubsetSet( x, cen ) );
 
-      allhomog:= true;
-      j:= 1;
-
-      while allhomog and j <= Length( nsg ) do
+      test:= rec( isQuasiPrimitive := true,
+                  comment          := "all restrictions checked" );
 
-        testhom:= TestHomogeneous( chi, nsg[j] );
+      for j in nsg do
+        testhom:= TestHomogeneous( chi, j );
         if not testhom.isHomogeneous then
 
           # nonhomogeneous restriction found
-          allhomog:= false;
           test:= rec( isQuasiPrimitive := false,
                       comment          := testhom.comment,
                       character        := testhom.character );
-
+          break;
         fi;
-
-        j:= j+1;
-
       od;
 
-      if allhomog then
-        test:= rec( isQuasiPrimitive := true,
-                    comment          := "all restrictions checked" );
-      fi;
-
     fi;
 
     Info( InfoMonomial, 1,
@@ -460,14 +458,18 @@ InstallMethod( IsQuasiPrimitive,
 ##
 #M  IsPrimitiveCharacter( <chi> ) . . . . . . . . . . . . . . for a character
 ##
+##  Quasi-primitive irreducible characters of solvable groups are primitive,
+##  see for example [Isa76, Thm. 11.33].
+##
 InstallMethod( IsPrimitiveCharacter,
     "for a class function",
     [ IsClassFunction ],
     function( chi )
-    if not IsSolvableGroup( UnderlyingGroup( chi ) ) then
+    if not ( IsIrreducibleCharacter( chi ) and
+             IsSolvableGroup( UnderlyingGroup( chi ) ) ) then
       TryNextMethod();
     fi;
-    return IsCharacter( chi ) and TestQuasiPrimitive( chi ).isQuasiPrimitive;
+    return TestQuasiPrimitive( chi ).isQuasiPrimitive;
     end );
 
 
@@ -747,7 +749,7 @@ InstallMethod( TestSubnormallyMonomial,
 ##
 #M  TestSubnormallyMonomial( <chi> )  . . . . . . . . . . . . for a character
 ##
-InstallOtherMethod( TestSubnormallyMonomial,
+InstallMethod( TestSubnormallyMonomial,
     "for a character",
     [ IsClassFunction ],
     function( chi )
@@ -917,7 +919,7 @@ InstallMethod( IsSubnormallyMonomial,
     [ IsGroup ],
     G -> TestSubnormallyMonomial( G ).isSubnormallyMonomial );
 
-InstallOtherMethod( IsSubnormallyMonomial,
+InstallMethod( IsSubnormallyMonomial,
     "for a character",
     [ IsClassFunction ],
     chi -> TestSubnormallyMonomial( chi ).isSubnormallyMonomial );
@@ -1013,6 +1015,8 @@ InstallMethod( IsMonomialNumber,
 ##
 #M  TestMonomialQuick( <chi> )  . . . . . . . . . . . . . . . for a character
 ##
+##  We assume that <chi> is an irreducible character.
+##
 InstallMethod( TestMonomialQuick,
     "for a character",
     [ IsClassFunction ],
@@ -1048,8 +1052,20 @@ InstallMethod( TestMonomialQuick,
       return rec( isMonomial := true,
                   comment    := "linear character" );
 
-    elif TestMonomialQuick( UnderlyingGroup( chi ) ).isMonomial = true then
-#T ?
+    fi;
+
+    G:= UnderlyingGroup( chi );
+
+    if Size( G ) mod DegreeOfCharacter( chi ) <> 0 then
+      Info( InfoMonomial, 1,
+            "TestMonomialQuick returns with `false'" );
+      return rec( isMonomial := false,
+                  comment    := "degree does not divide group order" );
+    fi;
+
+    # The following criteria are applicable only to irreducible characters.
+    # We do *not* check here that 'chi' is really an irreducible character.
+    if TestMonomialQuick( G ).isMonomial = true then
 
       # The whole group is known to be monomial.
       Info( InfoMonomial, 1,
@@ -1059,7 +1075,6 @@ InstallMethod( TestMonomialQuick,
 
     fi;
 
-    G   := UnderlyingGroup( chi );
     chi := ValuesOfClassFunction( chi );
 
     # Replace `G' by the factor group modulo the kernel.
@@ -1073,7 +1088,6 @@ InstallMethod( TestMonomialQuick,
 
     # Inspect the codegree.
     codegree := factsize / chi[1];
-
     if IsPrimePowerInt( codegree ) then
 
       # If the codegree is a prime power then the character is monomial,
@@ -1110,7 +1124,7 @@ InstallMethod( TestMonomialQuick,
 
       if factsize / hall = chi[1] then
 
-        # The character is induced from a {\em linear} character
+        # The character is induced from a *linear* character
         # of the $\pi$ Hall group.
         Info( InfoMonomial, 1,
               "TestMonomialQuick returns with `true'" );
@@ -1119,7 +1133,7 @@ InstallMethod( TestMonomialQuick,
 
       elif IsMonomialNumber( hall ) then
 
-        # The {\em order} of this Hall subgroup is monomial.
+        # The *order* of this Hall subgroup is monomial.
         Info( InfoMonomial, 1,
               "TestMonomialQuick returns with `true'" );
         return rec( isMonomial := true,
@@ -1132,29 +1146,22 @@ InstallMethod( TestMonomialQuick,
     # Inspect the factor group modulo the kernel.
     if 1 < Length( ker ) then
 
-      if   IsSolvableGroup( G ) and IsMonomialNumber( factsize ) then
-
-        # The order of the kernel factor group is monomial.
-        # (For faithful characters this check has been done already.)
-        Info( InfoMonomial, 1,
-              "TestMonomialQuick returns with `true'" );
-        return rec( isMonomial := true,
-                    comment    := "size of kernel factor is monomial" );
+      # For solvable 'G', checking 'factsize' for monomiality does not
+      # help here because the divisor 'hall' has been checked above.
 
-      elif IsSubsetSet( ker, ClassPositionsOfSupersolvableResiduum(t) ) then
+      if IsSubsetSet( ker, ClassPositionsOfSupersolvableResiduum(t) ) then
 
         # The factor group modulo the kernel is supersolvable.
         Info( InfoMonomial, 1,
               "TestMonomialQuick returns with `true'" );
         return rec( isMonomial:= true,
                     comment:= "kernel factor group is supersolvable" );
-#T Is there more one can do without computing the factor group?
 
       fi;
 
       grouptest:= TestMonomialQuick( FactorGroupNormalSubgroupClasses(
                       OrdinaryCharacterTable( G ), ker ) );
-#T This can help ??
+#T This is not cheap!
       if grouptest.isMonomial = true then
 
         Info( InfoMonomial, 1,
@@ -1190,7 +1197,7 @@ InstallMethod( TestMonomialQuick,
 ##    (Compute the Sylow subgroups of the supersolvable residuum,
 ##     and check whether they are abelian.)
 ##
-InstallOtherMethod( TestMonomialQuick,
+InstallMethod( TestMonomialQuick,
     "for a group",
     [ IsGroup ],
     function( G )
@@ -1273,11 +1280,18 @@ InstallOtherMethod( TestMonomialQuick,
 #M  TestMonomial( <chi> ) . . . . . . . . . . . . . . . . . . for a character
 #M  TestMonomial( <chi>, <uselattice> ) . . .  for a character, and a Boolean
 ##
-##  Called with a character <chi> as argument, `TestMonomialQuick( <chi> )'
-##  is inspected first.  If this did not decide the question, we test all
-##  those normal subgroups of $G$ to that <chi> restricts nonhomogeneously
-##  whether the interesting character of the inertia subgroup is monomial.
+##  Called with an irreducible character <chi> as argument,
+##  `TestMonomialQuick( <chi> )' is inspected first;
+##  if this did not decide the question,
+##  we test all those normal subgroups of $G$ to which <chi> restricts
+##  nonhomogeneously whether the interesting character of the
+##  inertia subgroup is monomial.
 ##  (If <chi> is quasiprimitive then it is nonmonomial.)
+##  If <chi> is not irreducible, these tests are not applicable.
+##
+##  If <uselattice> is `true' or if the group of <chi> has order at most
+##  `TestMonomialUseLattice' then the subgroup lattice is used
+##  to decide the question if necessary.
 ##
 BindGlobal( "TestMonomialFromLattice", function( chi )
     local G, H, source;
@@ -1286,7 +1300,7 @@ BindGlobal( "TestMonomialFromLattice", function( chi )
 
     # Loop over representatives of the conjugacy classes of subgroups.
     for H in List( ConjugacyClassesSubgroups( G ), Representative ) do
-      if Index( G, H ) = chi[1] then
+      if IndexNC( G, H ) = chi[1] then
         source:= First( LinearCharacters( H ), lambda -> lambda^G = chi );
         if source <> fail then
           return source;
@@ -1330,38 +1344,38 @@ InstallMethod( TestMonomial,
 
     Info( InfoMonomial, 1, "TestMonomial called" );
 
-    # Start wirth elementary tests for monomiality.
-    test:= TestMonomialQuick( chi );
+    # Start with elementary tests for monomiality.
+    if   HasIsMonomialCharacter( chi ) then
+      # The character knows about being monomial.
+      test:= rec( isMonomial := IsMonomialCharacter( chi ),
+                  comment    := "was already stored" );
+    elif IsIrreducibleCharacter( chi ) then
+      test:= TestMonomialQuick( chi );
+    elif DegreeOfCharacter( chi ) = 1 then
+      # Linear characters are monomial.
+      test:= rec( isMonomial := true,
+                  comment    := "linear character" );
+    elif Size( UnderlyingGroup( chi ) ) mod DegreeOfCharacter( chi ) <> 0 then
+      test:= rec( isMonomial := false,
+                  comment    := "degree does not divide group order" );
+    else
+      test:= rec( isMonomial:= "?" );
+    fi;
 
     if test.isMonomial = "?" then
 
       G:= UnderlyingGroup( chi );
 
       if not IsSolvableGroup( G ) then
-
-        # Use the subgroup lattice or give up.
-        if uselattice or Size( G ) <= TestMonomialUseLattice then
-
-          test:= TestMonomialFromLattice( chi );
-          if test = fail then
-            test:= rec( isMonomial := false,
-                        comment    := "lattice checked" );
-          else
-            test:= rec( isMonomial := true,
-                        comment    := "induced from \'character\'",
-                        character  := test );
-          fi;
-
-        else
-
-          # We do not know whether <chi> is monomial.
-          Info( InfoMonomial, 1,
-                "TestMonomial: nonsolvable group" );
-          test:= rec( isMonomial:= "?",
-                      comment:= "no criterion for nonsolvable group" );
-
-        fi;
-
+        Info( InfoMonomial, 1,
+              "TestMonomial: nonsolvable group" );
+        test:= rec( isMonomial := "?",
+                    comment    := "no criterion for nonsolvable group" );
+      elif not IsIrreducibleCharacter( chi ) then
+        Info( InfoMonomial, 1,
+              "TestMonomial: reducible character" );
+        test:= rec( isMonomial := "?",
+                    comment    := "no criterion for reducible character" );
       else
 
         # Loop over all normal subgroups of `G' to that <chi> restricts
@@ -1410,6 +1424,7 @@ InstallMethod( TestMonomial,
                 test:= rec( isMonomial := true,
                             comment    := "induced from monomial subgroup",
                             subgroup   := T );
+#T example?
 
               else
 
@@ -1464,29 +1479,25 @@ InstallMethod( TestMonomial,
           # We have tried all suitable normal subgroups and always got
           # back that the character of the inertia subgroup was
           # (possibly) nonmonomial.
-          if uselattice or Size( G ) <= TestMonomialUseLattice then
-
-            # Use explicit computations with the subgroup lattice,
-            test:= TestMonomialFromLattice( chi );
-            if test = fail then
-              test:= rec( isMonomial := false,
-                          comment    := "lattice checked" );
-            else
-              test:= rec( isMonomial := true,
-                          comment    := "induced from \'character\'",
-                          character  := test );
-            fi;
-
-          else
+          test:= rec( isMonomial:= "?",
+                      comment:= "all inertia subgroups checked, no result" );
 
-            # We cannot decide whether <chi> is monomial.
-            test:= rec( isMonomial:= "?",
-                     comment:= "all inertia subgroups checked, no result" );
+        fi;
 
-          fi;
+      fi;
 
+      if test.isMonomial = "?" and
+         ( uselattice or Size( G ) <= TestMonomialUseLattice ) then
+        # Use explicit computations with the subgroup lattice,
+        test:= TestMonomialFromLattice( chi );
+        if test = fail then
+          test:= rec( isMonomial := false,
+                      comment    := "lattice checked" );
+        else
+          test:= rec( isMonomial := true,
+                      comment    := "induced from \'character\'",
+                      character  := test );
         fi;
-
       fi;
 
     fi;
@@ -1503,17 +1514,15 @@ InstallMethod( TestMonomial,
 #M  TestMonomial( <G> ) . . . . . . . . . . . . . . . . . . . . . for a group
 #M  TestMonomial( <G>, <uselattice> ) . . . . . .  for a group, and a Boolean
 ##
-##  Called with a group <G> the program checks whether all representatives
+##  Called with a group <G>, the program checks whether all representatives
 ##  of character orbits are monomial.
 ##
-#T used e.g. by `Irr' for supersolvable groups, function `IrrConlon'!
-##
-InstallOtherMethod( TestMonomial,
+InstallMethod( TestMonomial,
     "for a group",
     [ IsGroup ],
     G -> TestMonomial( G, false ) );
 
-InstallOtherMethod( TestMonomial,
+InstallMethod( TestMonomial,
     "for a group, and a Boolean",
     [ IsGroup, IsBool ],
     function( G, uselattice )
@@ -1549,11 +1558,12 @@ InstallOtherMethod( TestMonomial,
         found:= false;
         j:= 2;
         poss:= [];
-        while ( not found ) and j <= Length( orbits ) do
+        while j <= Length( orbits ) do
           psi:= orbits[j];
           testmon:= TestMonomial( psi, uselattice ).isMonomial;
           if testmon = false then
             found:= true;
+            break;
           elif testmon = "?" then
             Add( poss, psi );
           fi;
@@ -1886,7 +1896,7 @@ InstallMethod( TestRelativelySM,
     [ IsClassFunction ],
     TestRelativelySMFun );
 
-InstallOtherMethod( TestRelativelySM,
+InstallMethod( TestRelativelySM,
     "for a group",
     [ IsGroup ],
     TestRelativelySMFun );
@@ -2579,6 +2589,8 @@ InstallGlobalFunction( MinimalNonmonomialGroup, function( p, factsize )
     K:= PolycyclicFactorGroup( K, rels );
     ConvertToStringRep( name );
     SetName( K, name );
+    SetIsMinimalNonmonomial( K, true );
+
     return K;
 end );
 
diff --git a/tst/testinstall/ctblmono.tst b/tst/testinstall/ctblmono.tst
index 063748546a..984a095b15 100644
--- a/tst/testinstall/ctblmono.tst
+++ b/tst/testinstall/ctblmono.tst
@@ -7,8 +7,12 @@
 #Y  Copyright (C)  1998,  Lehrstuhl D für Mathematik,  RWTH Aachen,  Germany
 ##
 gap> START_TEST("ctblmono.tst");
+
+##
 gap> S4:= SymmetricGroup( 4 );;  SetName( S4, "S4");
 gap> Sl23:= SL( 2, 3 );;
+
+##
 gap> Alpha( Sl23 );
 [ 1, 3, 3 ]
 gap> Alpha( S4 );
@@ -25,9 +29,11 @@ gap> List( Irr( Sl23 ), IsBergerCondition );
 [ true, true, true, false, false, false, true ]
 gap> List( Irr( Sl23 ), Degree );
 [ 1, 1, 1, 2, 2, 2, 3 ]
-gap> n:= DerivedSubgroup( Sl23 );;      
+
+##
 gap> chi:= Irr( Sl23 )[7];
 Character( CharacterTable( SL(2,3) ), [ 3, 0, 0, 3, 0, 0, -1 ] )
+gap> n:= DerivedSubgroup( Sl23 );;
 gap> test:= TestHomogeneous( chi, n );;
 gap> test.isHomogeneous;  test.comment;  test.multiplicity;
 false
@@ -39,6 +45,8 @@ gap> cln:= ClassPositionsOfNormalSubgroup( CharacterTable( Sl23 ), n );
 [ 1, 4, 7 ]
 gap> TestHomogeneous( chi, cln );
 rec( comment := "restricts irreducibly", isHomogeneous := true )
+
+##
 gap> chi:= Irr( Sl23 )[4];;
 gap> TestQuasiPrimitive( chi );
 rec( comment := "all restrictions checked", isQuasiPrimitive := true )
@@ -51,6 +59,8 @@ gap> IsPrimitive( Irr( Sl23 )[4] );
 true
 gap> IsPrimitive( Irr( Sl23 )[7] );
 false
+
+##
 gap> List( Irr( Sl23 ), IsInducedFromNormalSubgroup );
 [ false, false, false, false, false, false, true ]
 gap> List( Irr( S4 ){ [ 1, 3, 4 ] },
@@ -61,18 +71,216 @@ gap> List( Irr( S4 ){ [ 1, 3, 4 ] },
       comment := "induced from component '.character'", isInduced := true ), 
   rec( comment := "all maximal normal subgroups checked", isInduced := false 
      ) ]
-gap> TestMonomial( S4 );
-rec( comment := "abelian by supersolvable group", isMonomial := true )
-gap> TestMonomial( Sl23 );
-rec( comment := "list Delta( G ) contains entry > 1", isMonomial := false )
-gap> Filtered( [ 1 .. 111 ], x -> not IsMonomial( x ) );
-[ 24, 48, 72, 96, 108 ]
-gap> TestMonomialQuick( Irr( S4 )[3] );
+
+##
+gap> Filtered( [ 1 .. 200 ], i -> not IsMonomial( i ) );
+[ 24, 48, 72, 96, 108, 120, 144, 160, 168, 192 ]
+
+##
+gap> irr:= Irr( SymmetricGroup( 4 ) );;
+gap> SetIsMonomialCharacter( irr[1], true );
+gap> TestMonomialQuick( irr[1] );
+rec( comment := "was already stored", isMonomial := true )
+gap> TestMonomial( irr[1] );
+rec( comment := "was already stored", isMonomial := true )
+gap> IsMonomial( irr[1] );
+true
+gap> TestMonomialQuick( irr[5] );
+rec( comment := "linear character", isMonomial := true )
+gap> TestMonomial( irr[5] );
+rec( comment := "linear character", isMonomial := true )
+gap> IsMonomial( irr[5] );
+true
+gap> TestMonomial( 5 * irr[1] );
+rec( comment := "degree does not divide group order", isMonomial := false )
+gap> IsMonomial( 5 * irr[5] );
+false
+gap> TestMonomialQuick( irr[2] );
+rec( comment := "whole group is monomial", isMonomial := true )
+gap> TestMonomial( irr[2] );
 rec( comment := "whole group is monomial", isMonomial := true )
+gap> IsMonomial( irr[2] );
+true
+gap> irr:= Irr( SL(2,3) );;
+gap> chi:= First( irr, x -> x[1] = 3 );;
+gap> TestMonomialQuick( chi );
+rec( comment := "codegree is prime power", isMonomial := true )
+gap> TestMonomial( chi );
+rec( comment := "codegree is prime power", isMonomial := true )
+gap> IsMonomial( chi );
+true
+gap> irr:= Irr( SmallGroup( 120, 15 ) );;
+gap> chi:= First( irr, x -> x[1] = 3 and
+>                           Length( ClassPositionsOfKernel( x ) ) = 2 );;
+gap> TestMonomialQuick( chi );
+rec( comment := "degree is index of Hall subgroup", isMonomial := true )
+gap> TestMonomial( chi );
+rec( comment := "degree is index of Hall subgroup", isMonomial := true )
+gap> IsMonomial( chi );
+true
+gap> irr:= Irr( SmallGroup( 240, 109 ) );;
+gap> chi:= First( irr, x -> x[1] = 6 );;
+gap> TestMonomialQuick( chi );
+rec( comment := "induced from monomial Hall subgroup", isMonomial := true )
+gap> TestMonomial( chi );
+rec( comment := "induced from monomial Hall subgroup", isMonomial := true )
+gap> IsMonomial( chi );
+true
+gap> g:= DirectProduct( AlternatingGroup(5), SymmetricGroup(3),
+>                       SymmetricGroup(3) );;
+gap> chi:= First( Irr( g ), x -> x[1] = 2 and
+>                           Length( ClassPositionsOfKernel( x ) ) = 10 );;
+gap> TestMonomialQuick( chi );
+rec( comment := "kernel factor group is supersolvable", isMonomial := true )
+gap> TestMonomial( chi );
+rec( comment := "kernel factor group is supersolvable", isMonomial := true )
+gap> IsMonomial( chi );
+true
+gap> irr:= Irr( SmallGroup( 144, 31 ) );;
+gap> chi:= First( irr, x -> x[1] = 6 );;
+gap> TestMonomialQuick( chi );
+rec( comment := "kernel factor group is monomial", isMonomial := true )
+gap> TestMonomial( chi );
+rec( comment := "kernel factor group is monomial", isMonomial := true )
+gap> IsMonomial( chi );
+true
+gap> irr:= Irr( SL(2,3) );;
+gap> chi:= First( irr, x -> x[1] = 2 );;
+gap> TestMonomialQuick( chi );
+rec( comment := "no decision by cheap tests", isMonomial := "?" )
+gap> TestMonomial( chi );
+rec( comment := "quasiprimitive character", isMonomial := false )
+gap> IsMonomial( chi );
+false
+gap> irr:= Irr( AlternatingGroup( 5 ) );;
+gap> chi:= First( irr, x -> x[1] = 5 );;
+gap> TestMonomialQuick( chi );
+rec( comment := "no decision by cheap tests", isMonomial := "?" )
+gap> TestMonomial( chi ).comment;
+"induced from 'character'"
+gap> IsMonomial( chi );
+true
+gap> TestMonomialUseLattice_Orig:= TestMonomialUseLattice;;
+gap> TestMonomialUseLattice:= 20;;
+gap> chi:= First( irr, x -> x[1] = 4 );;
+gap> TestMonomialQuick( chi );
+rec( comment := "no decision by cheap tests", isMonomial := "?" )
+gap> TestMonomial( chi ).comment;
+"no criterion for nonsolvable group"
+gap> TestMonomial( chi, true ).comment;
+"lattice checked"
+gap> IsMonomial( chi );
+false
+gap> irr:= Irr( SmallGroup( 96, 204 ) );;
+gap> chi:= First( irr, x -> x[1] = 4 );;
+gap> TestMonomialQuick( chi );
+rec( comment := "no decision by cheap tests", isMonomial := "?" )
+gap> TestMonomial( chi ).comment;
+"induced from 'character'"
+gap> IsMonomial( chi );
+true
+gap> chi:= First( Irr( SmallGroup( 144, 31 ) ), x -> x[1] = 4 );;
+gap> TestMonomialQuick( chi );
+rec( comment := "no decision by cheap tests", isMonomial := "?" )
+gap> TestMonomial( chi ).comment;
+"all inertia subgroups checked, no result"
+gap> TestMonomial( chi, true ).comment;
+"induced from 'character'"
+gap> IsMonomial( chi );
+true
+gap> chi:= 0 * [ 1 .. NrConjugacyClasses( S4 ) ];;
+gap> chi[1]:= Size( S4 );;
+gap> chi:= ClassFunction( S4, chi );;
+gap> TestMonomial( chi ).comment;
+"no criterion for reducible character"
+gap> TestMonomial( chi, true ).comment;
+"induced from 'character'"
+gap> IsMonomial( chi );
+true
+gap> TestMonomialUseLattice:= TestMonomialUseLattice_Orig;;
+gap> chi:= First( Irr( SmallGroup( 48, 28 ) ), x -> x[1] = 4 );;
+gap> TestMonomialQuick( chi );
+rec( comment := "no decision by cheap tests", isMonomial := "?" )
+gap> TestMonomial( chi ).comment;
+"induced from 'character'"
+gap> IsMonomial( chi );
+true
+
+##
 gap> TestMonomialQuick( S4 );
 rec( comment := "abelian by supersolvable group", isMonomial := true )
+gap> TestMonomial( S4 );
+rec( comment := "abelian by supersolvable group", isMonomial := true )
+gap> IsMonomial( S4 );
+true
 gap> TestMonomialQuick( Sl23 );
 rec( comment := "no decision by cheap tests", isMonomial := "?" )
+gap> TestMonomial( Sl23 );
+rec( comment := "list Delta( G ) contains entry > 1", isMonomial := false )
+gap> IsMonomial( Sl23 );
+false
+gap> g:= SmallGroup( 96, 204 );;
+gap> TestMonomialQuick( g );
+rec( comment := "no decision by cheap tests", isMonomial := "?" )
+gap> TestMonomial( g );
+rec( comment := "all characters checked", isMonomial := true )
+gap> IsMonomial( g );
+true
+gap> TestMonomialUseLattice_Orig:= TestMonomialUseLattice;;
+gap> TestMonomialUseLattice:= 50;;
+gap> test:= TestMonomial( SmallGroup( 96, 190 ) );;
+gap> test.isMonomial;  test.comment;
+"?"
+"(possibly) nonmon. characters found"
+gap> test:= TestMonomial( SmallGroup( 96, 190 ), true );;
+gap> test.isMonomial;  test.comment;
+false
+"nonmonomial character found"
+gap> TestMonomialUseLattice:= TestMonomialUseLattice_Orig;;
+gap> g:= SmallGroup( 16, 3 );;
+gap> TestMonomialQuick( g );  # implication
+rec( comment := "was already stored", isMonomial := true )
+gap> TestMonomial( g );
+rec( comment := "was already stored", isMonomial := true )
+gap> IsMonomial( g );
+true
+gap> g:= AlternatingGroup( 5 );;
+gap> TestMonomialQuick( g );
+rec( comment := "non-solvable group", isMonomial := false )
+gap> TestMonomial( g );
+rec( comment := "non-solvable group", isMonomial := false )
+gap> IsMonomial( g );
+false
+gap> g:= SmallGroup( 56, 10 );;
+gap> TestMonomialQuick( g );
+rec( comment := "group order is monomial", isMonomial := true )
+gap> TestMonomial( g );
+rec( comment := "group order is monomial", isMonomial := true )
+gap> IsMonomial( g );
+true
+gap> g:= SmallGroup( 24, 10 );;
+gap> TestMonomialQuick( g );
+rec( comment := "nilpotent group", isMonomial := true )
+gap> TestMonomial( g );
+rec( comment := "nilpotent group", isMonomial := true )
+gap> IsMonomial( g );
+true
+gap> g:= SmallGroup( 24, 4 );;
+gap> TestMonomialQuick( g );
+rec( comment := "supersolvable group", isMonomial := true )
+gap> TestMonomial( g );
+rec( comment := "supersolvable group", isMonomial := true )
+gap> IsMonomial( g );
+true
+gap> g:= SmallGroup( 324, 160 );;
+gap> TestMonomialQuick( g );
+rec( comment := "Sylow abelian by supersolvable group", isMonomial := true )
+gap> TestMonomial( g );
+rec( comment := "Sylow abelian by supersolvable group", isMonomial := true )
+gap> IsMonomial( g );
+true
+
+##
 gap> TestSubnormallyMonomial( S4 );
 rec( character := Character( CharacterTable( S4 ), [ 3, -1, -1, 0, 1 ] ), 
   comment := "found non-SM character", isSubnormallyMonomial := false )
@@ -83,27 +291,52 @@ gap> TestSubnormallyMonomial( DerivedSubgroup( S4 ) );
 rec( comment := "all irreducibles checked", isSubnormallyMonomial := true )
 gap> IsSubnormallyMonomial( DerivedSubgroup( S4 ) );
 true
+
+##
 gap> TestRelativelySM( DerivedSubgroup( S4 ) );
 rec( comment := "normal subgroups are abelian or have nilpotent factor group",
   isRelativelySM := true )
-gap> IsMinimalNonmonomial( Sl23 );                  
-true
-gap> IsMinimalNonmonomial( S4 );
-false
-gap> MinimalNonmonomialGroup(  2,  3 ); # the group SL(2,3)
+
+##
+gap> g1:= MinimalNonmonomialGroup(  2,  3 ); # the group SL(2,3)
 2^(1+2):3
-gap> MinimalNonmonomialGroup(  3,  4 );
+gap> g2:= MinimalNonmonomialGroup(  3,  4 );
 3^(1+2):4
-gap> MinimalNonmonomialGroup(  5,  8 );
+gap> g3:= MinimalNonmonomialGroup(  5,  8 );
 5^(1+2):Q8
-gap> MinimalNonmonomialGroup( 13, 12 );                              
+gap> g4:= MinimalNonmonomialGroup( 13, 12 );
 13^(1+2):2.D6
-gap> MinimalNonmonomialGroup(  1, 14 );
+gap> g5:= MinimalNonmonomialGroup(  1, 14 );
 2^(1+6):D14
-gap> MinimalNonmonomialGroup(  2, 14 );
+gap> g6:= MinimalNonmonomialGroup(  2, 14 );
 (2^(1+6)Y4):D14
+gap> MinimalNonmonomialGroup(  3,  3 );
+fail
+gap> MinimalNonmonomialGroup(  2,  4 );
+fail
+gap> MinimalNonmonomialGroup(  2,  8 );
+fail
+gap> MinimalNonmonomialGroup(  1, 10 );
+fail
+gap> MinimalNonmonomialGroup(  5,  9 );
+fail
+
+##
+gap> IsMinimalNonmonomial( Sl23 );
+true
+gap> for g in [ g1, g2, g3, g4, g5, g6 ] do
+>      # Make sure that the value is not yet stored.
+>      if not IsMinimalNonmonomial( Group( GeneratorsOfGroup( g ) ) ) then
+>        Error( "wrong result of IsMinimalNonmonomial" );
+>      fi;
+>    od;
+gap> IsMinimalNonmonomial( S4 );
+false
+
+##
 gap> STOP_TEST( "ctblmono.tst", 1);
 
 #############################################################################
 ##
 #E
+