68.8 Operations for Class Functions

An ordinary character of a group G is a class function of G whose values are the traces of a complex matrix representation of G.

A Brauer character of G in characteristic p is a class function of G whose values are the complex lifts of a matrix representation of G with image a finite field of characteristic p.

A virtual character is a class function that can be written as the difference of two proper characters (see IsCharacter).

A character is irreducible if it cannot be written as the sum of two characters. For ordinary characters this can be checked using the scalar product of class functions (see ScalarProduct.ctblfuns). For Brauer characters there is no generic method for checking irreducibility.

gap> psi:= ClassFunction( S4, [ 1, 1, 1, -2, 1 ] );
ClassFunction( CharacterTable( S4 ), [ 1, 1, 1, -2, 1 ] )
gap> IsVirtualCharacter( psi );
true
gap> IsCharacter( psi );       
false
gap> chi:= ClassFunction( S4, SizesCentralizers( CharacterTable( S4 ) ) );
ClassFunction( CharacterTable( S4 ), [ 24, 4, 8, 3, 4 ] )
gap> IsCharacter( chi );
true
gap> IsIrreducibleCharacter( chi );
false
gap> IsIrreducibleCharacter( TrivialCharacter( S4 ) );
true

is the value of the character chi on the identity element. This can also be obtained as chi[1].

gap> List( Irr( S4 ), DegreeOfCharacter );
[ 1, 1, 2, 3, 3 ]
gap> nat:= NaturalCharacter( S4 );
Character( CharacterTable( S4 ), [ 4, 2, 0, 1, 0 ] )
gap> nat[1];
4

For two class functions chi and psi of the same ordinary character table tbl, ScalarProduct returns the scalar product.

If G is the underlying group of tbl and the two class functions are c and y then this is defined as [1/(|G|)] å_{g Î G} c(g) y(g^-1).

The first form returns the matrix of scalar products (see above) of the class functions in the list list1 with the class functions in the list list2. More precisely, the matrix contains in the i-th row the list of scalar products of list2 [i] with the entries of list1.

The second form returns a lower triangular matrix of scalar products, containing for ( j £ i) in the i-th row in column j the value ScalarProduct( tbl , list [j], list [i] ).

