Add IsQuasisimpleGroup, IsQuasisimpleCharacterTable

doc/ref/groups.xml

@@ -342,6 +342,7 @@ as they depend on a parameter.
 <#Include Label="IsMonomialGroup">
 <#Include Label="IsSimpleGroup">
 <#Include Label="IsAlmostSimpleGroup">
+<#Include Label="IsQuasisimpleGroup">
 <#Include Label="IsomorphismTypeInfoFiniteSimpleGroup">
 <#Include Label="SimpleGroup">
 <#Include Label="SimpleGroupsIterator">

lib/ctbl.gd

@@ -1093,6 +1093,7 @@ DeclareAttributeSuppCT( "OrdinaryCharacterTable", IsGroup, [] );
 #P  IsMonomial( <tbl> )
 #P  IsNilpotent( <tbl> )
 #P  IsPerfect( <tbl> )
+#P  IsQuasisimple( <tbl> )
 #P  IsSimple( <tbl> )
 #P  IsSporadicSimple( <tbl> )
 #P  IsSupersolvable( <tbl> )
@@ -1114,6 +1115,7 @@ DeclareAttributeSuppCT( "OrdinaryCharacterTable", IsGroup, [] );
 ##  <Prop Name="IsMonomial" Arg='tbl' Label="for a character table"/>
 ##  <Prop Name="IsNilpotent" Arg='tbl' Label="for a character table"/>
 ##  <Prop Name="IsPerfect" Arg='tbl' Label="for a character table"/>
+##  <Prop Name="IsQuasisimple" Arg='tbl' Label="for a character table"/>
 ##  <Prop Name="IsSimple" Arg='tbl' Label="for a character table"/>
 ##  <Prop Name="IsSolvable" Arg='tbl' Label="for a character table"/>
 ##  <Prop Name="IsSporadicSimple" Arg='tbl' Label="for a character table"/>
@@ -1133,37 +1135,40 @@ DeclareAttributeSuppCT( "OrdinaryCharacterTable", IsGroup, [] );
 ##  <Example><![CDATA[
 ##  gap> tables:= [ CharacterTable( CyclicGroup( 3 ) ),
 ##  >               CharacterTable( SymmetricGroup( 4 ) ),
-##  >               CharacterTable( AlternatingGroup( 5 ) ) ];;
+##  >               CharacterTable( AlternatingGroup( 5 ) ),
+##  >               CharacterTable( SL( 2, 5 ) ) ];;
 ##  gap> List( tables, AbelianInvariants );
-##  [ [ 3 ], [ 2 ], [  ] ]
+##  [ [ 3 ], [ 2 ], [  ], [  ] ]
 ##  gap> List( tables, CommutatorLength );
-##  [ 1, 1, 1 ]
+##  [ 1, 1, 1, 1 ]
 ##  gap> List( tables, Exponent );
-##  [ 3, 12, 30 ]
+##  [ 3, 12, 30, 60 ]
 ##  gap> List( tables, IsAbelian );
-##  [ true, false, false ]
+##  [ true, false, false, false ]
 ##  gap> List( tables, IsAlmostSimple );
-##  [ false, false, true ]
+##  [ false, false, true, false ]
 ##  gap> List( tables, IsCyclic );
-##  [ true, false, false ]
+##  [ true, false, false, false ]
 ##  gap> List( tables, IsFinite );
-##  [ true, true, true ]
+##  [ true, true, true, true ]
 ##  gap> List( tables, IsMonomial );
-##  [ true, true, false ]
+##  [ true, true, false, false ]
 ##  gap> List( tables, IsNilpotent );
-##  [ true, false, false ]
+##  [ true, false, false, false ]
 ##  gap> List( tables, IsPerfect );
-##  [ false, false, true ]
+##  [ false, false, true, true ]
+##  gap> List( tables, IsQuasisimple );
+##  [ false, false, true, true ]
 ##  gap> List( tables, IsSimple );
-##  [ true, false, true ]
+##  [ true, false, true, false ]
 ##  gap> List( tables, IsSolvable );
