67.7 Attributes and Properties of Character Tables

In the first two forms, CharacterDegrees returns a collected list of the degrees of the absolutely irreducible characters of the group G; the optional second argument p must be either zero or a prime integer denoting the characteristic, the default value is zero. In the third form, tbl must be an (ordinary or Brauer) character table, and CharacterDegrees returns a collected list of the degrees of the absolutely irreducible characters of tbl.

(The default method for the call with only argument a group is to call the operation with second argument 0.)

For solvable groups, the default method is based on Con90b.

gap> CharacterDegrees( SymmetricGroup( 4 ) );
[ [ 1, 2 ], [ 2, 1 ], [ 3, 2 ] ]
gap> CharacterDegrees( SymmetricGroup( 4 ), 2 );
[ [ 1, 1 ], [ 2, 1 ] ]
gap> CharacterDegrees( CharacterTable( "A5" ) );
[ [ 1, 1 ], [ 3, 2 ], [ 4, 1 ], [ 5, 1 ] ]
gap> CharacterDegrees( CharacterTable( "A5" ) mod 2 );
[ [ 1, 1 ], [ 2, 2 ], [ 4, 1 ] ]

Called with a group G, Irr returns the irreducible characters of the ordinary character table of G. Called with a group G and a prime integer p, Irr returns the irreducible characters of the p-modular Brauer table of G. Called with an (ordinary or Brauer) character table tbl, Irr returns the list of all complex absolutely irreducible characters of tbl.

For a character table tbl with underlying group, Irr may delegate to the group. For a group G, Irr may delegate to its character table only if the irreducibles are already stored there.

(If G is p-solvable (see IsPSolvable) then the p-modular irreducible characters can be computed by the Fong-Swan Theorem; in all other cases, there may be no method.)

Note that the ordering of columns in the Irr matrix of the group G refers to the ordering of conjugacy classes in CharacterTable( G ), which may differ from the ordering of conjugacy classes in G (see The Interface between Character Tables and Groups). As an extreme example, for a character table obtained from sorting the classes of CharacterTable( G ), the ordering of columns in the Irr matrix respects the sorting of classes (see Sorted Character Tables), so the irreducibles of such a table will in general not coincide with the irreducibles stored as Irr( G ) although also the sorted table stores the group G.

gap> Irr( SymmetricGroup( 4 ) );
[ Character( CharacterTable ( Sym( [ 1 .. 4 ] )), [ 1, 1, 1, 1, 1 ] ), 
  Character( CharacterTable ( Sym( [ 1 .. 4 ] )), [ 1, -1, 1, 1, -1 ] ), 
  Character( CharacterTable ( Sym( [ 1 .. 4 ] )), [ 2, 0, 2, -1, 0 ] ), 
  Character( CharacterTable ( Sym( [ 1 .. 4 ] )), [ 3, -1, -1, 0, 1 ] ), 
  Character( CharacterTable ( Sym( [ 1 .. 4 ] )), [ 3, 1, -1, 0, -1 ] ) ]
gap> Irr( SymmetricGroup( 4 ), 2 );
[ Character( BrauerTable( Sym( [ 1 .. 4 ] ), 2 ), [ 1, 1 ] ), 
  Character( BrauerTable( Sym( [ 1 .. 4 ] ), 2 ), [ 2, -1 ] ) ]
gap> Irr( CharacterTable( "A5" ) );
[ Character( CharacterTable( "A5" ), [ 1, 1, 1, 1, 1 ] ), 
  Character( CharacterTable( "A5" ), [ 3, -1, 0, -E(5)-E(5)^4, -E(5)^2-E(5)^3 
     ] ), Character( CharacterTable( "A5" ), 
    [ 3, -1, 0, -E(5)^2-E(5)^3, -E(5)-E(5)^4 ] ), 
  Character( CharacterTable( "A5" ), [ 4, 0, 1, -1, -1 ] ), 
  Character( CharacterTable( "A5" ), [ 5, 1, -1, 0, 0 ] ) ]
gap> Irr( CharacterTable( "A5" ) mod 2 );
[ Character( BrauerTable( "A5", 2 ), [ 1, 1, 1, 1 ] ), 
  Character( BrauerTable( "A5", 2 ), [ 2, -1, E(5)+E(5)^4, E(5)^2+E(5)^3 ] ), 
  Character( BrauerTable( "A5", 2 ), [ 2, -1, E(5)^2+E(5)^3, E(5)+E(5)^4 ] ), 
  Character( BrauerTable( "A5", 2 ), [ 4, 1, -1, -1 ] ) ]

