# 48.13 Advanced Methods for Dixon Schneider Calculations

The computation of character tables of very large groups may take quite some time. On the other hand, for the expert only a few irreducible characters may be needed, since the other ones can be computed using character theoretic methods like tensoring, induction, and restriction. Thus GAP provides also step-by-step routines for doing the calculations, that will allow to compute some characters, and stop before all are calculated. Note that there is no 'safety net', i.e., the routines, being somehow internal, do no error checking, and assume the information given are correct.

When the global variable `InfoCharTable1` if set to `Print`, information about the progress of splitting is printed. The default value of `InfoCharTable1` is `Ignore`.

`DixonInit( G )`

does the setup for the computation of characters: It computes conjugacy classes, power maps and linear characters (in the case of AgGroups it also contains a call of `CharTablePGroup`). `DixonInit` returns a special record D (see below), which stores all informations needed for the further computations. The power maps are computed for all primes smaller than the exponent of G, thus allowing to induce the characters of all cyclic subgroups by `InducedCyclic` (see InducedCyclic). For internal purposes, the algorithm uses a permuted arrangement of the classes and probably a different ---but isomorphic--- group. It is possible to obtain different informations about the progress of the splitting process as well as the partially computed character table from the record D.

`DixontinI( D )`

is the reverse function: It takes a Dixon record D and returns the old group G. It also does the cleanup of D. The returned group contains the component `charTable`, containing the character table as far as known. The classes are arranged in the same way, as the classes of G.

`DixonSplit( D )`

will do the main splitting task: It chooses a class and splits the character spaces using the corresponding class matrix. Characters are computed as far as possible.

`CombinatoricSplit( D )`

tries to split two-dimensional character spaces by combinatoric means. It is called automatically by `DixonSplit`. A separate call can be useful, when new characters have been found, that reduce the size of the character spaces.

`IncludeIrreducibles( D, list )`

If you have found irreducible characters by other means ---like tensoring etc.--- you must not include them in the character table yourself, but let them include, using this routine. Otherwise GAP would lose control of the characters yet known. The characters given in list must be according to the arrangement of classes in D. GAP will automatically take the closure of list under the galoisgroup and tensor products with one-dimensional characters.

`SplitCharacters( D, list )`

This routine decomposes the characters, given in list according to the character spaces found up to this point. By applying this routine to tensor products etc., it may result in characters with smaller norm, even irreducible ones. Since the recalculation of characters is only possible, if the degree is small enough, the splitting process is applied only to characters of sufficiently small degree.

Some notes on the record D returned by `DixonInit`:

This record stores several items of mainly internal interest. There are some entries, however, that may be useful to know about when using the advanced methods described above. The computation need not to take place in the original group, but in an isomorphic image W. This may be the same group as the group given, but --- depending on the group --- also a new one. Additionally the initialisation process will create a new list of the conjugacy classes with possibly different arrangement. For access to these informations, the following record components of the ``Dixon Record'' D might be of interest:

`group`:

the group W,

`oldG`:

the group G, of which the character table is to be computed,

`conjugacyClasses`:

classes of W; this list contains the same classes as `W.conjugacyClasses`, only the arrangement is different,

`charTable`:

contains the partially computed character table. The classes are arranged according to `D.conjugacyClasses`,

`classPermutation`:

permutation to apply to the classes to obtain the old arrangement.

GAP 3.4.4
April 1997