-##  [ true, true, false ]
+##  [ true, true, false, false ]
 ##  gap> List( tables, IsSupersolvable );
-##  [ true, false, false ]
+##  [ true, false, false, false ]
 ##  gap> List( tables, NrConjugacyClasses );
-##  [ 3, 5, 5 ]
+##  [ 3, 5, 5, 9 ]
 ##  gap> List( tables, Size );
-##  [ 3, 24, 60 ]
+##  [ 3, 24, 60, 120 ]
 ##  gap> IsomorphismTypeInfoFiniteSimpleGroup( CharacterTable( "C5" ) );
 ##  rec( name := "Z(5)", parameter := 5, series := "Z", shortname := "C5" 
 ##   )
@@ -1205,6 +1210,7 @@ DeclareAttributeSuppCT( "Size", IsNearlyCharacterTable, [] );
 #P  IsMonomialCharacterTable( <tbl> )
 #P  IsNilpotentCharacterTable( <tbl> )
 #P  IsPerfectCharacterTable( <tbl> )
+#P  IsQuasisimpleCharacterTable( <tbl> )
 #P  IsSimpleCharacterTable( <tbl> )
 #P  IsSolvableCharacterTable( <tbl> )
 #P  IsSporadicSimpleCharacterTable( <tbl> )
@@ -1216,6 +1222,7 @@ DeclareAttributeSuppCT( "Size", IsNearlyCharacterTable, [] );
 ##  <Prop Name="IsMonomialCharacterTable" Arg='tbl'/>
 ##  <Prop Name="IsNilpotentCharacterTable" Arg='tbl'/>
 ##  <Prop Name="IsPerfectCharacterTable" Arg='tbl'/>
+##  <Prop Name="IsQuasisimpleCharacterTable" Arg='tbl'/>
 ##  <Prop Name="IsSimpleCharacterTable" Arg='tbl'/>
 ##  <Prop Name="IsSolvableCharacterTable" Arg='tbl'/>
 ##  <Prop Name="IsSolubleCharacterTable" Arg='tbl'/>
