GAP (ref) - Chapter 72: Class Functions

Goto Chapter: Top 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 Bib Ind
[Top of Book] [Contents] [Previous Chapter] [Next Chapter]

[MathJax on]

72 Class Functions
72.1 Why Class Functions?
72.1-1 IsClassFunction
72.2 Basic Operations for Class Functions
72.2-1 UnderlyingCharacterTable
72.2-2 ValuesOfClassFunction
72.3 Comparison of Class Functions
72.4 Arithmetic Operations for Class Functions
72.4-1 Characteristic
72.4-2 ComplexConjugate
72.4-3 Order
72.5 Printing Class Functions
72.5-1 ViewObj
72.5-2 PrintObj
72.5-3 Display
72.6 Creating Class Functions from Values Lists
72.6-1 ClassFunction
72.6-2 VirtualCharacter
72.6-3 Character
72.6-4 ClassFunctionSameType
72.7 Creating Class Functions using Groups
72.7-1 TrivialCharacter
72.7-2 NaturalCharacter
72.7-3 PermutationCharacter
72.8 Operations for Class Functions
72.8-1 IsCharacter
72.8-2 IsVirtualCharacter
72.8-3 IsIrreducibleCharacter
72.8-4 DegreeOfCharacter
72.8-5 ScalarProduct
72.8-6 MatScalarProducts
72.8-7 Norm
72.8-8 ConstituentsOfCharacter
72.8-9 KernelOfCharacter
72.8-10 ClassPositionsOfKernel
72.8-11 CentreOfCharacter
72.8-12 ClassPositionsOfCentre
72.8-13 InertiaSubgroup
72.8-14 CycleStructureClass
72.8-15 IsTransitive
72.8-16 Transitivity
72.8-17 CentralCharacter
72.8-18 DeterminantOfCharacter
72.8-19 EigenvaluesChar
72.8-20 Tensored
72.9 Restricted and Induced Class Functions
72.9-1 RestrictedClassFunction
72.9-2 RestrictedClassFunctions
72.9-3 InducedClassFunction
72.9-4 InducedClassFunctions
72.9-5 InducedClassFunctionsByFusionMap
72.9-6 InducedCyclic
72.10 Reducing Virtual Characters
72.10-1 ReducedClassFunctions
72.10-2 ReducedCharacters
72.10-3 IrreducibleDifferences
72.10-4 LLL
72.10-5 Extract
72.10-6 OrthogonalEmbeddingsSpecialDimension
72.10-7 Decreased
72.10-8 DnLattice
72.10-9 DnLatticeIterative
72.11 Symmetrizations of Class Functions
72.11-1 Symmetrizations
72.11-2 SymmetricParts
72.11-3 AntiSymmetricParts
72.11-4 OrthogonalComponents
72.11-5 SymplecticComponents
72.12 Molien Series
72.12-1 MolienSeries
72.12-2 MolienSeriesInfo
72.12-3 ValueMolienSeries
72.12-4 MolienSeriesWithGivenDenominator
72.13 Possible Permutation Characters
72.13-1 PermCharInfo
72.13-2 PermCharInfoRelative
72.14 Computing Possible Permutation Characters
72.14-1 PermChars
72.14-2 TestPerm1, ..., TestPerm5
72.14-3 PermBounds
72.14-4 PermComb
72.14-5 Inequalities
72.15 Operations for Brauer Characters
72.15-1 FrobeniusCharacterValue
72.15-2 BrauerCharacterValue
72.15-3 SizeOfFieldOfDefinition
72.15-4 RealizableBrauerCharacters
72.16 Domains Generated by Class Functions

### 72 Class Functions

This chapter describes operations for class functions of finite groups. For operations concerning character tables, see Chapter 71.

Several examples in this chapter require the GAP Character Table Library to be available. If it is not yet loaded then we load it now.

    gap> LoadPackage( "ctbllib" );
    true

#### 72.1 Why Class Functions?

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 "χ is a character of a group G" then this object χ carries a lot of information. χ has certain properties such as being irreducible or not. Several subgroups of G are related to χ, such as the kernel and the centre of χ. 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 `\=` (31.11-1), so class function objects can be used wherever 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` (71.8-2) lists consist of class function objects, and `TrivialCharacter` (72.7-1) 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[4];
    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, 1, 0, 0, 0 ]
    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[4] );
    [ 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, 1, 0, 0, 0 ]
    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` (72.8-13)) can in general not be computed from character tables without access to their groups.

##### 72.1-1 IsClassFunction

`‣ IsClassFunction`( obj ) | ( category )

A class function (in characteristic p) of a finite group G is a map from the set of (p-regular) elements in G to the field of cyclotomics that is constant on conjugacy classes of G.

Each class function in GAP is represented by an immutable list, where at the i-th position the value on the i-th conjugacy class of the character table of G is stored. The ordering of the conjugacy classes is the one used in the underlying character table. Note that if the character table has access to its underlying group then the ordering of conjugacy classes in the group and in the character table may differ (see 71.6); class functions always refer to the ordering of classes in the character table.

Class function objects in GAP are not just plain lists, they store the character table of the group G as value of the attribute `UnderlyingCharacterTable` (72.2-1). The group G itself is accessible only via the character table and thus only if the character table stores its group, as value of the attribute `UnderlyingGroup` (71.6-1). The reason for this is that many computations with class functions are possible without using their groups, for example class functions of character tables in the GAP character table library do in general not have access to their underlying groups.

There are (at least) two reasons why class functions in GAP are not implemented as mappings. First, we want to distinguish class functions in different characteristics, for example to be able to define the Frobenius character of a given Brauer character; viewed as mappings, the trivial characters in all characteristics coprime to the order of G are equal. Second, the product of two class functions shall be again a class function, whereas the product of general mappings is defined as composition.

A further argument is that the typical operations for mappings such as `Image` (32.4-6) and `PreImage` (32.5-6) play no important role for class functions.

#### 72.2 Basic Operations for Class Functions

Basic operations for class functions are `UnderlyingCharacterTable` (72.2-1), `ValuesOfClassFunction` (72.2-2), and the basic operations for lists (see 21.2).

##### 72.2-1 UnderlyingCharacterTable

`‣ UnderlyingCharacterTable`( psi ) | ( attribute )

For a class function psi of the group G, say, the character table of G is stored as value of `UnderlyingCharacterTable`. The ordering of entries in the list psi (see `ValuesOfClassFunction` (72.2-2)) refers to the ordering of conjugacy classes in this character table.

If psi is an ordinary class function then the underlying character table is the ordinary character table of G (see `OrdinaryCharacterTable` (71.8-4)), if psi is a class function in characteristic p ≠ 0 then the underlying character table is the p-modular Brauer table of G (see `BrauerTable` (71.3-2)). So the underlying characteristic of psi can be read off from the underlying character table.

##### 72.2-2 ValuesOfClassFunction

`‣ ValuesOfClassFunction`( psi ) | ( attribute )

is the list of values of the class function psi, the i-th entry being the value on the i-th conjugacy class of the underlying character table (see `UnderlyingCharacterTable` (72.2-1)).

    gap> g:= SymmetricGroup( 4 );
    Sym( [ 1 .. 4 ] )
    gap> psi:= TrivialCharacter( g );
    Character( CharacterTable( Sym( [ 1 .. 4 ] ) ), [ 1, 1, 1, 1, 1 ] )
    gap> UnderlyingCharacterTable( psi );
    CharacterTable( Sym( [ 1 .. 4 ] ) )
    gap> ValuesOfClassFunction( psi );
    [ 1, 1, 1, 1, 1 ]
    gap> IsList( psi );
    true
    gap> psi[1];
    1
    gap> Length( psi );
    5
    gap> IsBound( psi[6] );
    false
    gap> Concatenation( psi, [ 2, 3 ] );
    [ 1, 1, 1, 1, 1, 2, 3 ]

#### 72.3 Comparison of Class Functions

With respect to `\=` (31.11-1) and `\<` (31.11-1), class functions behave equally to their lists of values (see `ValuesOfClassFunction` (72.2-2)). So two class functions are equal if and only if their lists of values are equal, no matter whether they are class functions of the same character table, of the same group but w.r.t. different class ordering, or of different groups.

    gap> grps:= Filtered( AllSmallGroups( 8 ), g -> not IsAbelian( g ) );
    [ <pc group of size 8 with 3 generators>,
      <pc group of size 8 with 3 generators> ]
    gap> t1:= CharacterTable( grps[1] );  SetName( t1, "t1" );
    CharacterTable( <pc group of size 8 with 3 generators> )
    gap> t2:= CharacterTable( grps[2] );  SetName( t2, "t2" );
    CharacterTable( <pc group of size 8 with 3 generators> )
    gap> irr1:= Irr( grps[1] );
    [ Character( t1, [ 1, 1, 1, 1, 1 ] ),
      Character( t1, [ 1, -1, -1, 1, 1 ] ),
      Character( t1, [ 1, -1, 1, 1, -1 ] ),
      Character( t1, [ 1, 1, -1, 1, -1 ] ),
      Character( t1, [ 2, 0, 0, -2, 0 ] ) ]
    gap> irr2:= Irr( grps[2] );
    [ Character( t2, [ 1, 1, 1, 1, 1 ] ),
      Character( t2, [ 1, -1, -1, 1, 1 ] ),
      Character( t2, [ 1, -1, 1, 1, -1 ] ),
      Character( t2, [ 1, 1, -1, 1, -1 ] ),
      Character( t2, [ 2, 0, 0, -2, 0 ] ) ]
    gap> irr1 = irr2;
    true
    gap> IsSSortedList( irr1 );
    false
    gap> irr1[1] < irr1[2];
    false
    gap> irr1[2] < irr1[3];
    true

#### 72.4 Arithmetic Operations for Class Functions