For an ordinary class function chi of the group G, say, we have chi = å_{c Î Irr(G)} a_c c, with complex coefficients a_c. The norm of chi is defined as å_{c Î Irr(G)} a_c[`(a_c)].

gap> tbl:= CharacterTable( "A5" );;
gap> ScalarProduct( TrivialCharacter( tbl ), Sum( Irr( tbl ) ) );
1
gap> ScalarProduct( tbl, [ 1, 1, 1, 1, 1 ], Sum( Irr( tbl ) ) );
1
gap> chars:= Irr( tbl ){ [ 2 .. 4 ] };;           
gap> chars:= Set( Tensored( chars, chars ) );;
gap> MatScalarProducts( Irr( tbl ), chars );          
[ [ 0, 0, 0, 1, 1 ], [ 1, 1, 0, 0, 1 ], [ 1, 0, 1, 0, 1 ], [ 0, 1, 0, 1, 1 ], 
  [ 0, 0, 1, 1, 1 ], [ 1, 1, 1, 1, 1 ] ]
gap> MatScalarProducts( tbl, chars );       
[ [ 2 ], [ 1, 3 ], [ 1, 2, 3 ], [ 2, 2, 1, 3 ], [ 2, 1, 2, 2, 3 ], 
  [ 2, 3, 3, 3, 3, 5 ] ]
gap> List( chars, Norm );                     
[ 2, 3, 3, 3, 3, 5 ]

is the set of irreducible characters that occur in the decomposition of the (virtual) character chi with nonzero coefficient.

gap> nat:= NaturalCharacter( S4 );
Character( CharacterTable( S4 ), [ 4, 2, 0, 1, 0 ] )
gap> ConstituentsOfCharacter( nat );
[ Character( CharacterTable( S4 ), [ 1, 1, 1, 1, 1 ] ), 
  Character( CharacterTable( S4 ), [ 3, 1, -1, 0, -1 ] ) ]

For a class function chi of the group G, say, KernelOfCharacter returns the normal subgroup of G that is formed by those conjugacy classes for which the value of chi equals the degree of chi. If the underlying character table of chi does not store the group G then an error is signalled. (See ClassPositionsOfKernel for a way to handle the kernel implicitly, by listing the positions of conjugacy classes in the kernel.)

The returned group is the kernel of any representation of G that affords chi.

is the list of positions of those conjugacy classes that form the kernel of the character chi, that is, those positions with character value equal to the character degree.

gap> List( Irr( S4 ), KernelOfCharacter );
[ Group([ (), (1,2), (1,2)(3,4), (1,2,3), (1,2,3,4) ]), 
  Group([ (), (1,2)(3,4), (1,2,3) ]), Group([ (1,2)(3,4), (1,3)(2,4) ]), 
  Group(()), Group(()) ]
gap> List( Irr( S4 ), ClassPositionsOfKernel );
[ [ 1, 2, 3, 4, 5 ], [ 1, 3, 4 ], [ 1, 3 ], [ 1 ], [ 1 ] ]

For a character chi of the group G, say, CentreOfCharacter returns the centre of chi, that is, the normal subgroup of all those elements of G for which the quotient of the value of chi by the degree of chi is a root of unity.

If the underlying character table of psi does not store the group G then an error is signalled. (See ClassPositionsOfCentre.ctblfuns for a way to handle the centre implicitly, by listing the positions of conjugacy classes in the centre.)

is the list of positions of classes forming the centre of the character chi (see CentreOfCharacter).

gap> List( Irr( S4 ), CentreOfCharacter );
[ Group([ (), (1,2), (1,2)(3,4), (1,2,3), (1,2,3,4) ]), 
  Group([ (), (1,2), (1,2)(3,4), (1,2,3), (1,2,3,4) ]), 
  Group([ (1,2)(3,4), (1,3)(2,4) ]), Group(()), Group(()) ]
gap> List( Irr( S4 ), ClassPositionsOfCentre );           
[ [ 1, 2, 3, 4, 5 ], [ 1, 2, 3, 4, 5 ], [ 1, 3 ], [ 1 ], [ 1 ] ]

Let chi be a character of the group H, say, and tbl the character table of H; if the argument tbl is not given then the underlying character table of chi (see UnderlyingCharacterTable) is used instead. Furthermore, let G be a group that contains H as a normal subgroup.

InertiaSubgroup returns the stabilizer in G of chi, w.r.t. the action of G on the classes of H via conjugation. In other words, InertiaSubgroup returns the group of all those elements g Î G that satisfy chi ^g = chi .

gap> der:= DerivedSubgroup( S4 );
Group([ (1,3,2), (2,4,3) ])
gap> List( Irr( der ), chi -> InertiaSubgroup( S4, chi ) );
[ S4, Alt( [ 1 .. 4 ] ), Alt( [ 1 .. 4 ] ), S4 ]

Let permchar be a permutation character, and class the position of a conjugacy class of the character table of permchar. CycleStructureClass returns a list describing the cycle structure of each element in class class in the underlying permutation representation, in the same format as the result of CycleStructurePerm (see CycleStructurePerm).

gap> nat:= NaturalCharacter( S4 );
Character( CharacterTable( S4 ), [ 4, 2, 0, 1, 0 ] )
gap> List( [ 1 .. 5 ], i -> CycleStructureClass( nat, i ) );
[ [  ], [ 1 ], [ 2 ], [ , 1 ], [ ,, 1 ] ]

For a permutation character chi of the group G that corresponds to an action on the G-set W (see PermutationCharacter), IsTransitive returns true if the action of G on W is transitive, and false otherwise.

For a permutation character chi of the group G that corresponds to an action on the G-set W (see PermutationCharacter), Transitivity returns the maximal nonnegative integer k such that the action of G on W is k-transitive.

gap> IsTransitive( nat );  Transitivity( nat );
true
4
gap> Transitivity( 2 * TrivialCharacter( S4 ) );
0

For a character chi of the group G, say, CentralCharacter returns the central character of chi.

The central character of c is the class function w_c defined by w_c(g) = |g^G| ·c(g)/c(1) for each g Î G.

DeterminantOfCharacter returns the determinant character of the character chi. This is defined to be the character obtained by taking the determinant of representing matrices of any representation affording chi; the determinant can be computed using EigenvaluesChar (see EigenvaluesChar).

It is also possible to call Determinant instead of DeterminantOfCharacter.

Note that the determinant character is well-defined for virtual characters.

gap> CentralCharacter( TrivialCharacter( S4 ) );
ClassFunction( CharacterTable( S4 ), [ 1, 6, 3, 8, 6 ] )
gap> DeterminantOfCharacter( Irr( S4 )[3] );
Character( CharacterTable( S4 ), [ 1, -1, 1, 1, -1 ] )

Let chi be a character of the group G, say. For an element g Î G in the class-th conjugacy class, of order n, let M be a matrix of a representation affording chi.

EigenvaluesChar( tbl, chi, class ) is the list of length n where at position k the multiplicity of E(n )^k = exp([(2pi k)/(n)]) as an eigenvalue of M is stored.

We have chi[ class ] = List( [ 1 .. n ], k -> E(n)^k ) * EigenvaluesChar( tbl, chi, class ).

It is also possible to call Eigenvalues instead of EigenvaluesChar.

gap> chi:= Irr( CharacterTable( "A5" ) )[2];
Character( CharacterTable( "A5" ), [ 3, -1, 0, -E(5)-E(5)^4, -E(5)^2-E(5)^3 
 ] )
gap> List( [ 1 .. 5 ], i -> Eigenvalues( chi, i ) );
[ [ 3 ], [ 2, 1 ], [ 1, 1, 1 ], [ 0, 1, 1, 0, 1 ], [ 1, 0, 0, 1, 1 ] ]

Let chars1 and chars2 be lists of (values lists of) class functions of the same character table. Tensored returns the list of tensor products of all entries in chars1 with all entries in chars2.

gap> irra5:= Irr( CharacterTable( "A5" ) );;
gap> chars1:= irra5{ [ 1 .. 3 ] };;  chars2:= irra5{ [ 2, 3 ] };;
gap> Tensored( chars1, chars2 );
[ 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" ), 
    [ 9, 1, 0, -2*E(5)-E(5)^2-E(5)^3-2*E(5)^4, -E(5)-2*E(5)^2-2*E(5)^3-E(5)^4 
     ] ), Character( CharacterTable( "A5" ), [ 9, 1, 0, -1, -1 ] ), 
  Character( CharacterTable( "A5" ), [ 9, 1, 0, -1, -1 ] ), 
  Character( CharacterTable( "A5" ), 
    [ 9, 1, 0, -E(5)-2*E(5)^2-2*E(5)^3-E(5)^4, -2*E(5)-E(5)^2-E(5)^3-2*E(5)^4 
     ] ) ]

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