@@ -1235,6 +1242,8 @@ DeclarePropertySuppCT( "IsAlmostSimpleCharacterTable",
 DeclarePropertySuppCT( "IsMonomialCharacterTable", IsNearlyCharacterTable );
 DeclarePropertySuppCT( "IsNilpotentCharacterTable", IsNearlyCharacterTable );
 DeclarePropertySuppCT( "IsPerfectCharacterTable", IsNearlyCharacterTable );
+DeclarePropertySuppCT( "IsQuasisimpleCharacterTable",
+    IsNearlyCharacterTable );
 DeclarePropertySuppCT( "IsSimpleCharacterTable", IsNearlyCharacterTable );
 DeclarePropertySuppCT( "IsSolvableCharacterTable", IsNearlyCharacterTable );
 DeclarePropertySuppCT( "IsSporadicSimpleCharacterTable",
@@ -1253,7 +1262,7 @@ InstallTrueMethod( IsMonomialCharacterTable,
 InstallTrueMethod( IsNilpotentCharacterTable,
     IsOrdinaryTable and IsAbelian );
 InstallTrueMethod( IsPerfectCharacterTable,
-    IsOrdinaryTable and IsSimpleCharacterTable );
+    IsOrdinaryTable and IsQuasisimpleCharacterTable );
 InstallTrueMethod( IsSimpleCharacterTable,
     IsOrdinaryTable and IsSporadicSimpleCharacterTable );
 InstallTrueMethod( IsSolvableCharacterTable,
@@ -1620,8 +1629,8 @@ DeclareAttributeSuppCT( "CharacterParameters", IsNearlyCharacterTable,
 ##  "A5"
 ##  gap> tbl:= CharacterTable( Group( () ) );;
 ##  gap> Identifier( tbl );  Identifier( tbl mod 2 );
-##  "CT8"
-##  "CT8mod2"
+##  "CT9"
+##  "CT9mod2"
 ##  ]]></Example>
 ##  </Description>
 ##  </ManSection>

lib/ctbl.gi

@@ -1338,6 +1338,17 @@ InstallMethod( IsAlmostSimpleCharacterTable,
     end );
 
 
+#############################################################################
+##
+#M  IsQuasisimpleCharacterTable( <tbl> )  . . for an ordinary character table
+##
+InstallMethod( IsQuasisimpleCharacterTable,
+    "for an ordinary character table",
+    [ IsOrdinaryTable ],
+    ordtbl -> IsPerfectCharacterTable( ordtbl ) and
+       IsSimpleCharacterTable( ordtbl / ClassPositionsOfCentre( ordtbl ) ) );
+
+
 #############################################################################
 ##
 #M  IsSolvableCharacterTable( <tbl> ) . . . . for an ordinary character table

lib/grp.gd

@@ -716,7 +716,7 @@ InstallIsomorphismMaintenance( IsSporadicSimpleGroup, IsGroup, IsGroup );
 ##  true
 ##  gap> IsAlmostSimpleGroup( SymmetricGroup( 3 ) );
 ##  false
-##  gap> IsAlmostSimpleGroup( SL( 2, 5 ) );            
+##  gap> IsAlmostSimpleGroup( SL( 2, 5 ) );
 ##  false
 ##  ]]></Example>
 ##  </Description>
@@ -729,6 +729,43 @@ InstallTrueMethod( IsGroup and IsNonTrivial, IsAlmostSimpleGroup );
 # nonabelian simple groups are almost simple
 InstallTrueMethod( IsAlmostSimpleGroup, IsNonabelianSimpleGroup );
 
+#############################################################################
+##
+#P  IsQuasisimpleGroup( <G> )
+##
+##  <#GAPDoc Label="IsQuasisimpleGroup">
+##  <ManSection>
+##  <Prop Name="IsQuasisimpleGroup" Arg='G'/>
+##
+##  <Description>
+##  A group <A>G</A> is <E>quasisimple</E> if <A>G</A> is perfect
+##  (see <Ref Prop="IsPerfectGroup"/>)
+##  and if <A>G</A><M>/Z(</M><A>G</A><M>)</M> is simple
+##  (see <Ref Prop="IsSimpleGroup"/>), where <M>Z(</M><A>G</A><M>)</M>
+##  is the centre of <A>G</A> (see <Ref Attr="Centre"/>).
+##  <P/>
+##  <Example><![CDATA[
+##  gap> IsQuasisimpleGroup( AlternatingGroup( 5 ) );
+##  true
+##  gap> IsQuasisimpleGroup( SymmetricGroup( 5 ) );
+##  false
+##  gap> IsQuasisimpleGroup( SL( 2, 5 ) );
+##  true
+##  ]]></Example>
+##  </Description>
+##  </ManSection>
+##  <#/GAPDoc>
+##
+DeclareProperty( "IsQuasisimpleGroup", IsGroup );
+InstallTrueMethod( IsGroup and IsNonTrivial, IsQuasisimpleGroup );
+
+# Nonabelian simple groups are quasisimple, quasisimple groups are perfect.
+InstallTrueMethod( IsQuasisimpleGroup, IsNonabelianSimpleGroup );
+InstallTrueMethod( IsPerfectGroup, IsQuasisimpleGroup );
+
+# We can expect that people will try the name with capital s.
+DeclareSynonymAttr( "IsQuasiSimpleGroup", IsQuasisimpleGroup );
+
 #############################################################################
 ##
 #P  IsSupersolvableGroup( <G> )
@@ -1901,9 +1938,9 @@ DeclareAttribute( "MinimalNormalSubgroups", IsGroup );
 ##  <Description>
 ##  returns a list of all normal subgroups of <A>G</A>.
 ##  <Example><![CDATA[
-##  gap> g:=SymmetricGroup(4);; NormalSubgroups(g);
-##  [ Sym( [ 1 .. 4 ] ), Alt( [ 1 .. 4 ] ),
-##    Group([ (1,4)(2,3), (1,2)(3,4) ]), Group(()) ]
+##  gap> g:=SymmetricGroup(4);;
+##  gap> List( NormalSubgroups(g), StructureDescription );
+##  [ "S4", "A4", "C2 x C2", "1" ]
 ##  gap> g:=AbelianGroup([2,2]);; NormalSubgroups(g);
 ##  [ <pc group of size 4 with 2 generators>, Group([ f2 ]),
 ##    Group([ f1*f2 ]), Group([ f1 ]), Group([  ]) ]
@@ -1929,9 +1966,9 @@ DeclareAttribute( "NormalSubgroups", IsGroup );
 ##  returns a list of all characteristic subgroups of <A>G</A>, that is
 ##  subgroups that are invariant under all automorphisms.
 ##  <Example><![CDATA[
-##  gap> g:=SymmetricGroup(4);; CharacteristicSubgroups(g);
-##  [ Sym( [ 1 .. 4 ] ), Group([ (2,4,3), (1,4)(2,3), (1,3)(2,4) ]), 
-##    Group([ (1,4)(2,3), (1,3)(2,4) ]), Group(()) ]
+##  gap> g:=SymmetricGroup(4);;
+##  gap> List( CharacteristicSubgroups(g), StructureDescription );
+##  [ "S4", "A4", "C2 x C2", "1" ]
 ##  gap> g:=AbelianGroup([2,2]);; CharacteristicSubgroups(g);
 ##  [ <pc group of size 4 with 2 generators>, Group([  ]) ]
 ##  ]]></Example>
@@ -3269,8 +3306,8 @@ DeclareOperation("CentralizerModulo", [IsGroup,IsGroup,IsObject]);
 ##  gap> PCentralSeries(g,2);
 ##  [ <pc group of size 12 with 3 generators>, Group([ y3, y*y3 ]), Group([ y*y3 ]) ]
 ##  gap> g:=SymmetricGroup(4);;
-##  gap> PCentralSeries(g,2);
-##  [ Sym( [ 1 .. 4 ] ), Group([ (1,2,3), (2,3,4) ]) ]
+##  gap> List(PCentralSeries(g,2), StructureDescription);
+##  [ "S4", "A4" ]
 ##  ]]></Example>
 ##  </Description>
 ##  </ManSection>

lib/grp.gi

@@ -546,6 +546,16 @@ InstallMethod( IsAlmostSimpleGroup,
     end );
 
 
+#############################################################################
+##
+#P  IsQuasisimpleGroup( <G> )
+##
+InstallMethod( IsQuasisimpleGroup,
+    "for a group",
+    [ IsGroup ],
+    G -> IsPerfectGroup( G ) and IsSimpleGroup( G / Centre( G ) ) );
+
+
 #############################################################################
 ##
 #M  IsSolvableGroup( <G> )  . . . . . . . . . . . test if a group is solvable

lib/overload.g

@@ -231,6 +231,22 @@ InstallMethod( IsAlmostSimple, [ IsOrdinaryTable ],
     IsAlmostSimpleCharacterTable );
 
 
+#############################################################################
+##
+#O  IsQuasisimple( <obj> )
+##
+##  is `true' if <obj> is a quasisimple group
+##  or a quasisimple character table or ...
+##
+DeclareOperation( "IsQuasisimple", [ IsObject ] );
+
+DeclareSynonym( "IsQuasiSimple", IsQuasisimple );
+
+InstallMethod( IsQuasisimple, [ IsGroup ], IsQuasisimpleGroup );
+InstallMethod( IsQuasisimple, [ IsOrdinaryTable ],
+    IsQuasisimpleCharacterTable );
+
+
 #############################################################################
 ##
 #O  IsSolvable( <obj> )

tst/testinstall/ctbl.tst

@@ -322,5 +322,12 @@ gap> t:= CharacterTable( g );;
 gap> ClassPositionsOfSupersolvableResiduum( t );
 [ 1, 5, 6 ]
 
+# test another bugfix ('IsSimple' does not imply 'IsPerfect')
+gap> t:= CharacterTable( CyclicGroup( 2 ) );;
+gap> IsSimpleCharacterTable( t );
+true
+gap> IsPerfectCharacterTable( t );
+false
+
 ##
 gap> STOP_TEST( "ctbl.tst" );