LinearCharacters returns the linear (i.e., degree 1) characters in the Irr (see Irr) list of the group G or the character table tbl, respectively. In the second form, LinearCharacters returns the p-modular linear characters of the group G.

For a character table tbl with underlying group, LinearCharacters may delegate to the group. For a group G, LinearCharacters may delegate to its character table only if the irreducibles are already stored there.

The ordering of linear characters in tbl need not coincide with the ordering of linear characters in the irreducibles of tbl (see Irr).

gap> LinearCharacters( SymmetricGroup( 4 ) );
[ Character( CharacterTable ( Sym( [ 1 .. 4 ] )), [ 1, 1, 1, 1, 1 ] ), 
  Character( CharacterTable ( Sym( [ 1 .. 4 ] )), [ 1, -1, 1, 1, -1 ] ) ]

OrdinaryCharacterTable returns the ordinary character table of the group G or the Brauer character table modtbl, respectively.

Since Brauer character tables are constructed from ordinary tables, the attribute value for modtbl is already stored (cf. Character Table Categories).

gap> OrdinaryCharacterTable( SymmetricGroup( 4 ) );
CharacterTable( Sym( [ 1 .. 4 ] ) )
gap> tbl:= CharacterTable( "A5" );;  modtbl:= tbl mod 2;
BrauerTable( "A5", 2 )
gap> OrdinaryCharacterTable( modtbl ) = tbl;
true

The following operations for groups are applicable to character tables and mean the same for a character table as for the group; see the chapter about groups for the definition.

AbelianInvariantsindexAbelianInvariants!for character tables

CommutatorLengthindexCommutatorLength!for character tables

ExponentindexExponent!for character tables

IsAbelianindexIsAbelian!for character tables

IsCyclicindexIsCyclic!for character tables

IsFiniteindexIsFinite!for character tables

IsMonomialindexIsMonomial!for character tables

IsNilpotentindexIsNilpotent!for character tables

IsPerfectindexIsPerfect!for character tables

IsSimpleindexIsSimple!for character tables

IsSolvableindexIsSolvable!for character tables

IsSupersolvableindexIsSupersolvable!for character tables

NrConjugacyClassesindexNrConjugacyClasses!for character tables

SizeindexSize!for character tables

gap> tables:= [ CharacterTable( CyclicGroup( 3 ) ),
>               CharacterTable( SymmetricGroup( 4 ) ), 
>               CharacterTable( AlternatingGroup( 5 ) ) ];;
gap> List( tables, AbelianInvariants );
[ [ 3 ], [ 2 ], [  ] ]
gap> List( tables, CommutatorLength );
[ 1, 1, 1 ]
gap> List( tables, Exponent );
[ 3, 12, 30 ]
gap> List( tables, IsAbelian );
[ true, false, false ]
gap> List( tables, IsCyclic );
[ true, false, false ]
gap> List( tables, IsFinite );
[ true, true, true ]
gap> List( tables, IsMonomial );
[ true, true, false ]
gap> List( tables, IsNilpotent );
[ true, false, false ]
gap> List( tables, IsPerfect );
[ false, false, true ]
gap> List( tables, IsSimple );
[ true, false, true ]
gap> List( tables, IsSolvable );
[ true, true, false ]
gap> List( tables, IsSupersolvable );
[ true, false, false ]
gap> List( tables, NrConjugacyClasses );
[ 3, 5, 5 ]
gap> List( tables, Size );
[ 3, 24, 60 ]

The following three attributes for character tables would make sense also for groups but are in fact not used for groups. This is because the values depend on the ordering of conjugacy classes stored as value of ConjugacyClasses, and this value may differ for a group and its character table (see The Interface between Character Tables and Groups). Note that for character tables, the consistency of attribute values must be guaranteed, whereas for groups, there is no need to impose such a consistency rule.

is a list of orders of representatives of conjugacy classes of the character table tbl, in the same ordering as the conjugacy classes of tbl.

is a list that stores at position i the size of the centralizer of any element in the i-th conjugacy class of the character table tbl.

is a list that stores at position i the size of the i-th conjugacy class of the character table tbl.

gap> tbl:= CharacterTable( "A5" );;
gap> OrdersClassRepresentatives( tbl );
[ 1, 2, 3, 5, 5 ]
gap> SizesCentralizers( tbl );
[ 60, 4, 3, 5, 5 ]
gap> SizesConjugacyClasses( tbl );
[ 1, 15, 20, 12, 12 ]

The following attributes apply only to character tables, not to groups.

