53.1 Why Group Characters

When one says ``chi is a character of a group G'' then this object chi carries a lot of information. chi has certain properties such as being irreducible or not. Several subgroups of G are related to chi, such as the kernel and the centre of chi. And one can apply operators to chi, such as forming the conjugate character under the action of an automorphism of G, or computing the determinant of chi.

In GAP, the characters known from chapters Character Tables and Characters are just lists of character values. This has several disadvantages. Firstly one cannot store knowledge about a character directly in the character, and secondly for every computation that requires more than just the character values one has to regard this list explicitly as a character belonging to a character table. In practice this means that the user has the task to put the objects into the right context, or --more concrete-- the user has to supply lots of arguments.

This works nicely for characters that are used without groups, like characters of library tables. And if one deals with incomplete character tables often it is necessary to specify the arguments explicitly, for example one has to choose a fusion map or power map from a set of possibilities.

But for dealing with a group and its characters, and maybe also subgroups and their characters, it is desirable that GAP keeps track of the interpretation of characters.

Because of this it seems to be useful to introduce an alternative concept where a group character in GAP is represented as a record that contains the character values, the underlying group or character table, an appropriate operations record, and all the knowledge about the group character.

Together with characters, also the more general class functions and virtual characters are implemented.

Here is an example that shows both approaches. First we define the groups.

    gap> S4:= SolvableGroup( "S4" );;
    gap> D8:= SylowSubgroup( S4, 2 );; D8.name:= "D8";; 

We do some computations using the functions described in chapters Characters and Character Tables.

    gap> t   := CharTable( S4 );;
    gap> tD8 := CharTable( D8 );;
    gap> FusionConjugacyClasses( D8, S4 );;
    gap> chi:= tD8.irreducibles[2];
    [ 1, -1, 1, 1, -1 ]
    gap> Tensored( [ chi ], [ chi ] )[1];
    [ 1, 1, 1, 1, 1 ]
    gap> ind:= Induced( tD8, t, [ chi ] )[1];
    [ 3, -1, 0, 1, -1 ]
    gap> List( t.irreducibles, x -> ScalarProduct( t, x, ind ) );
    [ 0, 0, 0, 1, 0 ]
    gap> det:= DeterminantChar( t, ind );
    [ 1, 1, 1, -1, -1 ]
    gap> cent:= CentralChar( t, ind );
    [ 1, -1, 0, 2, -2 ]
    gap> rest:= Restricted( t, tD8, [ cent ] )[1];
    [ 1, -1, -1, 2, -2 ] 

And now we do the same calculations with the class function records.

    gap> irr   := Irr( S4 );;
    gap> irrD8 := Irr( D8 );;
    gap> chi:= irrD8[2];
    Character( D8, [ 1, -1, 1, 1, -1 ] )
    gap> chi * chi;
    Character( D8, [ 1, 1, 1, 1, 1 ] )
    gap> ind:= chi ^ S4;
    Character( S4, [ 3, -1, 0, 1, -1 ] )
    gap> List( irr, x -> ScalarProduct( x, ind ) );
    [ 0, 0, 0, 1, 0 ]
    gap> det:= Determinant( ind );
    Character( S4, [ 1, 1, 1, -1, -1 ] )
    gap> cent:= Omega( ind );
    ClassFunction( S4, [ 1, -1, 0, 2, -2 ] )
    gap> rest:= Character( D8, cent );
    Character( D8, [ 1, -1, -1, 2, -2 ] ) 

Of course we could have used the Induce and Restricted function also for lists of class functions.

    gap> Induced( tD8, t, tD8.irreducibles{ [ 1, 3 ] } );
    [ [ 3, 3, 0, 1, 1 ], [ 3, 3, 0, -1, -1 ] ]
    gap> Induced( irrD8{ [ 1, 3 ] }, S4 );
    [ Character( S4, [ 3, 3, 0, 1, 1 ] ), 
      Character( S4, [ 3, 3, 0, -1, -1 ] ) ] 

If one deals with complete character tables then often the table provides enough information, so it is possible to use the table instead of the group.

    gap> s5 := CharTable( "A5.2" );; irrs5 := Irr( s5  );;
    gap> m11:= CharTable( "M11"  );; irrm11:= Irr( m11 );;
    gap> irrs5[2];
    Character( CharTable( "A5.2" ), [ 1, 1, 1, 1, -1, -1, -1 ] )
    gap> irrs5[2] ^ m11;
    Character( CharTable( "M11" ), [ 66, 2, 3, -2, 1, -1, 0, 0, 0, 0 ] )
    gap> Determinant( irrs5[4] );
    Character( CharTable( "A5.2" ), [ 1, 1, 1, 1, -1, -1, -1 ] ) 

In this case functions that compute normal subgroups related to characters will return the list of class positions corresponding to that normal subgroup.

    gap> Kernel( irrs5[2] );
    [ 1, 2, 3, 4 ] 

Up Top Next
Index