Class functions are row vectors of cyclotomics. The additive behaviour of class functions is defined such that they are equal to the plain lists of class function values except that the results are represented again as class functions whenever this makes sense. The multiplicative behaviour, however, is different. This is motivated by the fact that the tensor product of class functions is a more interesting operation than the vector product of plain lists. (Another candidate for a multiplication of compatible class functions would have been the inner product, which is implemented via the function `ScalarProduct` (72.8-5). In terms of filters, the arithmetic of class functions is based on the decision that they lie in `IsGeneralizedRowVector` (21.12-1), with additive nesting depth 1, but they do not lie in `IsMultiplicativeGeneralizedRowVector` (21.12-2).

More specifically, the scalar multiple of a class function with a cyclotomic is a class function, and the sum and the difference of two class functions of the same underlying character table (see `UnderlyingCharacterTable` (72.2-1)) are again class functions of this table. The sum and the difference of a class function and a list that is not a class function are plain lists, as well as the sum and the difference of two class functions of different character tables.

    gap> g:= SymmetricGroup( 4 );;  tbl:= CharacterTable( g );;
    gap> SetName( tbl, "S4" );  irr:= Irr( g );
    [ Character( S4, [ 1, -1, 1, 1, -1 ] ),
      Character( S4, [ 3, -1, -1, 0, 1 ] ),
      Character( S4, [ 2, 0, 2, -1, 0 ] ),
      Character( S4, [ 3, 1, -1, 0, -1 ] ),
      Character( S4, [ 1, 1, 1, 1, 1 ] ) ]
    gap> 2 * irr[5];
    Character( S4, [ 2, 2, 2, 2, 2 ] )
    gap> irr[1] / 7;
    ClassFunction( S4, [ 1/7, -1/7, 1/7, 1/7, -1/7 ] )
    gap> lincomb:= irr[3] + irr[1] - irr[5];
    VirtualCharacter( S4, [ 2, -2, 2, -1, -2 ] )
    gap> lincomb:= lincomb + 2 * irr[5];
    VirtualCharacter( S4, [ 4, 0, 4, 1, 0 ] )
    gap> IsCharacter( lincomb );
    true
    gap> lincomb;
    Character( S4, [ 4, 0, 4, 1, 0 ] )
    gap> irr[5] + 2;
    [ 3, 3, 3, 3, 3 ]
    gap> irr[5] + [ 1, 2, 3, 4, 5 ];
    [ 2, 3, 4, 5, 6 ]
    gap> zero:= 0 * irr[1];
    VirtualCharacter( S4, [ 0, 0, 0, 0, 0 ] )
    gap> zero + Z(3);
    [ Z(3), Z(3), Z(3), Z(3), Z(3) ]
    gap> irr[5] + TrivialCharacter( DihedralGroup( 8 ) );
    [ 2, 2, 2, 2, 2 ]

The product of two class functions of the same character table is the tensor product (pointwise product) of these class functions. Thus the set of all class functions of a fixed group forms a ring, and for any field F of cyclotomics, the F-span of a given set of class functions forms an algebra.

The product of two class functions of different tables and the product of a class function and a list that is not a class function are not defined, an error is signalled in these cases. Note that in this respect, class functions behave differently from their values lists, for which the product is defined as the standard scalar product.

    gap> tens:= irr[3] * irr[4];
    Character( S4, [ 6, 0, -2, 0, 0 ] )
    gap> ValuesOfClassFunction( irr[3] ) * ValuesOfClassFunction( irr[4] );
    4

Class functions without zero values are invertible, the inverse is defined pointwise. As a consequence, for example groups of linear characters can be formed.

    gap> tens / irr[1];
    Character( S4, [ 6, 0, -2, 0, 0 ] )

Other (somewhat strange) implications of the definition of arithmetic operations for class functions, together with the general rules of list arithmetic (see 21.11), apply to the case of products involving lists of class functions. No inverse of the list of irreducible characters as a matrix is defined; if one is interested in the inverse matrix then one can compute it from the matrix of class function values.

    gap> Inverse( List( irr, ValuesOfClassFunction ) );
    [ [ 1/24, 1/8, 1/12, 1/8, 1/24 ], [ -1/4, -1/4, 0, 1/4, 1/4 ],
      [ 1/8, -1/8, 1/4, -1/8, 1/8 ], [ 1/3, 0, -1/3, 0, 1/3 ],
      [ -1/4, 1/4, 0, -1/4, 1/4 ] ]

Also the product of a class function with a list of class functions is not a vector-matrix product but the list of pointwise products.

    gap> irr[1] * irr{ [ 1 .. 3 ] };
    [ Character( S4, [ 1, 1, 1, 1, 1 ] ),
      Character( S4, [ 3, 1, -1, 0, -1 ] ),
      Character( S4, [ 2, 0, 2, -1, 0 ] ) ]

And the product of two lists of class functions is not the matrix product but the sum of the pointwise products.

    gap> irr * irr;
    Character( S4, [ 24, 4, 8, 3, 4 ] )

The powering operator `\^` (31.12-1) has several meanings for class functions. The power of a class function by a nonnegative integer is clearly the tensor power. The power of a class function by an element that normalizes the underlying group or by a Galois automorphism is the conjugate class function. (As a consequence, the application of the permutation induced by such an action cannot be denoted by `\^` (31.12-1); instead one can use `Permuted` (21.20-18).) The power of a class function by a group or a character table is the induced class function (see `InducedClassFunction` (72.9-3)). The power of a group element by a class function is the class function value at (the conjugacy class containing) this element.

    gap> irr[3] ^ 3;
    Character( S4, [ 8, 0, 8, -1, 0 ] )
    gap> lin:= LinearCharacters( DerivedSubgroup( g ) );
    [ Character( CharacterTable( Alt( [ 1 .. 4 ] ) ), [ 1, 1, 1, 1 ] ),
      Character( CharacterTable( Alt( [ 1 .. 4 ] ) ),
      [ 1, 1, E(3), E(3)^2 ] ),
      Character( CharacterTable( Alt( [ 1 .. 4 ] ) ),
      [ 1, 1, E(3)^2, E(3) ] ) ]
    gap> List( lin, chi -> chi ^ (1,2) );
    [ Character( CharacterTable( Alt( [ 1 .. 4 ] ) ), [ 1, 1, 1, 1 ] ),
      Character( CharacterTable( Alt( [ 1 .. 4 ] ) ),
      [ 1, 1, E(3)^2, E(3) ] ),
      Character( CharacterTable( Alt( [ 1 .. 4 ] ) ),
      [ 1, 1, E(3), E(3)^2 ] ) ]
    gap> Orbit( GaloisGroup( CF(3) ), lin[2] );
    [ Character( CharacterTable( Alt( [ 1 .. 4 ] ) ),
      [ 1, 1, E(3), E(3)^2 ] ),
      Character( CharacterTable( Alt( [ 1 .. 4 ] ) ),
      [ 1, 1, E(3)^2, E(3) ] ) ]
    gap> lin[1]^g;
    Character( S4, [ 2, 0, 2, 2, 0 ] )
    gap> (1,2,3)^lin[2];
    E(3)

##### 72.4-1 Characteristic

`‣ Characteristic`( chi ) | ( attribute )

The characteristic of class functions is zero, as for all list of cyclotomics. For class functions of a p-modular character table, such as Brauer characters, the prime p is given by the `UnderlyingCharacteristic` (71.9-5) value of the character table.

    gap> Characteristic( irr[1] );
    0
    gap> irrmod2:= Irr( g, 2 );
    [ Character( BrauerTable( Sym( [ 1 .. 4 ] ), 2 ), [ 1, 1 ] ),
      Character( BrauerTable( Sym( [ 1 .. 4 ] ), 2 ), [ 2, -1 ] ) ]
    gap> Characteristic( irrmod2[1] );
    0
    gap> UnderlyingCharacteristic( UnderlyingCharacterTable( irrmod2[1] ) );
    2

##### 72.4-2 ComplexConjugate

`‣ ComplexConjugate`( chi ) | ( attribute )

`‣ GaloisCyc`( chi, k ) | ( operation )

`‣ Permuted`( chi, pi ) | ( method )

The operations `ComplexConjugate`, `GaloisCyc`, and `Permuted` return a class function when they are called with a class function; The complex conjugate of a class function that is known to be a (virtual) character is again known to be a (virtual) character, and applying an arbitrary Galois automorphism to an ordinary (virtual) character yields a (virtual) character.

    gap> ComplexConjugate( lin[2] );
    Character( CharacterTable( Alt( [ 1 .. 4 ] ) ),
     [ 1, 1, E(3)^2, E(3) ] )
    gap> GaloisCyc( lin[2], 5 );
    Character( CharacterTable( Alt( [ 1 .. 4 ] ) ),
     [ 1, 1, E(3)^2, E(3) ] )
    gap> Permuted( lin[2], (2,3,4) );
    ClassFunction( CharacterTable( Alt( [ 1 .. 4 ] ) ),
     [ 1, E(3)^2, 1, E(3) ] )

##### 72.4-3 Order

`‣ Order`( chi ) | ( attribute )

By definition of `Order` (31.10-10) for arbitrary monoid elements, the return value of `Order` (31.10-10) for a character must be its multiplicative order. The determinantal order (see `DeterminantOfCharacter` (72.8-18)) of a character chi can be computed as `Order( Determinant( chi ) )`.

    gap> det:= Determinant( irr[3] );
    Character( S4, [ 1, -1, 1, 1, -1 ] )
    gap> Order( det );
    2

#### 72.5 Printing Class Functions

##### 72.5-1 ViewObj

`‣ ViewObj`( chi ) | ( method )

The default `ViewObj` (6.3-5) methods for class functions print one of the strings `"ClassFunction"`, `"VirtualCharacter"`, `"Character"` (depending on whether the class function is known to be a character or virtual character, see `IsCharacter` (72.8-1), `IsVirtualCharacter` (72.8-2)), followed by the `ViewObj` (6.3-5) output for the underlying character table (see 71.13), and the list of values. The table is chosen (and not the group) in order to distinguish class functions of different underlying characteristic (see `UnderlyingCharacteristic` (71.9-5)).

##### 72.5-2 PrintObj

`‣ PrintObj`( chi ) | ( method )

The default `PrintObj` (6.3-5) method for class functions does the same as `ViewObj` (6.3-5), except that the character table is is `Print` (6.3-4)-ed instead of `View` (6.3-3)-ed.

Note that if a class function is shown only with one of the strings `"ClassFunction"`, `"VirtualCharacter"`, it may still be that it is in fact a character; just this was not known at the time when the class function was printed.

In order to reduce the space that is needed to print a class function, it may be useful to give a name (see `Name` (12.8-2)) to the underlying character table.

##### 72.5-3 Display

`‣ Display`( chi ) | ( method )

The default `Display` (6.3-6) method for a class function chi calls `Display` (6.3-6) for its underlying character table (see 71.13), with chi as the only entry in the `chars` list of the options record.

    gap> chi:= TrivialCharacter( CharacterTable( "A5" ) );
    Character( CharacterTable( "A5" ), [ 1, 1, 1, 1, 1 ] )
    gap> Display( chi );
    A5

         2  2  2  .  .  .
         3  1  .  1  .  .
         5  1  .  .  1  1

           1a 2a 3a 5a 5b
        2P 1a 1a 3a 5b 5a
        3P 1a 2a 1a 5b 5a
        5P 1a 2a 3a 1a 1a

    Y.1     1  1  1  1  1

#### 72.6 Creating Class Functions from Values Lists

##### 72.6-1 ClassFunction

`‣ ClassFunction`( tbl, values ) | ( operation )

`‣ ClassFunction`( G, values ) | ( operation )

In the first form, `ClassFunction` returns the class function of the character table tbl with values given by the list values of cyclotomics. In the second form, G must be a group, and the class function of its ordinary character table is returned.

Note that tbl determines the underlying characteristic of the returned class function (see `UnderlyingCharacteristic` (71.9-5)).

##### 72.6-2 VirtualCharacter

`‣ VirtualCharacter`( tbl, values ) | ( operation )

`‣ VirtualCharacter`( G, values ) | ( operation )

`VirtualCharacter` returns the virtual character (see `IsVirtualCharacter` (72.8-2)) of the character table tbl or the group G, respectively, with values given by the list values.

It is not checked whether the given values really describe a virtual character.

##### 72.6-3 Character

`‣ Character`( tbl, values ) | ( operation )

`‣ Character`( G, values ) | ( operation )

`Character` returns the character (see `IsCharacter` (72.8-1)) of the character table tbl or the group G, respectively, with values given by the list values.

It is not checked whether the given values really describe a character.

    gap> g:= DihedralGroup( 8 );  tbl:= CharacterTable( g );
    <pc group of size 8 with 3 generators>
    CharacterTable( <pc group of size 8 with 3 generators> )
    gap> SetName( tbl, "D8" );
    gap> phi:= ClassFunction( g, [ 1, -1, 0, 2, -2 ] );
    ClassFunction( D8, [ 1, -1, 0, 2, -2 ] )
    gap> psi:= ClassFunction( tbl,
    >              List( Irr( g ), chi -> ScalarProduct( chi, phi ) ) );
    ClassFunction( D8, [ -3/8, 9/8, 5/8, 1/8, -1/4 ] )
    gap> chi:= VirtualCharacter( g, [ 0, 0, 8, 0, 0 ] );
    VirtualCharacter( D8, [ 0, 0, 8, 0, 0 ] )
    gap> reg:= Character( tbl, [ 8, 0, 0, 0, 0 ] );
    Character( D8, [ 8, 0, 0, 0, 0 ] )

##### 72.6-4 ClassFunctionSameType

`‣ ClassFunctionSameType`( tbl, chi, values ) | ( function )

Let tbl be a character table, chi a class function object (not necessarily a class function of tbl), and values a list of cyclotomics. `ClassFunctionSameType` returns the class function ψ of tbl with values list values, constructed with `ClassFunction` (72.6-1).

If chi is known to be a (virtual) character then ψ is also known to be a (virtual) character.

    gap> h:= Centre( g );;
    gap> centbl:= CharacterTable( h );;  SetName( centbl, "C2" );
    gap> ClassFunctionSameType( centbl, phi, [ 1, 1 ] );
    ClassFunction( C2, [ 1, 1 ] )
    gap> ClassFunctionSameType( centbl, chi, [ 1, 1 ] );
    VirtualCharacter( C2, [ 1, 1 ] )
    gap> ClassFunctionSameType( centbl, reg, [ 1, 1 ] );
    Character( C2, [ 1, 1 ] )

#### 72.7 Creating Class Functions using Groups

##### 72.7-1 TrivialCharacter

`‣ TrivialCharacter`( tbl ) | ( attribute )

`‣ TrivialCharacter`( G ) | ( attribute )

is the trivial character of the group G or its character table tbl, respectively. This is the class function with value equal to 1 for each class.

    gap> TrivialCharacter( CharacterTable( "A5" ) );
    Character( CharacterTable( "A5" ), [ 1, 1, 1, 1, 1 ] )
    gap> TrivialCharacter( SymmetricGroup( 3 ) );
    Character( CharacterTable( Sym( [ 1 .. 3 ] ) ), [ 1, 1, 1 ] )

##### 72.7-2 NaturalCharacter

`‣ NaturalCharacter`( G ) | ( attribute )

`‣ NaturalCharacter`( hom ) | ( attribute )

If the argument is a permutation group G then `NaturalCharacter` returns the (ordinary) character of the natural permutation representation of G on the set of moved points (see `MovedPoints` (42.3-3)), that is, the value on each class is the number of points among the moved points of G that are fixed by any permutation in that class.

If the argument is a matrix group G in characteristic zero then `NaturalCharacter` returns the (ordinary) character of the natural matrix representation of G, that is, the value on each class is the trace of any matrix in that class.

If the argument is a group homomorphism hom whose image is a permutation group or a matrix group then `NaturalCharacter` returns the restriction of the natural character of the image of hom to the preimage of hom.

    gap> NaturalCharacter( SymmetricGroup( 3 ) );
    Character( CharacterTable( Sym( [ 1 .. 3 ] ) ), [ 3, 1, 0 ] )
    gap> NaturalCharacter( Group( [ [ 0, -1 ], [ 1, -1 ] ] ) );
    Character( CharacterTable( Group([ [ [ 0, -1 ], [ 1, -1 ] ] ]) ),
    [ 2, -1, -1 ] )
    gap> d8:= DihedralGroup( 8 );;  hom:= IsomorphismPermGroup( d8 );;
    gap> NaturalCharacter( hom );
    Character( CharacterTable( <pc group of size 8 with 3 generators> ),
    [ 8, 0, 0, 0, 0 ] )

##### 72.7-3 PermutationCharacter

`‣ PermutationCharacter`( G, D, opr ) | ( operation )

`‣ PermutationCharacter`( G, U ) | ( operation )

Called with a group G, an action domain or proper set D, and an action function opr (see Chapter 41), `PermutationCharacter` returns the permutation character of the action of G on D via opr, that is, the value on each class is the number of points in D that are fixed by an element in this class under the action opr.

If the arguments are a group G and a subgroup U of G then `PermutationCharacter` returns the permutation character of the action of G on the right cosets of U via right multiplication.

To compute the permutation character of a transitive permutation group G on the cosets of a point stabilizer U, the attribute `NaturalCharacter` (72.7-2) of G can be used instead of `PermutationCharacter( G, U )`.

More facilities concerning permutation characters are the transitivity test (see Section 72.8) and several tools for computing possible permutation characters (see 72.13, 72.14).

    gap> PermutationCharacter( GL(2,2), AsSSortedList( GF(2)^2 ), OnRight );
    Character( CharacterTable( SL(2,2) ), [ 4, 2, 1 ] )
    gap> s3:= SymmetricGroup( 3 );;  a3:= DerivedSubgroup( s3 );;
    gap> PermutationCharacter( s3, a3 );
    Character( CharacterTable( Sym( [ 1 .. 3 ] ) ), [ 2, 0, 2 ] )

#### 72.8 Operations for Class Functions

In the description of the following operations, the optional first argument tbl is needed only if the argument chi is a plain list and not a class function object. In this case, tbl must always be the character table of which chi shall be regarded as a class function.

##### 72.8-1 IsCharacter

`‣ IsCharacter`( [tbl, ]chi ) | ( property )

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.

##### 72.8-2 IsVirtualCharacter

`‣ IsVirtualCharacter`( [tbl, ]chi ) | ( property )

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

##### 72.8-3 IsIrreducibleCharacter

`‣ IsIrreducibleCharacter`( [tbl, ]chi ) | ( property )

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` (72.8-5)). For Brauer characters there is no generic method for checking irreducibility.

    gap> S4:= SymmetricGroup( 4 );;  SetName( S4, "S4" );
    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

##### 72.8-4 DegreeOfCharacter

`‣ DegreeOfCharacter`( chi ) | ( attribute )

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, 3, 2, 3, 1 ]
    gap> nat:= NaturalCharacter( S4 );
    Character( CharacterTable( S4 ), [ 4, 2, 0, 1, 0 ] )
    gap> nat[1];
    4

##### 72.8-5 ScalarProduct

`‣ ScalarProduct`( [tbl, ]chi, psi ) | ( operation )

Returns: the scalar product of the class functions chi and psi, which belong to the same character table tbl.

If chi and psi are class function objects, the argument tbl is not needed, but tbl is necessary if at least one of chi, psi is just a plain list.

The scalar product of two ordinary class functions χ, ψ of a group G is defined as

( ∑_{g ∈ G} χ(g) ψ(g^{-1}) ) / |G|.

For two p-modular class functions, the scalar product is defined as ( ∑_{g ∈ S} χ(g) ψ(g^{-1}) ) / |G|, where S is the set of p-regular elements in G.

##### 72.8-6 MatScalarProducts

`‣ MatScalarProducts`( [tbl, ]list[, list2] ) | ( operation )

Called with two lists list, list2 of class functions of the same character table (which may be given as the argument tbl), `MatScalarProducts` returns the matrix of scalar products (see `ScalarProduct` (72.8-5)) More precisely, this matrix contains in the i-th row the list of scalar products of list2[i] with the entries of list.

If only one list list of class functions is given then a lower triangular matrix of scalar products is returned, containing (for j ≤ i) in the i-th row in column j the value `ScalarProduct`( tbl, list[j], list[i] ).

##### 72.8-7 Norm

`‣ Norm`( [tbl, ]chi ) | ( attribute )

For an ordinary class function chi of the group G, say, we have chi = ∑_{χ ∈ Irr(G)} a_χ χ, with complex coefficients a_χ. The norm of chi is defined as ∑_{χ ∈ Irr(G)} a_χ overline{a_χ}.

    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> tbl2:= tbl mod 2;
    BrauerTable( "A5", 2 )
    gap> chi:= Irr( tbl2 )[1];
    Character( BrauerTable( "A5", 2 ), [ 1, 1, 1, 1 ] )
    gap> ScalarProduct( chi, chi );
    3/4
    gap> ScalarProduct( tbl2, [ 1, 1, 1, 1 ], [ 1, 1, 1, 1 ] );
    3/4
    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 ]

##### 72.8-8 ConstituentsOfCharacter

`‣ ConstituentsOfCharacter`( [tbl, ]chi ) | ( attribute )

Let chi be an ordinary or modular (virtual) character. If an ordinary or modular character table tbl is given then chi may also be a list of character values.

`ConstituentsOfCharacter` returns the set of those irreducible characters that occur in the decomposition of 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 ] ) ]

##### 72.8-9 KernelOfCharacter

`‣ KernelOfCharacter`( [tbl, ]chi ) | ( attribute )

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` (72.8-10) 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.

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

##### 72.8-10 ClassPositionsOfKernel

`‣ ClassPositionsOfKernel`( chi ) | ( attribute )

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 ), ClassPositionsOfKernel );
    [ [ 1, 3, 4 ], [ 1 ], [ 1, 3 ], [ 1 ], [ 1, 2, 3, 4, 5 ] ]