is the permutation group of all column permutations of the character table tbl that leave the set of irreducibles and each power map of tbl invariant (see also TableAutomorphisms).

gap> tbl:= CharacterTable( "Dihedral", 8 );;
gap> AutomorphismsOfTable( tbl );
Group([ (4,5) ])
gap> OrdersClassRepresentatives( tbl );
[ 1, 4, 2, 2, 2 ]
gap> SizesConjugacyClasses( tbl );
[ 1, 2, 1, 2, 2 ]

For an ordinary character table tbl, the result is 0, for a p-modular Brauer table tbl, it is p. The underlying characteristic of a class function psi is equal to that of its underlying character table.

The underlying characteristic must be stored when the table is constructed, there is no method to compute it.

We cannot use the attribute Characteristic (see Characteristic) to denote this, since of course each Brauer character is an element of characteristic zero in the sense of GAP (see Chapter Class Functions).

gap> tbl:= CharacterTable( "A5" );;
gap> UnderlyingCharacteristic( tbl );
0
gap> UnderlyingCharacteristic( tbl mod 17 );
17

ClassNames and CharacterNames return lists of strings, one for each conjugacy class or irreducible character, respectively, of the character table tbl. These names are used when tbl is displayed.

The default method for ClassNames computes class names consisting of the order of an element in the class and at least one distinguishing letter. There is no default method for CharacterNames.

The position of the class with name name in tbl can be accessed as tbl.name.

When ClassNames is called with two arguments, the second being the string "ATLAS", the class names returned obey the convention used in Chapter 7, Section 5 of the ATLAS of Finite Groups CCN85.

gap> tbl:= CharacterTable( "A5" );;
gap> ClassNames( tbl );
[ "1a", "2a", "3a", "5a", "5b" ]
gap> tbl.2a;
2

is a string that identifies the character table tbl in the current GAP session. It is used mainly for class fusions into tbl that are stored on other character tables. For character tables without group, the identifier is also used to print the table; this is the case for library tables, but also for tables that are constructed as direct products, factors etc. involving tables that may or may not store their groups.

The default method for ordinary tables constructs strings of the form "CTn", where n is a positive integer. LARGEST_IDENTIFIER_NUMBER is a list containing the largest integer n used in the current GAP session.

The default method for Brauer tables returns the concatenation of the identifier of the ordinary table, the string "mod", and the (string of the) underlying characteristic.

gap> Identifier( CharacterTable( "A5" ) );
"A5"
gap> g:= Group( () );;  HasName( g );
false
gap> SetName( g, "g" );
gap> Identifier( CharacterTable( g ) );
"g"
gap> tbl:= CharacterTable( Group( () ) );;
gap> Identifier( tbl );  Identifier( tbl mod 2 );
"CT8"
"CT8mod2"

is a mutable string with information about the character table tbl. There is no default method to create an info text.

Usual parts of the information are the origin of the table (see The Character Table Library), tests it has passed (1.o.r. for the test of orthogonality, pow[p] for the construction of the p-th power map, DEC for the decomposition of ordinary into Brauer characters, TENS for the decomposition of tensor products of irreducibles), and choices made without loss of generality.

gap> Print( InfoText( CharacterTable( "A5" ) ), "\n" );
origin: ATLAS of finite groups, tests: 1.o.r., pow[2,3,5]

For a character table tbl, InverseClasses returns the list mapping each conjugacy class to its inverse class. This list can be regarded as (-1)-st power map of tbl (see PowerMap).

For a character table tbl, RealClasses returns the strictly sorted list of positions of classes in tbl that consist of real elements.

An element x is real iff it is conjugate to its inverse x^-1 = x^o(x)-1.

gap> InverseClasses( CharacterTable( "A5" ) );
[ 1, 2, 3, 4, 5 ]
gap> InverseClasses( CharacterTable( "Cyclic", 3 ) );
[ 1, 3, 2 ]
gap> RealClasses( CharacterTable( "A5" ) );
[ 1, 2, 3, 4, 5 ]
gap> RealClasses( CharacterTable( "Cyclic", 3 ) );
[ 1 ]

is the list of positions of those conjugacy classes of the character table tbl that are Galois conjugate to the cc-th class. That is, exactly the classes at positions given by the list returned by ClassOrbit contain generators of the cyclic group generated by an element in the cc-th class.

This information is computed from the power maps of tbl.

For a character table tbl, ClassRoots returns a list containing at position i the list of positions of the classes of all nontrivial p-th roots, where p runs over the prime divisors of Size( tbl ).

This information is computed from the power maps of tbl.

