In principle it is possible to represent group characters or more general class functions by the plain lists of their values, and in fact many operations for class functions work with plain lists of class function values. But this has two disadvantages.
First, it is then necessary to regard a values list explicitly as a class function of a particular character table, by supplying this character table as an argument. In practice this means that with this setup, the user has the task to put the objects into the right context. For example, forming the scalar product or the tensor product of two class functions or forming an induced class function or a conjugate class function then needs three arguments in this case; this is particularly inconvenient in cases where infix operations cannot be used because of the additional argument, as for tensor products and induced class functions.
Second, when one says that `` c is a character of a group G'' then this object c carries a lot of information. c has certain properties such as being irreducible or not. Several subgroups of G are related to c, such as the kernel and the centre of c. Other attributes of characters are the determinant and the central character. This knowledge cannot be stored in a plain list.
For dealing with a group together with its characters, and maybe also subgroups and their characters, it is desirable that GAP keeps track of the interpretation of characters. On the other hand, for using characters without accessing their groups, such as characters of tables from the GAP table library, dealing just with values lists is often sufficient. In particular, if one deals with incomplete character tables then it is often necessary to specify the arguments explicitly, for example one has to choose a fusion map or power map from a set of possibilities.
The main idea behind class function objects is that a class function
object is equal to its values list in the sense of \=,
so class function objects can be used whereever their values lists
can be used,
but there are operations for class function objects that do not work
just with values lists.
GAP library functions prefer to return class function objects
rather than returning just values lists,
for example Irr lists (see Irr) consist of class function objects,
and TrivialCharacter (see TrivialCharacter) returns a class function
object.
Here is an example that shows both approaches. First we define some groups.
gap> S4:= SymmetricGroup( 4 );; SetName( S4, "S4" ); gap> D8:= SylowSubgroup( S4, 2 );; SetName( D8, "D8" );
We do some computations using the functions described later in this Chapter, first with class function objects.
gap> irrS4:= Irr( S4 );; gap> irrD8:= Irr( D8 );; gap> chi:= irrD8[3]; Character( CharacterTable( D8 ), [ 1, 1, 1, -1, -1 ] ) gap> chi * chi; Character( CharacterTable( D8 ), [ 1, 1, 1, 1, 1 ] ) gap> ind:= chi ^ S4; Character( CharacterTable( S4 ), [ 3, 1, -1, 0, -1 ] ) gap> List( irrS4, x -> ScalarProduct( x, ind ) ); [ 0, 0, 0, 0, 1 ] gap> det:= Determinant( ind ); Character( CharacterTable( S4 ), [ 1, -1, 1, 1, -1 ] ) gap> cent:= CentralCharacter( ind ); ClassFunction( CharacterTable( S4 ), [ 1, 2, -1, 0, -2 ] ) gap> rest:= Restricted( cent, D8 ); ClassFunction( CharacterTable( D8 ), [ 1, 2, -1, -1, -2 ] )
Now we repeat these calculations with plain lists of character values. Here we need the character tables in some places.
gap> tS4:= CharacterTable( S4 );; gap> tD8:= CharacterTable( D8 );; gap> chi:= ValuesOfClassFunction( irrD8[3] ); [ 1, 1, 1, -1, -1 ] gap> Tensored( [ chi ], [ chi ] )[1]; [ 1, 1, 1, 1, 1 ] gap> ind:= InducedClassFunction( tD8, chi, tS4 ); ClassFunction( CharacterTable( S4 ), [ 3, 1, -1, 0, -1 ] ) gap> List( Irr( tS4 ), x -> ScalarProduct( tS4, x, ind ) ); [ 0, 0, 0, 0, 1 ] gap> det:= DeterminantOfCharacter( tS4, ind ); ClassFunction( CharacterTable( S4 ), [ 1, -1, 1, 1, -1 ] ) gap> cent:= CentralCharacter( tS4, ind ); ClassFunction( CharacterTable( S4 ), [ 1, 2, -1, 0, -2 ] ) gap> rest:= Restricted( tS4, cent, tD8 ); ClassFunction( CharacterTable( D8 ), [ 1, 2, -1, -1, -2 ] )
If one deals with character tables from the GAP table library then one has no access to their groups, but often the tables provide enough information for computing induced or restricted class functions, symmetrizations etc., because the relevant class fusions and power maps are often stored on library tables. In these cases it is possible to use the tables instead of the groups as arguments. (If necessary information is not uniquely determined by the tables then an error is signalled.)
gap> s5 := CharacterTable( "A5.2" );; irrs5 := Irr( s5 );; gap> m11:= CharacterTable( "M11" );; irrm11:= Irr( m11 );; gap> chi:= TrivialCharacter( s5 ); Character( CharacterTable( "A5.2" ), [ 1, 1, 1, 1, 1, 1, 1 ] ) gap> chi ^ m11; Character( CharacterTable( "M11" ), [ 66, 10, 3, 2, 1, 1, 0, 0, 0, 0 ] ) gap> Determinant( irrs5[4] ); Character( CharacterTable( "A5.2" ), [ 1, 1, 1, 1, -1, -1, -1 ] )
Functions that compute normal subgroups related to characters have counterparts that return the list of class positions corresponding to these groups.
gap> ClassPositionsOfKernel( irrs5[2] ); [ 1, 2, 3, 4 ] gap> ClassPositionsOfCentre( irrs5[2] ); [ 1, 2, 3, 4, 5, 6, 7 ]
Non-normal subgroups cannot be described this way, so for example inertia subgroups (see InertiaSubgroup) can in general not be computed from character tables without access to their groups.
GAP 4 manual