##### 72.8-11 CentreOfCharacter

`‣ CentreOfCharacter`( [tbl, ]chi ) | ( attribute )

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` (72.8-12) for a way to handle the centre implicitly, by listing the positions of conjugacy classes in the centre.)

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

##### 72.8-12 ClassPositionsOfCentre

`‣ ClassPositionsOfCentre`( chi ) | ( attribute )

is the list of positions of classes forming the centre of the character chi (see `CentreOfCharacter` (72.8-11)).

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

##### 72.8-13 InertiaSubgroup

`‣ InertiaSubgroup`( [tbl, ]G, chi ) | ( operation )

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` (72.2-1)) 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 );
    Alt( [ 1 .. 4 ] )
    gap> List( Irr( der ), chi -> InertiaSubgroup( S4, chi ) );
    [ S4, Alt( [ 1 .. 4 ] ), Alt( [ 1 .. 4 ] ), S4 ]

##### 72.8-14 CycleStructureClass

`‣ CycleStructureClass`( [tbl, ]chi, class ) | ( operation )

Let permchar be a permutation character, and class be 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` (42.4-2).

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

##### 72.8-15 IsTransitive

`‣ IsTransitive`( [tbl, ]chi ) | ( property )

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

##### 72.8-16 Transitivity

`‣ Transitivity`( [tbl, ]chi ) | ( attribute )

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

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

##### 72.8-17 CentralCharacter

`‣ CentralCharacter`( [tbl, ]chi ) | ( attribute )

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

The central character of χ is the class function ω_χ defined by ω_χ(g) = |g^G| ⋅ χ(g)/χ(1) for each g ∈ G.

##### 72.8-18 DeterminantOfCharacter

`‣ DeterminantOfCharacter`( [tbl, ]chi ) | ( attribute )

`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` (72.8-19).

It is also possible to call `Determinant` (24.4-4) 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 ] )

##### 72.8-19 EigenvaluesChar

`‣ EigenvaluesChar`( [tbl, ]chi, class ) | ( operation )

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` returns the list of length n where at position k the multiplicity of `E`(n)^k = exp(2 π i 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` (24.8-3) 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 ] ]

##### 72.8-20 Tensored

`‣ Tensored`( chars1, chars2 ) | ( operation )

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 ] ) ]

#### 72.9 Restricted and Induced Class Functions

For restricting a class function of a group G to a subgroup H and for inducing a class function of H to G, the class fusion from H to G must be known (see 73.3).

If F is the factor group of G by the normal subgroup N then each class function of F can be naturally regarded as a class function of G, with N in its kernel. For a class function of F, the corresponding class function of G is called the inflated class function. Restriction and inflation are in principle the same, namely indirection of a class function by the appropriate fusion map, and thus no extra operation is needed for this process. But note that contrary to the case of a subgroup fusion, the factor fusion can in general not be computed from the groups G and F; either one needs the natural homomorphism, or the factor fusion to the character table of F must be stored on the table of G. This explains the different syntax for computing restricted and inflated class functions.

In the following, the meaning of the optional first argument tbl is the same as in Section 72.8.

##### 72.9-1 RestrictedClassFunction

`‣ RestrictedClassFunction`( [tbl, ]chi, target ) | ( operation )

Let chi be a class function of the group G, say, and let target be either a subgroup H of G or an injective homomorphism from H to G or the character table of H. Then `RestrictedClassFunction` returns the class function of H obtained by restricting chi to H.

If chi is a class function of a factor group Gof H, where target is either the group H or a homomorphism from H to G or the character table of H then the restriction can be computed in the case of the homomorphism; in the other cases, this is possible only if the factor fusion from H to G is stored on the character table of H.

##### 72.9-2 RestrictedClassFunctions

`‣ RestrictedClassFunctions`( [tbl, ]chars, target ) | ( operation )

`RestrictedClassFunctions` is similar to `RestrictedClassFunction` (72.9-1), the only difference is that it takes a list chars of class functions instead of one class function, and returns the list of restricted class functions.

    gap> a5:= CharacterTable( "A5" );;  s5:= CharacterTable( "S5" );;
    gap> RestrictedClassFunction( Irr( s5 )[2], a5 );
    Character( CharacterTable( "A5" ), [ 1, 1, 1, 1, 1 ] )
    gap> RestrictedClassFunctions( Irr( s5 ), a5 );
    [ Character( CharacterTable( "A5" ), [ 1, 1, 1, 1, 1 ] ),
      Character( CharacterTable( "A5" ), [ 1, 1, 1, 1, 1 ] ),
      Character( CharacterTable( "A5" ), [ 6, -2, 0, 1, 1 ] ),
      Character( CharacterTable( "A5" ), [ 4, 0, 1, -1, -1 ] ),
      Character( CharacterTable( "A5" ), [ 4, 0, 1, -1, -1 ] ),
      Character( CharacterTable( "A5" ), [ 5, 1, -1, 0, 0 ] ),
      Character( CharacterTable( "A5" ), [ 5, 1, -1, 0, 0 ] ) ]
    gap> hom:= NaturalHomomorphismByNormalSubgroup( S4, der );;
    gap> RestrictedClassFunctions( Irr( Image( hom ) ), hom );
    [ Character( CharacterTable( S4 ), [ 1, 1, 1, 1, 1 ] ),
      Character( CharacterTable( S4 ), [ 1, -1, 1, 1, -1 ] ) ]

##### 72.9-3 InducedClassFunction

`‣ InducedClassFunction`( [tbl, ]chi, H ) | ( operation )

`‣ InducedClassFunction`( [tbl, ]chi, hom ) | ( operation )

`‣ InducedClassFunction`( [tbl, ]chi, suptbl ) | ( operation )

Let chi be a class function of the group G, say, and let target be either a supergroup H of G or an injective homomorphism from H to G or the character table of H. Then `InducedClassFunction` returns the class function of H obtained by inducing chi to H.

##### 72.9-4 InducedClassFunctions

`‣ InducedClassFunctions`( [tbl, ]chars, target ) | ( operation )

`InducedClassFunctions` is similar to `InducedClassFunction` (72.9-3), the only difference is that it takes a list chars of class functions instead of one class function, and returns the list of induced class functions.

    gap> InducedClassFunctions( Irr( a5 ), s5 );
    [ Character( CharacterTable( "A5.2" ), [ 2, 2, 2, 2, 0, 0, 0 ] ),
      Character( CharacterTable( "A5.2" ), [ 6, -2, 0, 1, 0, 0, 0 ] ),
      Character( CharacterTable( "A5.2" ), [ 6, -2, 0, 1, 0, 0, 0 ] ),
      Character( CharacterTable( "A5.2" ), [ 8, 0, 2, -2, 0, 0, 0 ] ),
      Character( CharacterTable( "A5.2" ), [ 10, 2, -2, 0, 0, 0, 0 ] ) ]

##### 72.9-5 InducedClassFunctionsByFusionMap

`‣ InducedClassFunctionsByFusionMap`( subtbl, tbl, chars, fusionmap ) | ( function )

Let subtbl and tbl be two character tables of groups H and G, such that H is a subgroup of G, let chars be a list of class functions of subtbl, and let fusionmap be a fusion map from subtbl to tbl. The function returns the list of induced class functions of tbl that correspond to chars, w.r.t. the given fusion map.

`InducedClassFunctionsByFusionMap` is the function that does the work for `InducedClassFunction` (72.9-3) and `InducedClassFunctions` (72.9-4).

    gap> fus:= PossibleClassFusions( a5, s5 );
    [ [ 1, 2, 3, 4, 4 ] ]
    gap> InducedClassFunctionsByFusionMap( a5, s5, Irr( a5 ), fus[1] );
    [ Character( CharacterTable( "A5.2" ), [ 2, 2, 2, 2, 0, 0, 0 ] ),
      Character( CharacterTable( "A5.2" ), [ 6, -2, 0, 1, 0, 0, 0 ] ),
      Character( CharacterTable( "A5.2" ), [ 6, -2, 0, 1, 0, 0, 0 ] ),
      Character( CharacterTable( "A5.2" ), [ 8, 0, 2, -2, 0, 0, 0 ] ),
      Character( CharacterTable( "A5.2" ), [ 10, 2, -2, 0, 0, 0, 0 ] ) ]

##### 72.9-6 InducedCyclic

`‣ InducedCyclic`( tbl[, classes][, "all"] ) | ( operation )

`InducedCyclic` calculates characters induced up from cyclic subgroups of the ordinary character table tbl to tbl, and returns the strictly sorted list of the induced characters.

If the string `"all"` is specified then all irreducible characters of these subgroups are induced, otherwise only the permutation characters are calculated.

If a list classes is specified then only those cyclic subgroups generated by these classes are considered, otherwise all classes of tbl are considered.

    gap> InducedCyclic( a5, "all" );
    [ Character( CharacterTable( "A5" ), [ 12, 0, 0, 2, 2 ] ),
      Character( CharacterTable( "A5" ),
        [ 12, 0, 0, E(5)^2+E(5)^3, E(5)+E(5)^4 ] ),
      Character( CharacterTable( "A5" ),
        [ 12, 0, 0, E(5)+E(5)^4, E(5)^2+E(5)^3 ] ),
      Character( CharacterTable( "A5" ), [ 20, 0, -1, 0, 0 ] ),
      Character( CharacterTable( "A5" ), [ 20, 0, 2, 0, 0 ] ),
      Character( CharacterTable( "A5" ), [ 30, -2, 0, 0, 0 ] ),
      Character( CharacterTable( "A5" ), [ 30, 2, 0, 0, 0 ] ),
      Character( CharacterTable( "A5" ), [ 60, 0, 0, 0, 0 ] ) ]

#### 72.10 Reducing Virtual Characters

The following operations are intended for the situation that one is given a list of virtual characters of a character table and is interested in the irreducible characters of this table. The idea is to compute virtual characters of small norm from the given ones, hoping to get eventually virtual characters of norm 1.

##### 72.10-1 ReducedClassFunctions

`‣ ReducedClassFunctions`( [tbl, ][constituents, ]reducibles ) | ( operation )

Let reducibles be a list of ordinary virtual characters of the group G, say. If constituents is given then it must also be a list of ordinary virtual characters of G, otherwise we have constituents equal to reducibles in the following.

`ReducedClassFunctions` returns a record with the components `remainders` and `irreducibles`, both lists of virtual characters of G. These virtual characters are computed as follows.

Let `rems` be the set of nonzero class functions obtained by subtraction of

∑_χ ( [reducibles[i], χ] / [χ, χ] ) ⋅ χ

from reducibles[i], where the summation runs over constituents and [χ, ψ] denotes the scalar product of G-class functions. Let `irrs` be the list of irreducible characters in `rems`.

We project `rems` into the orthogonal space of `irrs` and all those irreducibles found this way until no new irreducibles arise. Then the `irreducibles` list is the set of all found irreducible characters, and the `remainders` list is the set of all nonzero remainders.

##### 72.10-2 ReducedCharacters

`‣ ReducedCharacters`( [tbl, ]constituents, reducibles ) | ( operation )

`ReducedCharacters` is similar to `ReducedClassFunctions` (72.10-1), the only difference is that constituents and reducibles are assumed to be lists of characters. This means that only those scalar products must be formed where the degree of the character in constituents does not exceed the degree of the character in reducibles.

    gap> tbl:= CharacterTable( "A5" );;
    gap> chars:= Irr( tbl ){ [ 2 .. 4 ] };;
    gap> chars:= Set( Tensored( chars, chars ) );;
    gap> red:= ReducedClassFunctions( chars );
    rec(
      irreducibles :=
        [ 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 ] ) ],
      remainders := [  ] )

##### 72.10-3 IrreducibleDifferences

`‣ IrreducibleDifferences`( tbl, reducibles, reducibles2[, scprmat] ) | ( function )

`IrreducibleDifferences` returns the list of irreducible characters which occur as difference of an element of reducibles and an element of reducibles2, where these two arguments are lists of class functions of the character table tbl.

If reducibles2 is the string `"triangle"` then the differences of elements in reducibles are considered.

If scprmat is not specified then it will be calculated, otherwise we must have `scprmat = MatScalarProducts( tbl, reducibles, reducibles2 )` or `scprmat = MatScalarProducts( tbl, reducibles )`, respectively.

    gap> IrreducibleDifferences( a5, chars, "triangle" );
    [ 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 ] ) ]

##### 72.10-4 LLL

`‣ LLL`( tbl, characters[, y][, "sort"][, "linearcomb"] ) | ( function )

`LLL` calls the LLL algorithm (see `LLLReducedBasis` (25.5-1)) in the case of lattices spanned by the virtual characters characters of the ordinary character table tbl (see `ScalarProduct` (72.8-5)). By finding shorter vectors in the lattice spanned by characters, i.e., virtual characters of smaller norm, in some cases `LLL` is able to find irreducible characters.

`LLL` returns a record with at least components `irreducibles` (the list of found irreducible characters), `remainders` (a list of reducible virtual characters), and `norms` (the list of norms of the vectors in `remainders`). `irreducibles` together with `remainders` form a basis of the ℤ-lattice spanned by characters.

Note that the vectors in the `remainders` list are in general not orthogonal (see `ReducedClassFunctions` (72.10-1)) to the irreducible characters in `irreducibles`.

Optional arguments of `LLL` are

y

  controls the sensitivity of the algorithm, see `LLLReducedBasis` (25.5-1),

"sort"

  `LLL` sorts characters and the `remainders` component of the result according to the degrees,

"linearcomb"

  the returned record contains components `irreddecomp` and `reddecomp`, which are decomposition matrices of `irreducibles` and `remainders`, with respect to characters.

    gap> s4:= CharacterTable( "Symmetric", 4 );;
    gap> chars:= [ [ 8, 0, 0, -1, 0 ], [ 6, 0, 2, 0, 2 ],
    >     [ 12, 0, -4, 0, 0 ], [ 6, 0, -2, 0, 0 ], [ 24, 0, 0, 0, 0 ],
    >     [ 12, 0, 4, 0, 0 ], [ 6, 0, 2, 0, -2 ], [ 12, -2, 0, 0, 0 ],
    >     [ 8, 0, 0, 2, 0 ], [ 12, 2, 0, 0, 0 ], [ 1, 1, 1, 1, 1 ] ];;
    gap> LLL( s4, chars );
    rec(
      irreducibles :=
        [ Character( CharacterTable( "Sym(4)" ), [ 2, 0, 2, -1, 0 ] ),
          Character( CharacterTable( "Sym(4)" ), [ 1, 1, 1, 1, 1 ] ),
          Character( CharacterTable( "Sym(4)" ), [ 3, 1, -1, 0, -1 ] ),
          Character( CharacterTable( "Sym(4)" ), [ 3, -1, -1, 0, 1 ] ),
          Character( CharacterTable( "Sym(4)" ), [ 1, -1, 1, 1, -1 ] ) ],
      norms := [  ], remainders := [  ] )

##### 72.10-5 Extract

`‣ Extract`( tbl, reducibles, grammat[, missing] ) | ( function )

Let tbl be an ordinary character table, reducibles a list of characters of tbl, and grammat the matrix of scalar products of reducibles (see `MatScalarProducts` (72.8-6)). `Extract` tries to find irreducible characters by drawing conclusions out of the scalar products, using combinatorial and backtrack means.

The optional argument missing is the maximal number of irreducible characters that occur as constituents of reducibles. Specification of missing may accelerate `Extract`.

`Extract` returns a record ext with the components `solution` and `choice`, where the value of `solution` is a list [ M_1, ..., M_n ] of decomposition matrices M_i (up to permutations of rows) with the property that M_i^tr ⋅ X is equal to the sublist at the positions ext`.choice[i]` of reducibles, for a matrix X of irreducible characters; the value of `choice` is a list of length n whose entries are lists of indices.

So the j-th column in each matrix M_i corresponds to reducibles[j], and each row in M_i corresponds to an irreducible character. `Decreased` (72.10-7) can be used to examine the solution for computable irreducibles.

    gap> s4:= CharacterTable( "Symmetric", 4 );;
    gap> red:= [ [ 5, 1, 5, 2, 1 ], [ 2, 0, 2, 2, 0 ], [ 3, -1, 3, 0, -1 ],
    >            [ 6, 0, -2, 0, 0 ], [ 4, 0, 0, 1, 2 ] ];;
    gap> gram:= MatScalarProducts( s4, red, red );
    [ [ 6, 3, 2, 0, 2 ], [ 3, 2, 1, 0, 1 ], [ 2, 1, 2, 0, 0 ],
      [ 0, 0, 0, 2, 1 ], [ 2, 1, 0, 1, 2 ] ]
    gap> ext:= Extract( s4, red, gram, 5 );
    rec( choice := [ [ 2, 5, 3, 4, 1 ] ],
      solution :=
        [
          [ [ 1, 1, 0, 0, 2 ], [ 1, 0, 1, 0, 1 ], [ 0, 1, 0, 1, 0 ],
              [ 0, 0, 1, 0, 1 ], [ 0, 0, 0, 1, 0 ] ] ] )
    gap> dec:= Decreased( s4, red, ext.solution[1], ext.choice[1] );
    rec(
      irreducibles :=
        [ Character( CharacterTable( "Sym(4)" ), [ 1, 1, 1, 1, 1 ] ),
          Character( CharacterTable( "Sym(4)" ), [ 3, -1, -1, 0, 1 ] ),
          Character( CharacterTable( "Sym(4)" ), [ 1, -1, 1, 1, -1 ] ),
          Character( CharacterTable( "Sym(4)" ), [ 3, 1, -1, 0, -1 ] ),
          Character( CharacterTable( "Sym(4)" ), [ 2, 0, 2, -1, 0 ] ) ],
      matrix := [  ], remainders := [  ] )

##### 72.10-6 OrthogonalEmbeddingsSpecialDimension

`‣ OrthogonalEmbeddingsSpecialDimension`( tbl, reducibles, grammat[, "positive"], dim ) | ( function )

`OrthogonalEmbeddingsSpecialDimension` is a variant of `OrthogonalEmbeddings` (25.6-1) for the situation that tbl is an ordinary character table, reducibles is a list of virtual characters of tbl, grammat is the matrix of scalar products (see `MatScalarProducts` (72.8-6)), and dim is an upper bound for the number of irreducible characters of tbl that occur as constituents of reducibles; if the vectors in reducibles are known to be proper characters then the string `"positive"` may be entered as fourth argument. (See `OrthogonalEmbeddings` (25.6-1) for information why this may help.)

`OrthogonalEmbeddingsSpecialDimension` first uses `OrthogonalEmbeddings` (25.6-1) to compute all orthogonal embeddings of grammat into a standard lattice of dimension up to dim, and then calls `Decreased` (72.10-7) in order to find irreducible characters of tbl.

`OrthogonalEmbeddingsSpecialDimension` returns a record with the following components.

`irreducibles`

  a list of found irreducibles, the intersection of all lists of irreducibles found by `Decreased` (72.10-7), for all possible embeddings, and

`remainders`

  a list of remaining reducible virtual characters.

    gap> s6:= CharacterTable( "S6" );;
    gap> red:= InducedCyclic( s6, "all" );;
    gap> Add( red, TrivialCharacter( s6 ) );
    gap> lll:= LLL( s6, red );;
    gap> irred:= lll.irreducibles;
    [ Character( CharacterTable( "A6.2_1" ),
        [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ] ),
      Character( CharacterTable( "A6.2_1" ),
        [ 9, 1, 0, 0, 1, -1, -3, -3, 1, 0, 0 ] ),
      Character( CharacterTable( "A6.2_1" ),
        [ 16, 0, -2, -2, 0, 1, 0, 0, 0, 0, 0 ] ) ]
    gap> Set( Flat( MatScalarProducts( s6, irred, lll.remainders ) ) );
    [ 0 ]
    gap> dim:= NrConjugacyClasses( s6 ) - Length( lll.irreducibles );
    8
    gap> rem:= lll.remainders;;  Length( rem );
    8
    gap> gram:= MatScalarProducts( s6, rem, rem );;  RankMat( gram );
    8
    gap> emb1:= OrthogonalEmbeddings( gram, 8 );
    rec( norms := [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ],
      solutions := [ [ 1, 2, 3, 7, 11, 12, 13, 15 ],
          [ 1, 2, 4, 8, 10, 12, 13, 14 ], [ 1, 2, 5, 6, 9, 12, 13, 16 ] ],
      vectors :=
        [ [ -1, 0, 1, 0, 1, 0, 1, 0 ], [ 1, 0, 0, 1, 0, 1, 0, 0 ],
          [ 0, 1, 1, 0, 0, 0, 1, 1 ], [ 0, 1, 1, 0, 0, 0, 1, 0 ],
          [ 0, 1, 1, 0, 0, 0, 0, 0 ], [ 0, 1, 0, 0, 0, 0, 1, 0 ],
          [ 0, -1, 0, 0, 0, 0, 0, 1 ], [ 0, 1, 0, 0, 0, 0, 0, 0 ],
          [ 0, 0, 1, 0, 0, 0, 1, 1 ], [ 0, 0, 1, 0, 0, 0, 0, 1 ],
          [ 0, 0, 1, 0, 0, 0, 0, 0 ], [ 0, 0, 0, -1, 1, 0, 0, 0 ],
          [ 0, 0, 0, 0, 0, 1, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 1, 1 ],
          [ 0, 0, 0, 0, 0, 0, 1, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 1 ] ] )

In the following example we temporarily decrease the line length limit from its default value 80 to 62 in order to get a nicer output format.

    gap> emb2:= OrthogonalEmbeddingsSpecialDimension( s6, rem, gram, 8 );
    rec(
      irreducibles :=
        [ Character( CharacterTable( "A6.2_1" ),
            [ 5, 1, -1, 2, -1, 0, 1, -3, -1, 1, 0 ] ),
          Character( CharacterTable( "A6.2_1" ),
            [ 5, 1, 2, -1, -1, 0, -3, 1, -1, 0, 1 ] ),
          Character( CharacterTable( "A6.2_1" ),
            [ 10, -2, 1, 1, 0, 0, -2, 2, 0, 1, -1 ] ),
          Character( CharacterTable( "A6.2_1" ),
            [ 10, -2, 1, 1, 0, 0, 2, -2, 0, -1, 1 ] ) ],
      remainders :=
        [ VirtualCharacter( CharacterTable( "A6.2_1" ),
            [ 0, 0, 3, -3, 0, 0, 4, -4, 0, 1, -1 ] ),
          VirtualCharacter( CharacterTable( "A6.2_1" ),
            [ 6, 2, 3, 0, 0, 1, 2, -2, 0, -1, -2 ] ),
          VirtualCharacter( CharacterTable( "A6.2_1" ),
            [ 10, 2, 1, 1, 2, 0, 2, 2, -2, -1, -1 ] ),
          VirtualCharacter( CharacterTable( "A6.2_1" ),
            [ 14, 2, 2, -1, 0, -1, 6, 2, 0, 0, -1 ] ) ] )

##### 72.10-7 Decreased

`‣ Decreased`( tbl, chars, decompmat[, choice] ) | ( function )

Let tbl be an ordinary character table, chars a list of virtual characters of tbl, and decompmat a decomposition matrix, that is, a matrix M with the property that M^tr ⋅ X = chars holds, where X is a list of irreducible characters of tbl. `Decreased` tries to compute the irreducibles in X or at least some of them.

Usually `Decreased` is applied to the output of `Extract` (72.10-5) or `OrthogonalEmbeddings` (25.6-1) or `OrthogonalEmbeddingsSpecialDimension` (72.10-6). In the case of `Extract` (72.10-5), the choice component corresponding to the decomposition matrix must be entered as argument choice of `Decreased`.

`Decreased` returns `fail` if it can prove that no list X of irreducible characters corresponding to the arguments exists; otherwise `Decreased` returns a record with the following components.

`irreducibles`

  the list of found irreducible characters,

`remainders`

  the remaining reducible characters, and

`matrix`

  the decomposition matrix of the characters in the `remainders` component.

In the following example we temporarily decrease the line length limit from its default value 80 to 62 in order to get a nicer output format.

    gap> s4:= CharacterTable( "Symmetric", 4 );;
    gap> x:= Irr( s4 );;
    gap> red:= [ x[1]+x[2], -x[1]-x[3], -x[1]+x[3], -x[2]-x[4] ];;
    gap> mat:= MatScalarProducts( s4, red, red );
    [ [ 2, -1, -1, -1 ], [ -1, 2, 0, 0 ], [ -1, 0, 2, 0 ],
      [ -1, 0, 0, 2 ] ]
    gap> emb:= OrthogonalEmbeddings( mat );
    rec( norms := [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ],
      solutions := [ [ 1, 6, 7, 12 ], [ 2, 5, 8, 11 ], [ 3, 4, 9, 10 ] ],
      vectors := [ [ -1, 1, 1, 0 ], [ -1, 1, 0, 1 ], [ 1, -1, 0, 0 ],
          [ -1, 0, 1, 1 ], [ -1, 0, 1, 0 ], [ -1, 0, 0, 1 ],
          [ 0, -1, 1, 0 ], [ 0, -1, 0, 1 ], [ 0, 1, 0, 0 ],
          [ 0, 0, -1, 1 ], [ 0, 0, 1, 0 ], [ 0, 0, 0, 1 ] ] )
    gap> dec:= Decreased( s4, red, emb.vectors{ emb.solutions[1] } );
    rec(
      irreducibles :=
        [ Character( CharacterTable( "Sym(4)" ), [ 3, -1, -1, 0, 1 ] ),
          Character( CharacterTable( "Sym(4)" ), [ 1, -1, 1, 1, -1 ] ),
          Character( CharacterTable( "Sym(4)" ), [ 2, 0, 2, -1, 0 ] ),
          Character( CharacterTable( "Sym(4)" ), [ 3, 1, -1, 0, -1 ] ) ],
      matrix := [  ], remainders := [  ] )
    gap> Decreased( s4, red, emb.vectors{ emb.solutions[2] } );
    fail
    gap> Decreased( s4, red, emb.vectors{ emb.solutions[3] } );
    fail

##### 72.10-8 DnLattice

`‣ DnLattice`( tbl, grammat, reducibles ) | ( function )

Let tbl be an ordinary character table, and reducibles a list of virtual characters of tbl.

`DnLattice` searches for sublattices isomorphic to root lattices of type D_n, for n ≥ 4, in the lattice that is generated by reducibles; each vector in reducibles must have norm 2, and the matrix of scalar products (see `MatScalarProducts` (72.8-6)) of reducibles must be entered as argument grammat.

`DnLattice` is able to find irreducible characters if there is a lattice of type D_n with n > 4. In the case n = 4, `DnLattice` may fail to determine irreducibles.

`DnLattice` returns a record with components

`irreducibles`

  the list of found irreducible characters,

`remainders`

  the list of remaining reducible virtual characters, and

`gram`

  the Gram matrix of the vectors in `remainders`.

The `remainders` list is transformed in such a way that the `gram` matrix is a block diagonal matrix that exhibits the structure of the lattice generated by the vectors in `remainders`. So `DnLattice` might be useful even if it fails to find irreducible characters.

In the following example we temporarily decrease the line length limit from its default value 80 to 62 in order to get a nicer output format.

    gap> s4:= CharacterTable( "Symmetric", 4 );;
    gap> red:= [ [ 2, 0, 2, 2, 0 ], [ 4, 0, 0, 1, 2 ],
    >            [ 5, -1, 1, -1, 1 ], [ -1, 1, 3, -1, -1 ] ];;
    gap> gram:= MatScalarProducts( s4, red, red );
    [ [ 2, 1, 0, 0 ], [ 1, 2, 1, -1 ], [ 0, 1, 2, 0 ], [ 0, -1, 0, 2 ] ]
    gap> dn:= DnLattice( s4, gram, red );
    rec( gram := [  ],
      irreducibles :=
        [ Character( CharacterTable( "Sym(4)" ), [ 2, 0, 2, -1, 0 ] ),
          Character( CharacterTable( "Sym(4)" ), [ 1, -1, 1, 1, -1 ] ),
          Character( CharacterTable( "Sym(4)" ), [ 1, 1, 1, 1, 1 ] ),
          Character( CharacterTable( "Sym(4)" ), [ 3, -1, -1, 0, 1 ] ) ],
      remainders := [  ] )

##### 72.10-9 DnLatticeIterative

`‣ DnLatticeIterative`( tbl, reducibles ) | ( function )

Let tbl be an ordinary character table, and reducibles either a list of virtual characters of tbl or a record with components `remainders` and `norms`, for example a record returned by `LLL` (72.10-4).

`DnLatticeIterative` was designed for iterative use of `DnLattice` (72.10-8). `DnLatticeIterative` selects the vectors of norm 2 among the given virtual character, calls `DnLattice` (72.10-8) for them, reduces the virtual characters with found irreducibles, calls `DnLattice` (72.10-8) again for the remaining virtual characters, and so on, until no new irreducibles are found.

`DnLatticeIterative` returns a record with the same components and meaning of components as `LLL` (72.10-4).

In the following example we temporarily decrease the line length limit from its default value 80 to 62 in order to get a nicer output format.

    gap> s4:= CharacterTable( "Symmetric", 4 );;
    gap> red:= [ [ 2, 0, 2, 2, 0 ], [ 4, 0, 0, 1, 2 ],
    >            [ 5, -1, 1, -1, 1 ], [ -1, 1, 3, -1, -1 ] ];;
    gap> dn:= DnLatticeIterative( s4, red );
    rec(
      irreducibles :=
        [ Character( CharacterTable( "Sym(4)" ), [ 2, 0, 2, -1, 0 ] ),
          Character( CharacterTable( "Sym(4)" ), [ 1, -1, 1, 1, -1 ] ),
          Character( CharacterTable( "Sym(4)" ), [ 1, 1, 1, 1, 1 ] ),
          Character( CharacterTable( "Sym(4)" ), [ 3, -1, -1, 0, 1 ] ) ],
      norms := [  ], remainders := [  ] )

#### 72.11 Symmetrizations of Class Functions

##### 72.11-1 Symmetrizations

`‣ Symmetrizations`( [tbl, ]characters, n ) | ( operation )

`Symmetrizations` returns the list of symmetrizations of the characters characters of the ordinary character table tbl with the ordinary irreducible characters of the symmetric group of degree n; instead of the integer n, the character table of the symmetric group can be entered.

The symmetrization χ^[λ] of the character χ of tbl with the character λ of the symmetric group S_n of degree n is defined by

χ^[λ](g) = ( ∑_{ρ ∈ S_n} λ(ρ) ∏_{k=1}^n χ(g^k)^{a_k(ρ)} ) / n! ,

where a_k(ρ) is the number of cycles of length k in ρ.

For special kinds of symmetrizations, see `SymmetricParts` (72.11-2), `AntiSymmetricParts` (72.11-3), `MinusCharacter` (73.6-5) and `OrthogonalComponents` (72.11-4), `SymplecticComponents` (72.11-5).

Note that the returned list may contain zero class functions, and duplicates are not deleted.

    gap> tbl:= CharacterTable( "A5" );;
    gap> Symmetrizations( Irr( tbl ){ [ 1 .. 3 ] }, 3 );
    [ VirtualCharacter( CharacterTable( "A5" ), [ 0, 0, 0, 0, 0 ] ),
      VirtualCharacter( CharacterTable( "A5" ), [ 0, 0, 0, 0, 0 ] ),
      Character( CharacterTable( "A5" ), [ 1, 1, 1, 1, 1 ] ),
      Character( CharacterTable( "A5" ), [ 1, 1, 1, 1, 1 ] ),
      Character( CharacterTable( "A5" ),
        [ 8, 0, -1, -E(5)-E(5)^4, -E(5)^2-E(5)^3 ] ),
      Character( CharacterTable( "A5" ), [ 10, -2, 1, 0, 0 ] ),
      Character( CharacterTable( "A5" ), [ 1, 1, 1, 1, 1 ] ),
      Character( CharacterTable( "A5" ),
        [ 8, 0, -1, -E(5)^2-E(5)^3, -E(5)-E(5)^4 ] ),
      Character( CharacterTable( "A5" ), [ 10, -2, 1, 0, 0 ] ) ]

##### 72.11-2 SymmetricParts

`‣ SymmetricParts`( tbl, characters, n ) | ( function )

is the list of symmetrizations of the characters characters of the character table tbl with the trivial character of the symmetric group of degree n (see `Symmetrizations` (72.11-1)).

    gap> SymmetricParts( tbl, Irr( tbl ), 3 );
    [ Character( CharacterTable( "A5" ), [ 1, 1, 1, 1, 1 ] ),
      Character( CharacterTable( "A5" ), [ 10, -2, 1, 0, 0 ] ),
      Character( CharacterTable( "A5" ), [ 10, -2, 1, 0, 0 ] ),
      Character( CharacterTable( "A5" ), [ 20, 0, 2, 0, 0 ] ),
      Character( CharacterTable( "A5" ), [ 35, 3, 2, 0, 0 ] ) ]

##### 72.11-3 AntiSymmetricParts

`‣ AntiSymmetricParts`( tbl, characters, n ) | ( function )

is the list of symmetrizations of the characters characters of the character table tbl with the alternating character of the symmetric group of degree n (see `Symmetrizations` (72.11-1)).

    gap> AntiSymmetricParts( tbl, Irr( tbl ), 3 );
    [ VirtualCharacter( CharacterTable( "A5" ), [ 0, 0, 0, 0, 0 ] ),
      Character( CharacterTable( "A5" ), [ 1, 1, 1, 1, 1 ] ),
      Character( CharacterTable( "A5" ), [ 1, 1, 1, 1, 1 ] ),
      Character( CharacterTable( "A5" ), [ 4, 0, 1, -1, -1 ] ),
      Character( CharacterTable( "A5" ), [ 10, -2, 1, 0, 0 ] ) ]

##### 72.11-4 OrthogonalComponents

`‣ OrthogonalComponents`( tbl, chars, m ) | ( function )

If χ is a nonlinear character with indicator +1, a splitting of the tensor power χ^m is given by the so-called Murnaghan functions (see [Mur58]). These components in general have fewer irreducible constituents than the symmetrizations with the symmetric group of degree m (see `Symmetrizations` (72.11-1)).

`OrthogonalComponents` returns the Murnaghan components of the nonlinear characters of the character table tbl in the list chars up to the power m, where m is an integer between 2 and 6.

The Murnaghan functions are implemented as in [Fra82].

Note: If chars is a list of character objects (see `IsCharacter` (72.8-1)) then also the result consists of class function objects. It is not checked whether all characters in chars do really have indicator +1; if there are characters with indicator 0 or -1, the result might contain virtual characters (see also `SymplecticComponents` (72.11-5)), therefore the entries of the result do in general not know that they are characters.

    gap> tbl:= CharacterTable( "A8" );;  chi:= Irr( tbl )[2];
    Character( CharacterTable( "A8" ), [ 7, -1, 3, 4, 1, -1, 1, 2, 0, -1,
      0, 0, -1, -1 ] )
    gap> OrthogonalComponents( tbl, [ chi ], 3 );
    [ ClassFunction( CharacterTable( "A8" ),
        [ 21, -3, 1, 6, 0, 1, -1, 1, -2, 0, 0, 0, 1, 1 ] ),
      ClassFunction( CharacterTable( "A8" ),
        [ 27, 3, 7, 9, 0, -1, 1, 2, 1, 0, -1, -1, -1, -1 ] ),
      ClassFunction( CharacterTable( "A8" ),
        [ 105, 1, 5, 15, -3, 1, -1, 0, -1, 1, 0, 0, 0, 0 ] ),
      ClassFunction( CharacterTable( "A8" ),
        [ 35, 3, -5, 5, 2, -1, -1, 0, 1, 0, 0, 0, 0, 0 ] ),
      ClassFunction( CharacterTable( "A8" ),
        [ 77, -3, 13, 17, 2, 1, 1, 2, 1, 0, 0, 0, 2, 2 ] ) ]

##### 72.11-5 SymplecticComponents

`‣ SymplecticComponents`( tbl, chars, m ) | ( function )

If χ is a (nonlinear) character with indicator -1, a splitting of the tensor power χ^m is given in terms of the so-called Murnaghan functions (see [Mur58]). These components in general have fewer irreducible constituents than the symmetrizations with the symmetric group of degree m (see `Symmetrizations` (72.11-1)).

`SymplecticComponents` returns the symplectic symmetrizations of the nonlinear characters of the character table tbl in the list chars up to the power m, where m is an integer between 2 and 5.

Note: If chars is a list of character objects (see `IsCharacter` (72.8-1)) then also the result consists of class function objects. It is not checked whether all characters in chars do really have indicator -1; if there are characters with indicator 0 or +1, the result might contain virtual characters (see also `OrthogonalComponents` (72.11-4)), therefore the entries of the result do in general not know that they are characters.

    gap> tbl:= CharacterTable( "U3(3)" );;  chi:= Irr( tbl )[2];
    Character( CharacterTable( "U3(3)" ),
    [ 6, -2, -3, 0, -2, -2, 2, 1, -1, -1, 0, 0, 1, 1 ] )
    gap> SymplecticComponents( tbl, [ chi ], 3 );
    [ ClassFunction( CharacterTable( "U3(3)" ),
        [ 14, -2, 5, -1, 2, 2, 2, 1, 0, 0, 0, 0, -1, -1 ] ),
      ClassFunction( CharacterTable( "U3(3)" ),
        [ 21, 5, 3, 0, 1, 1, 1, -1, 0, 0, -1, -1, 1, 1 ] ),
      ClassFunction( CharacterTable( "U3(3)" ),
        [ 64, 0, -8, -2, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0 ] ),
      ClassFunction( CharacterTable( "U3(3)" ),
        [ 14, 6, -4, 2, -2, -2, 2, 0, 0, 0, 0, 0, -2, -2 ] ),
      ClassFunction( CharacterTable( "U3(3)" ),
        [ 56, -8, 2, 2, 0, 0, 0, -2, 0, 0, 0, 0, 0, 0 ] ) ]

#### 72.12 Molien Series

##### 72.12-1 MolienSeries

`‣ MolienSeries`( [tbl, ]psi[, chi] ) | ( function )

The Molien series of the character ψ, relative to the character χ, is the rational function given by the series M_{ψ,χ}(z) = ∑_{d = 0}^∞ [χ,ψ^[d]] z^d, where ψ^[d] denotes the symmetrization of ψ with the trivial character of the symmetric group S_d (see `SymmetricParts` (72.11-2)).

`MolienSeries` returns the Molien series of psi, relative to chi, where psi and chi must be characters of the same character table; this table must be entered as tbl if chi and psi are only lists of character values. The default for chi is the trivial character of tbl.

The return value of `MolienSeries` stores a value for the attribute `MolienSeriesInfo` (72.12-2). This admits the computation of coefficients of the series with `ValueMolienSeries` (72.12-3). Furthermore, this attribute gives access to numerator and denominator of the Molien series viewed as rational function, where the denominator is a product of polynomials of the form (1-z^r)^k; the Molien series is also displayed in this form. Note that such a representation is not unique, one can use `MolienSeriesWithGivenDenominator` (72.12-4) to obtain the series with a prescribed denominator.

For more information about Molien series, see [NPP84].

    gap> t:= CharacterTable( AlternatingGroup( 5 ) );;
    gap> psi:= First( Irr( t ), x -> Degree( x ) = 3 );;
    gap> mol:= MolienSeries( psi );
    ( 1-z^2-z^3+z^6+z^7-z^9 ) / ( (1-z^5)*(1-z^3)*(1-z^2)^2 )

##### 72.12-2 MolienSeriesInfo

`‣ MolienSeriesInfo`( ratfun ) | ( attribute )

If the rational function ratfun was constructed by `MolienSeries` (72.12-1), a representation as quotient of polynomials is known such that the denominator is a product of terms of the form (1-z^r)^k. This information is encoded as value of `MolienSeriesInfo`. Additionally, there is a special `PrintObj` (6.3-5) method for Molien series based on this.

`MolienSeriesInfo` returns a record that describes the rational function ratfun as a Molien series. The components of this record are

`numer`

  numerator of ratfun (in general a multiple of the numerator one gets by `NumeratorOfRationalFunction` (66.4-2)),

`denom`

  denominator of ratfun (in general a multiple of the denominator one gets by `NumeratorOfRationalFunction` (66.4-2)),

`ratfun`

  the rational function ratfun itself,

`numerstring`

  string corresponding to the polynomial `numer`, expressed in terms of `z`,

`denomstring`

  string corresponding to the polynomial `denom`, expressed in terms of `z`,

`denominfo`

  a list of the form [ [ r_1, k_1 ], ..., [ r_n, k_n ] ] such that `denom` is ∏_{i = 1}^n (1-z^{r_i})^{k_i}.

`summands`

  a list of records, each with the components `numer`, `r`, and `k`, describing the summand `numer`/ (1-z^r)^k,

`pol`

  a list of coefficients, describing a final polynomial which is added to those described by `summands`,

`size`

  the order of the underlying matrix group,

`degree`

  the degree of the underlying matrix representation.

    gap> HasMolienSeriesInfo( mol );
    true
    gap> MolienSeriesInfo( mol );
    rec( degree := 3,
      denom := x_1^12-2*x_1^10-x_1^9+x_1^8+x_1^7+x_1^5+x_1^4-x_1^3-2*x_1^2\
    +1, denominfo := [ 5, 1, 3, 1, 2, 2 ],
      denomstring := "(1-z^5)*(1-z^3)*(1-z^2)^2",
      numer := -x_1^9+x_1^7+x_1^6-x_1^3-x_1^2+1,
      numerstring := "1-z^2-z^3+z^6+z^7-z^9", pol := [  ],
      ratfun := ( 1-z^2-z^3+z^6+z^7-z^9 ) / ( (1-z^5)*(1-z^3)*(1-z^2)^2 ),
      size := 60,
      summands := [ rec( k := 1, numer := [ -24, -12, -24 ], r := 5 ),
          rec( k := 1, numer := [ -20 ], r := 3 ),
          rec( k := 2, numer := [ -45/4, 75/4, -15/4, -15/4 ], r := 2 ),
          rec( k := 3, numer := [ -1 ], r := 1 ),
          rec( k := 1, numer := [ -15/4 ], r := 1 ) ] )

##### 72.12-3 ValueMolienSeries

`‣ ValueMolienSeries`( molser, i ) | ( function )

is the i-th coefficient of the Molien series series computed by `MolienSeries` (72.12-1).

    gap> List( [ 0 .. 20 ], i -> ValueMolienSeries( mol, i ) );
    [ 1, 0, 1, 0, 1, 0, 2, 0, 2, 0, 3, 0, 4, 0, 4, 1, 5, 1, 6, 1, 7 ]

##### 72.12-4 MolienSeriesWithGivenDenominator

`‣ MolienSeriesWithGivenDenominator`( molser, list ) | ( function )

is a Molien series equal to molser as rational function, but viewed as quotient with denominator ∏_{i = 1}^n (1-z^{r_i}), where list = [ r_1, r_2, ..., r_n ]. If molser cannot be represented this way, `fail` is returned.

    gap> MolienSeriesWithGivenDenominator( mol, [ 2, 6, 10 ] );
    ( 1+z^15 ) / ( (1-z^10)*(1-z^6)*(1-z^2) )

#### 72.13 Possible Permutation Characters

For groups H and G with H ≤ G, the induced character (1_G)^H is called the permutation character of the operation of G on the right cosets of H. If only the character table of G is available and not the group G itself, one can try to get information about possible subgroups of G by inspection of those G-class functions that might be permutation characters, using that such a class function π must have at least the following properties. (For details, see [Isa76, Theorem 5.18.]),

(a)

  π is a character of G,

(b)

  π(g) is a nonnegative integer for all g ∈ G,

(c)

  π(1) divides |G|,

(d)

  π(g^n) ≥ π(g) for g ∈ G and integers n,

(e)

  [π, 1_G] = 1,

(f)

  the multiplicity of any rational irreducible G-character ψ as a constituent of π is at most ψ(1)/[ψ, ψ],

(g)

  π(g) = 0 if the order of g does not divide |G|/π(1),

(h)

  π(1) |N_G(g)| divides π(g) |G| for all g ∈ G,

(i)

  π(g) ≤ (|G| - π(1)) / (|g^G| |Gal_G(g)|) for all nonidentity g ∈ G, where |Gal_G(g)| denotes the number of conjugacy classes of G that contain generators of the group ⟨ g ⟩,

(j)

  if p is a prime that divides |G|/π(1) only once then s/(p-1) divides |G|/π(1) and is congruent to 1 modulo p, where s is the number of elements of order p in the (hypothetical) subgroup H for which π = (1_H)^G holds. (Note that s/(p-1) equals the number of Sylow p subgroups in H.)

Any G-class function with these properties is called a possible permutation character in GAP.

(Condition (d) is checked only for those power maps that are stored in the character table of G; clearly (d) holds for all integers if it holds for all prime divisors of the group order |G|.)

GAP provides some algorithms to compute possible permutation characters (see `PermChars` (72.14-1)), and also provides functions to check a few more criteria whether a given character can be a transitive permutation character (see `TestPerm1` (72.14-2)).

Some information about the subgroup U can be computed from the permutation character (1_U)^G using `PermCharInfo` (72.13-1).

##### 72.13-1 PermCharInfo

`‣ PermCharInfo`( tbl, permchars[, format] ) | ( function )

Let tbl be the ordinary character table of the group G, and permchars either the permutation character (1_U)^G, for a subgroup U of G, or a list of such permutation characters. `PermCharInfo` returns a record with the following components.

`contained`:

  a list containing, for each character ψ = (1_U)^G in permchars, a list containing at position i the number ψ[i] |U| / `SizesCentralizers(` tbl`)`[i], which equals the number of those elements of U that are contained in class i of tbl,

`bound`:

  a list containing, for each character ψ = (1_U)^G in permchars, a list containing at position i the number |U| / gcd( |U|, `SizesCentralizers( tbl )`[i] ), which divides the class length in U of an element in class i of tbl,

`display`:

  a record that can be used as second argument of `Display` (6.3-6) to display each permutation character in permchars and the corresponding components `contained` and `bound`, for those classes where at least one character of permchars is nonzero,

`ATLAS`:

  a list of strings describing the decomposition of the permutation characters in permchars into the irreducible characters of tbl, given in an Atlas-like notation. This means that the irreducible constituents are indicated by their degrees followed by lower case letters `a`, `b`, `c`, ..., which indicate the successive irreducible characters of tbl of that degree, in the order in which they appear in `Irr(` tbl`)`. A sequence of small letters (not necessarily distinct) after a single number indicates a sum of irreducible constituents all of the same degree, an exponent n for the letter lett means that lett is repeated n times. The default notation for exponentiation is `lett^{n}`, this is also chosen if the optional third argument format is the string `"LaTeX"`; if the third argument is the string `"HTML"` then exponentiation is denoted by `lett<sup>n</sup>`.

    gap> t:= CharacterTable( "A6" );;
    gap> psi:= Sum( Irr( t ){ [ 1, 3, 6 ] } );
    Character( CharacterTable( "A6" ), [ 15, 3, 0, 3, 1, 0, 0 ] )
    gap> info:= PermCharInfo( t, psi );
    rec( ATLAS := [ "1a+5b+9a" ], bound := [ [ 1, 3, 8, 8, 6, 24, 24 ] ],
      contained := [ [ 1, 9, 0, 8, 6, 0, 0 ] ],
      display :=
        rec(
          chars := [ [ 15, 3, 0, 3, 1, 0, 0 ], [ 1, 9, 0, 8, 6, 0, 0 ],
              [ 1, 3, 8, 8, 6, 24, 24 ] ], classes := [ 1, 2, 4, 5 ],
          letter := "I" ) )
    gap> Display( t, info.display );
    A6

         2  3  3  .  2
         3  2  .  2  .
         5  1  .  .  .

           1a 2a 3b 4a
        2P 1a 1a 3b 2a
        3P 1a 2a 1a 4a
        5P 1a 2a 3b 4a

    I.1    15  3  3  1
    I.2     1  9  8  6
    I.3     1  3  8  6
    gap> j1:= CharacterTable( "J1" );;
    gap> psi:= TrivialCharacter( CharacterTable( "7:6" ) )^j1;
    Character( CharacterTable( "J1" ), [ 4180, 20, 10, 0, 0, 2, 1, 0, 0,
      0, 0, 0, 0, 0, 0 ] )
    gap> PermCharInfo( j1, psi ).ATLAS;
    [ "1a+56aabb+76aaab+77aabbcc+120aaabbbccc+133a^{4}bbcc+209a^{5}" ]

##### 72.13-2 PermCharInfoRelative

`‣ PermCharInfoRelative`( tbl, tbl2, permchars ) | ( function )

Let tbl and tbl2 be the ordinary character tables of two groups H and G, respectively, where H is of index two in G, and permchars either the permutation character (1_U)^G, for a subgroup U of G, or a list of such permutation characters. `PermCharInfoRelative` returns a record with the same components as `PermCharInfo` (72.13-1), the only exception is that the entries of the `ATLAS` component are names relative to tbl.

More precisely, the i-th entry of the `ATLAS` component is a string describing the decomposition of the i-th entry in permchars. The degrees and distinguishing letters of the constituents refer to the irreducibles of tbl, as follows. The two irreducible characters of tbl2 of degree N, say, that extend the irreducible character N `a` of tbl are denoted by N `a`^+ and N`a`^-. The irreducible character of tbl2 of degree 2N, say, whose restriction to tbl is the sum of the irreducible characters N `a` and N `b` is denoted as N `ab`. Multiplicities larger than 1 of constituents are denoted by exponents.

(This format is useful mainly for multiplicity free permutation characters.)

    gap> t:= CharacterTable( "A5" );;
    gap> t2:= CharacterTable( "A5.2" );;
    gap> List( Irr( t2 ), x -> x[1] );
    [ 1, 1, 6, 4, 4, 5, 5 ]
    gap> List( Irr( t ), x -> x[1] );
    [ 1, 3, 3, 4, 5 ]
    gap> permchars:= List( [ [1], [1,2], [1,7], [1,3,4,4,6,6,7] ],
    >                      l -> Sum( Irr( t2 ){ l } ) );
    [ Character( CharacterTable( "A5.2" ), [ 1, 1, 1, 1, 1, 1, 1 ] ),
      Character( CharacterTable( "A5.2" ), [ 2, 2, 2, 2, 0, 0, 0 ] ),
      Character( CharacterTable( "A5.2" ), [ 6, 2, 0, 1, 0, 2, 0 ] ),
      Character( CharacterTable( "A5.2" ), [ 30, 2, 0, 0, 6, 0, 0 ] ) ]
    gap> info:= PermCharInfoRelative( t, t2, permchars );;
    gap> info.ATLAS;
    [ "1a^+", "1a^{\\pm}", "1a^++5a^-",
      "1a^++3ab+4(a^+)^{2}+5a^+a^{\\pm}" ]

#### 72.14 Computing Possible Permutation Characters

##### 72.14-1 PermChars

`‣ PermChars`( tbl[, cond] ) | ( function )

GAP provides several algorithms to determine possible permutation characters from a given character table. They are described in detail in [BP98]. The algorithm is selected from the choice of the optional argument cond. The user is encouraged to try different approaches, especially if one choice fails to come to an end.

Regardless of the algorithm used in a specific case, `PermChars` returns a list of all possible permutation characters with the properties described by cond. There is no guarantee that a character of this list is in fact a permutation character. But an empty list always means there is no permutation character with these properties (e.g., of a certain degree).

Called with only one argument, a character table tbl, `PermChars` returns the list of all possible permutation characters of the group with this character table. This list might be rather long for big groups, and its computation might take much time. The algorithm is described in [BP98, Section 3.2]; it depends on a preprocessing step, where the inequalities arising from the condition π(g) ≥ 0 are transformed into a system of inequalities that guides the search (see `Inequalities` (72.14-5)). So the following commands compute the list of 39 possible permutation characters of the Mathieu group M_11.

    gap> m11:= CharacterTable( "M11" );;
    gap> SetName( m11, "m11" );
    gap> perms:= PermChars( m11 );;
    gap> Length( perms );
    39

There are two different search strategies for this algorithm. The default strategy simply constructs all characters with nonnegative values and then tests for each such character whether its degree is a divisor of the order of the group. The other strategy uses the inequalities to predict whether a character of a certain degree can lie in the currently searched part of the search tree. To choose this strategy, enter a record as the second argument of `PermChars`, and set its component `degree` to the range of degrees (which might also be a range containing all divisors of the group order) you want to look for; additionally, the record component `ineq` can take the inequalities computed by `Inequalities` (72.14-5) if they are needed more than once.

If a positive integer is given as the second argument cond, `PermChars` returns the list of all possible permutation characters of tbl that have degree cond. For that purpose, a preprocessing step is performed where essentially the rational character table is inverted in order to determine boundary points for the simplex in which the possible permutation characters of the given degree must lie (see `PermBounds` (72.14-3)). The algorithm is described at the end of [BP98, Section 3.2]. Note that inverting big integer matrices needs a lot of time and space. So this preprocessing is restricted to groups with less than 100 classes, say.

    gap> deg220:= PermChars( m11, 220 );
    [ Character( m11, [ 220, 4, 4, 0, 0, 4, 0, 0, 0, 0 ] ),
      Character( m11, [ 220, 12, 4, 4, 0, 0, 0, 0, 0, 0 ] ),
      Character( m11, [ 220, 20, 4, 0, 0, 2, 0, 0, 0, 0 ] ) ]

If a record is given as the second argument cond, `PermChars` returns the list of all possible permutation characters that have the properties described by the components of this record. One such situation has been mentioned above. If cond contains a degree as value of the record component `degree` then `PermChars` will behave exactly as if this degree was entered as cond.

    gap> deg220 = PermChars( m11, rec( degree:= 220 ) );
    true

For the meaning of additional components of cond besides `degree`, see `PermComb` (72.14-4).

Instead of `degree`, cond may have the component `torso` bound to a list that contains some known values of the required characters at the right positions; at least the degree cond`.torso[1]` must be an integer. In this case, the algorithm described in [BP98, Section 3.3] is chosen. The component `chars`, if present, holds a list of all those rational irreducible characters of tbl that might be constituents of the required characters.

(Note: If cond`.chars` is bound and does not contain all rational irreducible characters of tbl, GAP checks whether the scalar products of all class functions in the result list with the omitted rational irreducible characters of tbl are nonnegative; so there should be nontrivial reasons for excluding a character that is known to be not a constituent of the desired possible permutation characters.)

    gap> PermChars( m11, rec( torso:= [ 220 ] ) );
    [ Character( m11, [ 220, 4, 4, 0, 0, 4, 0, 0, 0, 0 ] ),
      Character( m11, [ 220, 20, 4, 0, 0, 2, 0, 0, 0, 0 ] ),
      Character( m11, [ 220, 12, 4, 4, 0, 0, 0, 0, 0, 0 ] ) ]
    gap> PermChars( m11, rec( torso:= [ 220,,,,, 2 ] ) );
    [ Character( m11, [ 220, 20, 4, 0, 0, 2, 0, 0, 0, 0 ] ) ]

An additional restriction on the possible permutation characters computed can be forced if con contains, in addition to `torso`, the components `normalsubgroup` and `nonfaithful`, with values a list of class positions of a normal subgroup N of the group G of tbl and a possible permutation character π of G, respectively, such that N is contained in the kernel of π. In this case, `PermChars` returns the list of those possible permutation characters ψ of tbl coinciding with `torso` wherever its values are bound and having the property that no irreducible constituent of ψ - π has N in its kernel. If the component `chars` is bound in cond then the above statements apply. An interpretation of the computed characters is the following. Suppose there exists a subgroup V of G such that π = (1_V)^G; Then N ≤ V, and if a computed character is of the form (1_U)^G, for a subgroup U of G, then V = UN.

    gap> s4:= CharacterTable( "Symmetric", 4 );;
    gap> nsg:= ClassPositionsOfDerivedSubgroup( s4 );;
    gap> pi:= TrivialCharacter( s4 );;
    gap> PermChars( s4, rec( torso:= [ 12 ], normalsubgroup:= nsg,
    >                        nonfaithful:= pi ) );
    [ Character( CharacterTable( "Sym(4)" ), [ 12, 2, 0, 0, 0 ] ) ]
    gap> pi:= Sum( Filtered( Irr( s4 ),
    >              chi -> IsSubset( ClassPositionsOfKernel( chi ), nsg ) ) );
    Character( CharacterTable( "Sym(4)" ), [ 2, 0, 2, 2, 0 ] )
    gap> PermChars( s4, rec( torso:= [ 12 ], normalsubgroup:= nsg,
    >                        nonfaithful:= pi ) );
    [ Character( CharacterTable( "Sym(4)" ), [ 12, 0, 4, 0, 0 ] ) ]

The class functions returned by `PermChars` have the properties tested by `TestPerm1` (72.14-2), `TestPerm2` (72.14-2), and `TestPerm3` (72.14-2). So they are possible permutation characters. See `TestPerm1` (72.14-2) for criteria whether a possible permutation character can in fact be a permutation character.

##### 72.14-2 TestPerm1, ..., TestPerm5

`‣ TestPerm1`( tbl, char ) | ( function )

`‣ TestPerm2`( tbl, char ) | ( function )

`‣ TestPerm3`( tbl, chars ) | ( function )

`‣ TestPerm4`( tbl, chars ) | ( function )

`‣ TestPerm5`( tbl, chars, modtbl ) | ( function )

The first three of these functions implement tests of the properties of possible permutation characters listed in Section 72.13, The other two implement test of additional properties. Let tbl be the ordinary character table of a group G, say, char a rational character of tbl, and chars a list of rational characters of tbl. For applying `TestPerm5`, the knowledge of a p-modular Brauer table modtbl of G is required. `TestPerm4` and `TestPerm5` expect the characters in chars to satisfy the conditions checked by `TestPerm1` and `TestPerm2` (see below).

The return values of the functions were chosen parallel to the tests listed in [NPP84].

`TestPerm1` return `1` or `2` if char fails because of (T1) or (T2), respectively; this corresponds to the criteria (b) and (d). Note that only those power maps are considered that are stored on tbl. If char satisfies the conditions, `0` is returned.

`TestPerm2` returns `1` if char fails because of the criterion (c), it returns `3`, `4`, or `5` if char fails because of (T3), (T4), or (T5), respectively; these tests correspond to (g), a weaker form of (h), and (j). If char satisfies the conditions, `0` is returned.

`TestPerm3` returns the list of all those class functions in the list chars that satisfy criterion (h); this is a stronger version of (T6).

`TestPerm4` returns the list of all those class functions in the list chars that satisfy (T8) and (T9) for each prime divisor p of the order of G; these tests use modular representation theory but do not require the knowledge of decomposition matrices (cf. `TestPerm5` below).

(T8) implements the test of the fact that in the case that p divides |G| and the degree of a transitive permutation character π exactly once, the projective cover of the trivial character is a summand of π. (This test is omitted if the projective cover cannot be identified.)

Given a permutation character π of a group G and a prime integer p, the restriction π_B to a p-block B of G has the following property, which is checked by (T9). For each g ∈ G such that g^n is a p-element of G, π_B(g^n) is a nonnegative integer that satisfies |π_B(g)| ≤ π_B(g^n) ≤ π(g^n). (This is [Sco73, Corollary A on p. 113].)

`TestPerm5` requires the p-modular Brauer table modtbl of G, for some prime p dividing the order of G, and checks whether those characters in the list chars whose degree is divisible by the p-part of the order of G can be decomposed into projective indecomposable characters; `TestPerm5` returns the sublist of all those characters in chars that either satisfy this condition or to which the test does not apply.

    gap> tbl:= CharacterTable( "A5" );;
    gap> rat:= RationalizedMat( Irr( tbl ) );
    [ Character( CharacterTable( "A5" ), [ 1, 1, 1, 1, 1 ] ),
      Character( CharacterTable( "A5" ), [ 6, -2, 0, 1, 1 ] ),
      Character( CharacterTable( "A5" ), [ 4, 0, 1, -1, -1 ] ),
      Character( CharacterTable( "A5" ), [ 5, 1, -1, 0, 0 ] ) ]
    gap> tup:= Filtered( Tuples( [ 0, 1 ], 4 ), x -> not IsZero( x ) );
    [ [ 0, 0, 0, 1 ], [ 0, 0, 1, 0 ], [ 0, 0, 1, 1 ], [ 0, 1, 0, 0 ],
      [ 0, 1, 0, 1 ], [ 0, 1, 1, 0 ], [ 0, 1, 1, 1 ], [ 1, 0, 0, 0 ],
      [ 1, 0, 0, 1 ], [ 1, 0, 1, 0 ], [ 1, 0, 1, 1 ], [ 1, 1, 0, 0 ],
      [ 1, 1, 0, 1 ], [ 1, 1, 1, 0 ], [ 1, 1, 1, 1 ] ]
    gap> lincomb:= List( tup, coeff -> coeff * rat );;
    gap> List( lincomb, psi -> TestPerm1( tbl, psi ) );
    [ 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0 ]
    gap> List( lincomb, psi -> TestPerm2( tbl, psi ) );
    [ 0, 5, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1 ]
    gap> Set( List( TestPerm3(tbl, lincomb), x -> Position(lincomb, x) ) );
    [ 1, 4, 6, 7, 8, 9, 10, 11, 13 ]
    gap> tbl:= CharacterTable( "A7" );
    CharacterTable( "A7" )
    gap> perms:= PermChars( tbl, rec( degree:= 315 ) );
    [ Character( CharacterTable( "A7" ), [ 315, 3, 0, 0, 3, 0, 0, 0, 0 ] )
        , Character( CharacterTable( "A7" ),
        [ 315, 15, 0, 0, 1, 0, 0, 0, 0 ] ) ]
    gap> TestPerm4( tbl, perms );
    [ Character( CharacterTable( "A7" ), [ 315, 15, 0, 0, 1, 0, 0, 0, 0
         ] ) ]
    gap> perms:= PermChars( tbl, rec( degree:= 15 ) );
    [ Character( CharacterTable( "A7" ), [ 15, 3, 0, 3, 1, 0, 0, 1, 1 ] ),
      Character( CharacterTable( "A7" ), [ 15, 3, 3, 0, 1, 0, 3, 1, 1 ] )
     ]
    gap> TestPerm5( tbl, perms, tbl mod 5 );
    [ Character( CharacterTable( "A7" ), [ 15, 3, 0, 3, 1, 0, 0, 1, 1 ] )
     ]

##### 72.14-3 PermBounds

`‣ PermBounds`( tbl, d ) | ( function )

Let tbl be the ordinary character table of the group G. All G-characters π satisfying π(g) > 0 and π(1) = d, for a given degree d, lie in a simplex described by these conditions. `PermBounds` computes the boundary points of this simplex for d = 0, from which the boundary points for any other d are easily derived. (Some conditions from the power maps of tbl are also involved.) For this purpose, a matrix similar to the rational character table of G has to be inverted. These boundary points are used by `PermChars` (72.14-1) to construct all possible permutation characters (see 72.13) of a given degree. `PermChars` (72.14-1) either calls `PermBounds` or takes this information from the `bounds` component of its argument record.

##### 72.14-4 PermComb

`‣ PermComb`( tbl, arec ) | ( function )

`PermComb` computes possible permutation characters of the character table tbl by the improved combinatorial approach described at the end of [BP98, Section 3.2].

For computing the possible linear combinations without prescribing better bounds (i.e., when the computation of bounds shall be suppressed), enter

`arec:= rec( degree := degree, bounds := false )`,

where degree is the character degree; this is useful if the multiplicities are expected to be small, and if this is forced by high irreducible degrees.

A list of upper bounds on the multiplicities of the rational irreducibles characters can be explicitly prescribed as a `maxmult` component in arec.

##### 72.14-5 Inequalities

`‣ Inequalities`( tbl, chars[, option] ) | ( operation )

Let tbl be the ordinary character table of a group G. The condition π(g) ≥ 0 for every possible permutation character π of G places restrictions on the multiplicities a_i of the irreducible constituents χ_i of π = ∑_{i = 1}^r a_i χ_i. For every element g ∈ G, we have ∑_{i = 1}^r a_i χ_i(g) ≥ 0. The power maps provide even stronger conditions.

This system of inequalities is kind of diagonalized, resulting in a system of inequalities restricting a_i in terms of a_j, j < i. These inequalities are used to construct characters with nonnegative values (see `PermChars` (72.14-1)). `PermChars` (72.14-1) either calls `Inequalities` or takes this information from the `ineq` component of its argument record.

The number of inequalities arising in the process of diagonalization may grow very strongly.

There are two ways to organize the projection. The first, which is chosen if no option argument is present, is the straight approach which takes the rational irreducible characters in their original order and by this guarantees the character with the smallest degree to be considered first. The other way, which is chosen if the string `"small"` is entered as third argument option, tries to keep the number of intermediate inequalities small by eventually changing the order of characters.

    gap> tbl:= CharacterTable( "M11" );;
    gap> PermComb( tbl, rec( degree:= 110 ) );
    [ Character( CharacterTable( "M11" ),
        [ 110, 6, 2, 2, 0, 0, 2, 2, 0, 0 ] ),
      Character( CharacterTable( "M11" ),
        [ 110, 6, 2, 6, 0, 0, 0, 0, 0, 0 ] ),
      Character( CharacterTable( "M11" ), [ 110, 14, 2, 2, 0, 2, 0, 0, 0,
          0 ] ) ]
    gap> # Now compute only multiplicity free permutation characters.
    gap> bounds:= List( RationalizedMat( Irr( tbl ) ), x -> 1 );;
    gap> PermComb( tbl, rec( degree:= 110, maxmult:= bounds ) );
    [ Character( CharacterTable( "M11" ),
        [ 110, 6, 2, 2, 0, 0, 2, 2, 0, 0 ] ) ]

#### 72.15 Operations for Brauer Characters

##### 72.15-1 FrobeniusCharacterValue

`‣ FrobeniusCharacterValue`( value, p ) | ( function )

Let value be a cyclotomic whose coefficients over the rationals are in the ring ℤ_p of p-local numbers, where p is a prime integer. Assume that value lies in ℤ_p[ζ] for ζ = exp(p^n-1), for some positive integer n.

`FrobeniusCharacterValue` returns the image of value under the ring homomorphism from ℤ_p[ζ] to the field with p^n elements that is defined with the help of Conway polynomials (see `ConwayPolynomial` (59.5-1)), more information can be found in [JLPW95, Sections 2-5].

If value is a Brauer character value in characteristic p then the result can be described as the corresponding value of the Frobenius character, that is, as the trace of a representing matrix with the given Brauer character value.

If the result of `FrobeniusCharacterValue` cannot be expressed as an element of a finite field in GAP (see Chapter 59) then `FrobeniusCharacterValue` returns `fail`.

If the Conway polynomial of degree n is required for the computation then it is computed only if `IsCheapConwayPolynomial` (59.5-2) returns `true` when it is called with p and n, otherwise `fail` is returned.

##### 72.15-2 BrauerCharacterValue

`‣ BrauerCharacterValue`( mat ) | ( attribute )

For an invertible matrix mat over a finite field F, `BrauerCharacterValue` returns the Brauer character value of mat if the order of mat is coprime to the characteristic of F, and `fail` otherwise.

The Brauer character value of a matrix is the sum of complex lifts of its eigenvalues.

    gap> g:= SL(2,4);;           # 2-dim. irreducible representation of A5
    gap> ccl:= ConjugacyClasses( g );;
    gap> rep:= List( ccl, Representative );;
    gap> List( rep, Order );
    [ 1, 2, 5, 5, 3 ]
    gap> phi:= List( rep, BrauerCharacterValue );
    [ 2, fail, E(5)^2+E(5)^3, E(5)+E(5)^4, -1 ]
    gap> List( phi{ [ 1, 3, 4, 5 ] }, x -> FrobeniusCharacterValue( x, 2 ) );
    [ 0*Z(2), Z(2^2), Z(2^2)^2, Z(2)^0 ]
    gap> List( rep{ [ 1, 3, 4, 5 ] }, TraceMat );
    [ 0*Z(2), Z(2^2), Z(2^2)^2, Z(2)^0 ]

##### 72.15-3 SizeOfFieldOfDefinition

`‣ SizeOfFieldOfDefinition`( val, p ) | ( function )

For a cyclotomic or a list of cyclotomics val, and a prime integer p, `SizeOfFieldOfDefinition` returns the size of the smallest finite field in characteristic p that contains the p-modular reduction of val.

The reduction map is defined as in [JLPW95], that is, the complex (p^d-1)-th root of unity exp(p^d-1) is mapped to the residue class of the indeterminate, modulo the ideal spanned by the Conway polynomial (see `ConwayPolynomial` (59.5-1)) of degree d over the field with p elements.

If val is a Brauer character then the value returned is the size of the smallest finite field in characteristic p over which the corresponding representation lives.

##### 72.15-4 RealizableBrauerCharacters

`‣ RealizableBrauerCharacters`( matrix, q ) | ( function )

For a list matrix of absolutely irreducible Brauer characters in characteristic p, and a power q of p, `RealizableBrauerCharacters` returns a duplicate-free list of sums of Frobenius conjugates of the rows of matrix, each irreducible over the field with q elements.

    gap> irr:= 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 ] ) ]
    gap> List( irr, phi -> SizeOfFieldOfDefinition( phi, 2 ) );
    [ 2, 4, 4, 2 ]
    gap> RealizableBrauerCharacters( irr, 2 );
    [ Character( BrauerTable( "A5", 2 ), [ 1, 1, 1, 1 ] ),
      ClassFunction( BrauerTable( "A5", 2 ), [ 4, -2, -1, -1 ] ),
      Character( BrauerTable( "A5", 2 ), [ 4, 1, -1, -1 ] ) ]

#### 72.16 Domains Generated by Class Functions

GAP supports groups, vector spaces, and algebras generated by class functions.

[Top of Book] [Contents] [Previous Chapter] [Next Chapter]
Goto Chapter: Top 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 Bib Ind

generated by GAPDoc2HTML