gap> ClassOrbit( CharacterTable( "A5" ), 4 );
[ 4, 5 ]
gap> ClassRoots( CharacterTable( "A5" ) );
[ [ 2, 3, 4, 5 ], [  ], [  ], [  ], [  ] ]
gap> ClassRoots( CharacterTable( "Cyclic", 6 ) );
[ [ 3, 4, 5 ], [  ], [ 2 ], [ 2, 6 ], [ 6 ], [  ] ]

The following attributes for a character table tbl correspond to attributes for the group G of tbl. But instead of a normal subgroup (or a list of normal subgroups) of G, they return a strictly sorted list of positive integers (or a list of such lists) which are the positions --relative to ConjugacyClasses( tbl )-- of those classes forming the normal subgroup in question.

correspond to NormalSubgroups and MaximalNormalSubgroups for the group of the ordinary character table ordtbl (see NormalSubgroups, MaximalNormalSubgroups).

The entries of the result lists are sorted according to increasing length. (So this total order respects the partial order of normal subgroups given by inclusion.)

corresponds to Agemo (see Agemo) for the group of the ordinary character table ordtbl.

corresponds to Centre (see Centre) for the group of the ordinary character table ordtbl.

Let tbl be the ordinary character table of the group G, say. Called with the only argument tbl, ClassPositionsOfDirectProductDecompositions returns the list of all those pairs [ l₁, l₂ ] where l₁ and l₂ are lists of class positions of normal subgroups N₁, N₂ of G such that G is their direct product and |N₁| £ |N₂| holds. Called with second argument a list nclasses of class positions of a normal subgroup N of G, ClassPositionsOfDirectProductDecompositions returns the list of pairs describing the decomposition of N as a direct product of two normal subgroups of G.

corresponds to DerivedSubgroup (see DerivedSubgroup) for the group of the ordinary character table ordtbl.

corresponds to ElementaryAbelianSeries (see ElementaryAbelianSeries) for the group of the ordinary character table ordtbl.

corresponds to FittingSubgroup (see FittingSubgroup) for the group of the ordinary character table ordtbl.

corresponds to LowerCentralSeries (see LowerCentralSeriesOfGroup) for the group of the ordinary character table ordtbl.

corresponds to UpperCentralSeries (see UpperCentralSeriesOfGroup) for the group of the ordinary character table ordtbl.

corresponds to SupersolvableResiduum (see SupersolvableResiduum) for the group of the ordinary character table ordtbl.

is the sorted list of the positions of all conjugacy classes of the ordinary character table ordtbl that form the normal closure (see NormalClosure) of the conjugacy classes at positions in the list classes.

gap> tbla5:= CharacterTable( "A5" );;
gap> tbls4:= CharacterTable( "Symmetric", 4 );;
gap> tbld8:= CharacterTable( "Dihedral", 8 );;
gap> ClassPositionsOfNormalSubgroups( tbls4 );
[ [ 1 ], [ 1, 3 ], [ 1, 3, 4 ], [ 1, 2, 3, 4, 5 ] ]
gap> ClassPositionsOfAgemo( tbls4, 2 );
[ 1, 3, 4 ]
gap> ClassPositionsOfCentre( tbld8 );
[ 1, 3 ]
gap> ClassPositionsOfDerivedSubgroup( tbld8 );
[ 1, 3 ]
gap> ClassPositionsOfElementaryAbelianSeries( tbls4 );
[ [ 1 .. 5 ], [ 1, 3, 4 ], [ 1, 3 ], [ 1 ] ]
gap> ClassPositionsOfElementaryAbelianSeries( tbla5 );
fail
gap> ClassPositionsOfFittingSubgroup( tbls4 );
[ 1, 3 ]
gap> ClassPositionsOfLowerCentralSeries( tbls4 );
[ [ 1 .. 5 ], [ 1, 3, 4 ] ]
gap> ClassPositionsOfLowerCentralSeries( tbld8 );
[ [ 1 .. 5 ], [ 1, 3 ], [ 1 ] ]
gap> ClassPositionsOfUpperCentralSeries( tbls4 );
[ [ 1 ] ]
gap> ClassPositionsOfUpperCentralSeries( tbld8 );
[ [ 1, 3 ], [ 1, 2, 3, 4, 5 ] ]
gap> ClassPositionsOfSupersolvableResiduum( tbls4 );
[ 1, 3 ]
gap> ClassPositionsOfNormalClosure( tbls4, [ 1, 4 ] );
[ 1, 3, 4 ]

[Top] [Previous] [Up] [Next] [Index]