Welcome To Our Shell

Mister Spy & Souheyl Bypass Shell

  
  75 Monomiality Questions
  
  This  chapter  describes  functions  dealing  with the monomiality of finite
  (solvable) groups and their characters.
  
  All  these  functions  assume  characters  to  be  class function objects as
  described in Chapter 72, lists of character values are not allowed.
  
  The  usual  property  tests  of GAP that return either true or false are not
  sufficient  for  us.  When  we ask whether a group character χ has a certain
  property,  such  as  quasiprimitivity, we usually want more information than
  just  yes or no. Often we are interested in the reason why a group character
  χ  was proved to have a certain property, e.g., whether monomiality of χ was
  proved by the observation that the underlying group is nilpotent, or whether
  it  was necessary to construct a linear character of a subgroup from which χ
  can  be induced. In the latter case we also may be interested in this linear
  character.  Therefore we need test functions that return a record containing
  such  useful  information.  For example, the record returned by the function
  TestQuasiPrimitive  (75.3-3)  contains the component isQuasiPrimitive (which
  is the known boolean property flag), and additionally the component comment,
  a string telling the reason for the value of the isQuasiPrimitive component,
  and  in  the  case  that  the  argument  χ  was  not quasiprimitive also the
  component character, which is an irreducible constituent of a nonhomogeneous
  restriction  of  χ  to a normal subgroup. Besides these test functions there
  are  also the known properties, e.g., the property IsQuasiPrimitive (75.3-3)
  which  will  call  the attribute TestQuasiPrimitive (75.3-3), and return the
  value of the isQuasiPrimitive component of the result.
  
  A few words about how to use the monomiality functions seem to be necessary.
  Monomiality  questions  usually  involve  computations in many subgroups and
  factor  groups  of  a  given  group,  and  for  these groups often expensive
  calculations  such  as  that  of  the  character table are necessary. So one
  should  be  careful  not  to  construct  the same group over and over again,
  instead  the  same  group  object  should be reused, such that its character
  table  need  to  be  computed  only  once.  For example, suppose you want to
  restrict a character to a normal subgroup N that was constructed as a normal
  closure  of  some group elements, and suppose that you have already computed
  with   normal   subgroups   (by   calls   to  NormalSubgroups  (39.19-9)  or
  MaximalNormalSubgroups  (39.19-10))  and  their  character  tables. Then you
  should  look  in the lists of known normal subgroups whether N is contained,
  and  if  so you can use the known character table. A mechanism that supports
  this for normal subgroups is described in 71.23.
  
  Also  the  following  hint  may  be useful in this context. If you know that
  sooner  or  later  you will compute the character table of a group G then it
  may be advisable to compute it as soon as possible. For example, if you need
  the  normal subgroups of G then they can be computed more efficiently if the
  character  table  of  G  is  known, and they can be stored compatibly to the
  contained  G-conjugacy  classes.  This  correspondence  of  classes list and
  normal subgroup can be used very often.
  
  Several examples in this chapter use the symmetric group S_4 and the special
  linear  group  SL(2,3).  For running the examples, you must first define the
  groups, for example as follows.
  
    Example  
    gap> S4:= SymmetricGroup( 4 );;  SetName( S4, "S4" );
    gap> Sl23:= SL( 2, 3 );;
  
  
  
  75.1 InfoMonomial (Info Class)
  
  75.1-1 InfoMonomial
  
  InfoMonomial info class
  
  Most  of  the  functions  described  in  this  chapter print some (hopefully
  useful)  information  if the info level of the info class InfoMonomial is at
  least 1, see 7.4 for details.
  
  
  75.2 Character Degrees and Derived Length
  
  75.2-1 Alpha
  
  Alpha( G )  attribute
  
  For  a group G, Alpha returns a list whose i-th entry is the maximal derived
  length  of  groups  G  /  ker(χ)  for  χ ∈ Irr(G) with χ(1) at most the i-th
  irreducible degree of G.
  
  75.2-2 Delta
  
  Delta( G )  attribute
  
  For  a  group  G, Delta returns the list [ 1, alp[2] - alp[1], ..., alp[n] -
  alp[n-1] ], where alp =Alpha( G ) (see Alpha (75.2-1)).
  
  
  75.2-3 IsBergerCondition
  
  IsBergerCondition( G )  property
  IsBergerCondition( chi )  property
  
  Called  with  an  irreducible  character chi of a group G, IsBergerCondition
  returns  true  if chi satisfies M' ≤ ker(χ) for every normal subgroup M of G
  with the property that M ≤ ker(ψ) holds for all ψ ∈ Irr(G) with ψ(1) < χ(1),
  and false otherwise.
  
  Called  with  a  group  G, IsBergerCondition returns true if all irreducible
  characters of G satisfy the inequality above, and false otherwise.
  
  For  groups  of  odd  order  the  result  is  always  true  by  a theorem of
  T. R. Berger (see [Ber76, Thm. 2.2]).
  
  In  the  case  that  false  is returned, InfoMonomial (75.1-1) tells about a
  degree for which the inequality is violated.
  
    Example  
    gap> Alpha( Sl23 );
    [ 1, 3, 3 ]
    gap> Alpha( S4 );
    [ 1, 2, 3 ]
    gap> Delta( Sl23 );
    [ 1, 2, 0 ]
    gap> Delta( S4 );
    [ 1, 1, 1 ]
    gap> IsBergerCondition( S4 );
    true
    gap> IsBergerCondition( Sl23 );
    false
    gap> List( Irr( Sl23 ), IsBergerCondition );
    [ true, true, true, false, false, false, true ]
    gap> List( Irr( Sl23 ), Degree );
    [ 1, 1, 1, 2, 2, 2, 3 ]
  
  
  
  75.3 Primitivity of Characters
  
  75.3-1 TestHomogeneous
  
  TestHomogeneous( chi, N )  function
  
  For a group character chi of the group G, say, and a normal subgroup N of G,
  TestHomogeneous returns a record with information whether the restriction of
  chi to N is homogeneous, i.e., is a multiple of an irreducible character.
  
  N  may  be  given  also  as  list  of  conjugacy  class positions w.r.t. the
  character table of G.
  
  The components of the result are
  
  isHomogeneous
        true or false,
  
  comment
        a  string  telling  a  reason  for  the  value  of  the  isHomogeneous
        component,
  
  character
        irreducible   constituent  of  the  restriction,  only  bound  if  the
        restriction had to be checked,
  
  multiplicity
        multiplicity of the character component in the restriction of chi.
  
    Example  
    gap> n:= DerivedSubgroup( Sl23 );;
    gap> chi:= Irr( Sl23 )[7];
    Character( CharacterTable( SL(2,3) ), [ 3, 0, 0, 3, 0, 0, -1 ] )
    gap> TestHomogeneous( chi, n );
    rec( character := Character( CharacterTable( Group(
        [ [ [ 0*Z(3), Z(3) ], [ Z(3)^0, 0*Z(3) ] ], 
          [ [ Z(3), 0*Z(3) ], [ 0*Z(3), Z(3) ] ], 
          [ [ Z(3)^0, Z(3) ], [ Z(3), Z(3) ] ] ]) ),
      [ 1, -1, 1, -1, 1 ] ), comment := "restriction checked", 
      isHomogeneous := false, multiplicity := 1 )
    gap> chi:= Irr( Sl23 )[4];
    Character( CharacterTable( SL(2,3) ), [ 2, 1, 1, -2, -1, -1, 0 ] )
    gap> cln:= ClassPositionsOfNormalSubgroup( CharacterTable( Sl23 ), n );
    [ 1, 4, 7 ]
    gap> TestHomogeneous( chi, cln );
    rec( comment := "restricts irreducibly", isHomogeneous := true )
  
  
  75.3-2 IsPrimitiveCharacter
  
  IsPrimitiveCharacter( chi )  property
  
  For  a  character chi of the group G, say, IsPrimitiveCharacter returns true
  if chi is not induced from any proper subgroup, and false otherwise.
  
    Example  
    gap> IsPrimitive( Irr( Sl23 )[4] );
    true
    gap> IsPrimitive( Irr( Sl23 )[7] );
    false
  
  
  75.3-3 TestQuasiPrimitive
  
  TestQuasiPrimitive( chi )  attribute
  IsQuasiPrimitive( chi )  property
  
  TestQuasiPrimitive  returns a record with information about quasiprimitivity
  of  the  group  character  chi, i.e., whether chi restricts homogeneously to
  every  normal subgroup of its group. The result record contains at least the
  components isQuasiPrimitive (with value either true or false) and comment (a
  string telling a reason for the value of the component isQuasiPrimitive). If
  chi  is not quasiprimitive then there is additionally a component character,
  with  value  an  irreducible  constituent of a nonhomogeneous restriction of
  chi.
  
  IsQuasiPrimitive  returns  true or false, depending on whether the character
  chi is quasiprimitive.
  
  Note  that  for solvable groups, quasiprimitivity is the same as primitivity
  (see IsPrimitiveCharacter (75.3-2)).
  
    Example  
    gap> chi:= Irr( Sl23 )[4];
    Character( CharacterTable( SL(2,3) ), [ 2, 1, 1, -2, -1, -1, 0 ] )
    gap> TestQuasiPrimitive( chi );
    rec( comment := "all restrictions checked", isQuasiPrimitive := true )
    gap> chi:= Irr( Sl23 )[7];
    Character( CharacterTable( SL(2,3) ), [ 3, 0, 0, 3, 0, 0, -1 ] )
    gap> TestQuasiPrimitive( chi );
    rec( character := Character( CharacterTable( Group(
        [ [ [ 0*Z(3), Z(3) ], [ Z(3)^0, 0*Z(3) ] ], 
          [ [ Z(3), 0*Z(3) ], [ 0*Z(3), Z(3) ] ], 
          [ [ Z(3)^0, Z(3) ], [ Z(3), Z(3) ] ] ]) ),
      [ 1, -1, 1, -1, 1 ] ), comment := "restriction checked", 
      isQuasiPrimitive := false )
  
  
  75.3-4 TestInducedFromNormalSubgroup
  
  TestInducedFromNormalSubgroup( chi[, N] )  function
  IsInducedFromNormalSubgroup( chi )  property
  
  TestInducedFromNormalSubgroup  returns a record with information whether the
  irreducible  character  chi  of  the  group G, say, is induced from a proper
  normal  subgroup  of G. If the second argument N is present, which must be a
  normal  subgroup of G or the list of class positions of a normal subgroup of
  G, it is checked whether chi is induced from N.
  
  The  result  contains always the components isInduced (either true or false)
  and  comment  (a  string  telling  a  reason  for the value of the component
  isInduced). In the true case there is a component character which contains a
  character of a maximal normal subgroup from which chi is induced.
  
  IsInducedFromNormalSubgroup  returns  true  if  chi is induced from a proper
  normal subgroup of G, and false otherwise.
  
    Example  
    gap> List( Irr( Sl23 ), IsInducedFromNormalSubgroup );
    [ false, false, false, false, false, false, true ]
    gap> List( Irr( S4 ){ [ 1, 3, 4 ] },
    >          TestInducedFromNormalSubgroup );
    [ rec( comment := "linear character", isInduced := false ), 
      rec( character := Character( CharacterTable( Alt( [ 1 .. 4 ] ) ), 
            [ 1, 1, E(3)^2, E(3) ] ), 
          comment := "induced from component '.character'", 
          isInduced := true ), 
      rec( comment := "all maximal normal subgroups checked", 
          isInduced := false ) ]
  
  
  
  75.4 Testing Monomiality
  
  A  character χ of a finite group G is called monomial if χ is induced from a
  linear character of a subgroup of G. A finite group G is called monomial (or
  M-group) if each ordinary irreducible character of G is monomial.
  
  
  75.4-1 TestMonomial
  
  TestMonomial( chi )  attribute
  TestMonomial( G )  attribute
  TestMonomial( chi, uselattice )  operation
  TestMonomial( G, uselattice )  operation
  
  Called  with  a  group  character  chi  of a group G, TestMonomial returns a
  record  containing information about monomiality of the group G or the group
  character chi, respectively.
  
  If  TestMonomial  proves  the  character  chi to be monomial then the result
  contains  components isMonomial (with value true), comment (a string telling
  a  reason  for  monomiality),  and  if  it was necessary to compute a linear
  character from which chi is induced, also a component character.
  
  If  TestMonomial  proves  chi  or  G to be nonmonomial then the value of the
  component  isMonomial is false, and in the case of G a nonmonomial character
  is  the value of the component character if it had been necessary to compute
  it.
  
  A  Boolean can be entered as the second argument uselattice; if the value is
  true then the subgroup lattice of the underlying group is used if necessary,
  if  the  value is false then the subgroup lattice is used only for groups of
  order   at  most  TestMonomialUseLattice  (75.4-2).  The  default  value  of
  uselattice is false.
  
  For  a group whose lattice must not be used, it may happen that TestMonomial
  cannot  prove  or  disprove monomiality; then the result record contains the
  component  isMonomial  with  value  "?".  This case occurs in the call for a
  character chi if and only if chi is not induced from the inertia subgroup of
  a component of any reducible restriction to a normal subgroup. It can happen
  that  chi is monomial in this situation. For a group, this case occurs if no
  irreducible character can be proved to be nonmonomial, and if no decision is
  possible for at least one irreducible character.
  
    Example  
    gap> TestMonomial( S4 );
    rec( comment := "abelian by supersolvable group", isMonomial := true )
    gap> TestMonomial( Sl23 );
    rec( comment := "list Delta( G ) contains entry > 1", 
      isMonomial := false )
  
  
  75.4-2 TestMonomialUseLattice
  
  TestMonomialUseLattice global variable
  
  This  global  variable  controls for which groups the operation TestMonomial
  (75.4-1)  may  compute  the  subgroup  lattice.  The  value  can be set to a
  positive integer or infinity (18.2-1), the default is 1000.
  
  75.4-3 IsMonomialNumber
  
  IsMonomialNumber( n )  property
  
  For  a  positive  integer n, IsMonomialNumber returns true if every solvable
  group  of  order  n  is  monomial,  and  false  otherwise.  One can also use
  IsMonomial instead.
  
  Let  ν_p(n)  denote  the  multiplicity  of  the  prime p as factor of n, and
  ord(p,q) the multiplicative order of p mod q.
  
  Then there exists a solvable nonmonomial group of order n if and only if one
  of the following conditions is satisfied.
  
  1.
        ν_2(n) ≥ 2 and there is a p such that ν_p(n) ≥ 3 and p ≡ -1 mod 4,
  
  2.
        ν_2(n) ≥ 3 and there is a p such that ν_p(n) ≥ 3 and p ≡ 1 mod 4,
  
  3.
        there  are  odd prime divisors p and q of n such that ord(p,q) is even
        and ord(p,q) < ν_p(n) (especially ν_p(n) ≥ 3),
  
  4.
        there  is  a  prime  divisor  q of n such that ν_2(n) ≥ 2 ord(2,q) + 2
        (especially ν_2(n) ≥ 4),
  
  5.
        ν_2(n)  ≥  2  and there is a p such that p ≡ 1 mod 4, ord(p,q) is odd,
        and 2 ord(p,q) < ν_p(n) (especially ν_p(n) ≥ 3).
  
  These  five  possibilities  correspond to the five types of solvable minimal
  nonmonomial  groups (see MinimalNonmonomialGroup (75.5-2)) that can occur as
  subgroups and factor groups of groups of order n.
  
    Example  
    gap> Filtered( [ 1 .. 111 ], x -> not IsMonomial( x ) );
    [ 24, 48, 72, 96, 108 ]
  
  
  
  75.4-4 TestMonomialQuick
  
  TestMonomialQuick( chi )  attribute
  TestMonomialQuick( G )  attribute
  
  TestMonomialQuick  does  some  cheap tests whether the irreducible character
  chi  or  the  group  G,  respectively,  is  monomial.  Here  cheap  means in
  particular  that no computations of character tables are involved, and it is
  not  checked whether chi is a character and irreducible. The return value is
  a record with components
  
  isMonomial
        either  true  or  false  or  the  string  "?",  depending  on  whether
        (non)monomiality could be proved, and
  
  comment
        a string telling the reason for the value of the isMonomial component.
  
  A group G is proved to be monomial by TestMonomialQuick if G is nilpotent or
  Sylow  abelian  by  supersolvable,  or if G is solvable and its order is not
  divisible by the third power of a prime, Nonsolvable groups are proved to be
  nonmonomial by TestMonomialQuick.
  
  An irreducible character chi is proved to be monomial if 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
  TestMonomialQuick.
  
    Example  
    gap> TestMonomialQuick( Irr( S4 )[3] );
    rec( comment := "whole group is monomial", isMonomial := true )
    gap> TestMonomialQuick( S4 );
    rec( comment := "abelian by supersolvable group", isMonomial := true )
    gap> TestMonomialQuick( Sl23 );
    rec( comment := "no decision by cheap tests", isMonomial := "?" )
  
  
  
  75.4-5 TestSubnormallyMonomial
  
  TestSubnormallyMonomial( G )  attribute
  TestSubnormallyMonomial( chi )  attribute
  IsSubnormallyMonomial( G )  property
  IsSubnormallyMonomial( chi )  property
  
  An  irreducible  character of the group G is called subnormally monomial (SM
  for  short) if it is induced from a linear character of a subnormal subgroup
  of G. A group G is called SM if all its irreducible characters are SM.
  
  TestSubnormallyMonomial  returns a record with information whether the group
  G or the irreducible character chi of G is SM.
  
  The  result  has the components isSubnormallyMonomial (either true or false)
  and  comment  (a  string  telling  a  reason  for the value of the component
  isSubnormallyMonomial); in the case that the isSubnormallyMonomial component
  has  value  false  there  is  also  a  component  character,  with  value an
  irreducible character of G that is not SM.
  
  IsSubnormallyMonomial returns true if the group G or the group character chi
  is subnormally monomial, and false otherwise.
  
    Example  
    gap> TestSubnormallyMonomial( S4 );
    rec( character := Character( CharacterTable( S4 ), [ 3, -1, -1, 0, 1 
         ] ), comment := "found non-SM character", 
      isSubnormallyMonomial := false )
    gap> TestSubnormallyMonomial( Irr( S4 )[4] );
    rec( comment := "all subnormal subgroups checked", 
      isSubnormallyMonomial := false )
    gap> TestSubnormallyMonomial( DerivedSubgroup( S4 ) );
    rec( comment := "all irreducibles checked", 
      isSubnormallyMonomial := true )
  
  
  
  75.4-6 TestRelativelySM
  
  TestRelativelySM( G )  attribute
  TestRelativelySM( chi )  attribute
  TestRelativelySM( G, N )  operation
  TestRelativelySM( chi, N )  operation
  IsRelativelySM( G )  property
  IsRelativelySM( chi )  property
  
  In  the  first two cases, TestRelativelySM returns a record with information
  whether the argument, which must be a SM group G or an irreducible character
  chi  of a SM group G, is relatively SM with respect to every normal subgroup
  of G.
  
  In  the  second  two cases, a normal subgroup N of G is the second argument.
  Here  TestRelativelySM  returns  a record with information whether the first
  argument  is  relatively  SM  with  respect  to  N,  i.e, whether there is a
  subnormal  subgroup  H  of  G  that  contains  N such that the character chi
  resp. every  irreducible  character  of G is induced from a character ψ of H
  such that the restriction of ψ to N is irreducible.
  
  The  result record has the components isRelativelySM (with value either true
  or false) and comment (a string that describes a reason). If the argument is
  a  group  G that is not relatively SM with respect to a normal subgroup then
  additionally  the  component character is bound, with value a not relatively
  SM character of such a normal subgroup.
  
  IsRelativelySM  returns  true if the SM group G or the irreducible character
  chi of the SM group G is relatively SM with respect to every normal subgroup
  of G, and false otherwise.
  
  Note that it is not checked whether G is SM.
  
    Example  
    gap> IsSubnormallyMonomial( DerivedSubgroup( S4 ) );
    true
    gap> TestRelativelySM( DerivedSubgroup( S4 ) );
    rec( 
      comment := "normal subgroups are abelian or have nilpotent factor gr\
    oup", isRelativelySM := true )
  
  
  
  75.5 Minimal Nonmonomial Groups
  
  75.5-1 IsMinimalNonmonomial
  
  IsMinimalNonmonomial( G )  property
  
  A group G is called minimal nonmonomial if it is nonmonomial, and all proper
  subgroups and factor groups are monomial.
  
    Example  
    gap> IsMinimalNonmonomial( Sl23 );  IsMinimalNonmonomial( S4 );
    true
    false
  
  
  75.5-2 MinimalNonmonomialGroup
  
  MinimalNonmonomialGroup( p, factsize )  function
  
  is a solvable minimal nonmonomial group described by the parameters factsize
  and p if such a group exists, and false otherwise.
  
  Suppose  that  the required group K exists. Then factsize is the size of the
  Fitting  factor K / F(K), and this value is 4, 8, an odd prime, twice an odd
  prime, or four times an odd prime. In the case that factsize is twice an odd
  prime,  the  centre Z(K) is cyclic of order 2^{p+1}. In all other cases p is
  the (unique) prime that divides the order of F(K).
  
  The  solvable  minimal  nonmonomial groups were classified by van der Waall,
  see [vdW76].
  
    Example  
    gap> MinimalNonmonomialGroup(  2,  3 ); # the group SL(2,3)
    2^(1+2):3
    gap> MinimalNonmonomialGroup(  3,  4 );
    3^(1+2):4
    gap> MinimalNonmonomialGroup(  5,  8 );
    5^(1+2):Q8
    gap> MinimalNonmonomialGroup( 13, 12 );
    13^(1+2):2.D6
    gap> MinimalNonmonomialGroup(  1, 14 );
    2^(1+6):D14
    gap> MinimalNonmonomialGroup(  2, 14 );
    (2^(1+6)Y4):D14