5 Functions for Character Table Constructions

5.8 Construction Functions used in the Character Table Library

5.8-1 ConstructMGA

5.8-2 ConstructMGAInfo

5.8-3 ConstructGS3

5.8-4 ConstructV4G

5.8-5 ConstructProj

5.8-6 ConstructDirectProduct

5.8-7 ConstructCentralProduct

5.8-8 ConstructSubdirect

5.8-9 ConstructWreathSymmetric

5.8-10 ConstructIsoclinic

5.8-11 ConstructPermuted

5.8-12 ConstructAdjusted

5.8-13 ConstructFactor

5.8-1 ConstructMGA

5.8-2 ConstructMGAInfo

5.8-3 ConstructGS3

5.8-4 ConstructV4G

5.8-5 ConstructProj

5.8-6 ConstructDirectProduct

5.8-7 ConstructCentralProduct

5.8-8 ConstructSubdirect

5.8-9 ConstructWreathSymmetric

5.8-10 ConstructIsoclinic

5.8-11 ConstructPermuted

5.8-12 ConstructAdjusted

5.8-13 ConstructFactor

The functions described in this chapter deal with the construction of character tables from other character tables. So they fit to the functions in Section Reference: Constructing Character Tables from Others. But since they are used in situations that are typical for the **GAP** Character Table Library, they are described here.

An important ingredient of the constructions is the description of the action of a group automorphism on the classes by a permutation. In practice, these permutations are usually chosen from the group of table automorphisms of the character table in question, see `AutomorphismsOfTable`

(Reference: AutomorphismsOfTable).

Section 5.1 deals with groups of the structure \(M.G.A\), where the upwards extension \(G.A\) acts suitably on the central extension \(M.G\). Section 5.2 deals with groups that have a factor group of type \(S_3\). Section 5.3 deals with upward extensions of a group by a Klein four group. Section 5.4 deals with downward extensions of a group by a Klein four group. Section 5.6 describes the construction of certain Brauer tables. Section 5.7 deals with special cases of the construction of character tables of central extensions from known character tables of suitable factor groups. Section 5.8 documents the functions used to encode certain tables in the **GAP** Character Table Library.

Examples can be found in [Breb] and [Bref].

For the functions in this section, let \(H\) be a group with normal subgroups \(N\) and \(M\) such that \(H/N\) is cyclic, \(M \leq N\) holds, and such that each irreducible character of \(N\) that does not contain \(M\) in its kernel induces irreducibly to \(H\). (This is satisfied for example if \(N\) has prime index in \(H\) and \(M\) is a group of prime order that is central in \(N\) but not in \(H\).) Let \(G = N/M\) and \(A = H/N\), so \(H\) has the structure \(M.G.A\). For some examples, see [Bre11].

`‣ PossibleCharacterTablesOfTypeMGA` ( tblMG, tblG, tblGA, orbs, identifier ) | ( function ) |

Let \(H\), \(N\), and \(M\) be as described at the beginning of the section.

Let `tblMG`, `tblG`, `tblGA` be the ordinary character tables of the groups \(M.G = N\), \(G\), and \(G.A = H/M\), respectively, and `orbs` be the list of orbits on the class positions of `tblMG` that is induced by the action of \(H\) on \(M.G\). Furthermore, let the class fusions from `tblMG` to `tblG` and from `tblG` to `tblGA` be stored on `tblMG` and `tblG`, respectively (see `StoreFusion`

(Reference: StoreFusion)).

`PossibleCharacterTablesOfTypeMGA`

returns a list of records describing all possible ordinary character tables for groups \(H\) that are compatible with the arguments. Note that in general there may be several possible groups \(H\), and it may also be that "character tables" are constructed for which no group exists.

Each of the records in the result has the following components.

`table`

a possible ordinary character table for \(H\), and

`MGfusMGA`

the fusion map from

`tblMG`into the table stored in`table`

.

The possible tables differ w. r. t. some power maps, and perhaps element orders and table automorphisms; in particular, the `MGfusMGA`

component is the same in all records.

The returned tables have the `Identifier`

(Reference: Identifier for character tables) value `identifier`. The classes of these tables are sorted as follows. First come the classes contained in \(M.G\), sorted compatibly with the classes in `tblMG`, then the classes in \(H \setminus M.G\) follow, in the same ordering as the classes of \(G.A \setminus G\).

`‣ BrauerTableOfTypeMGA` ( modtblMG, modtblGA, ordtblMGA ) | ( function ) |

Let \(H\), \(N\), and \(M\) be as described at the beginning of the section, let `modtblMG` and `modtblGA` be the \(p\)-modular character tables of the groups \(N\) and \(H/M\), respectively, and let `ordtblMGA` be the \(p\)-modular Brauer table of \(H\), for some prime integer \(p\). Furthermore, let the class fusions from the ordinary character table of `modtblMG` to `ordtblMGA` and from `ordtblMGA` to the ordinary character table of `modtblGA` be stored.

`BrauerTableOfTypeMGA`

returns the \(p\)-modular character table of \(H\).

`‣ PossibleActionsForTypeMGA` ( tblMG, tblG, tblGA ) | ( function ) |

Let the arguments be as described for `PossibleCharacterTablesOfTypeMGA`

(5.1-1). `PossibleActionsForTypeMGA`

returns the set of orbit structures \(\Omega\) on the class positions of `tblMG` that can be induced by the action of \(H\) on the classes of \(M.G\) in the sense that \(\Omega\) is the set of orbits of a table automorphism of `tblMG` (see `AutomorphismsOfTable`

(Reference: AutomorphismsOfTable)) that is compatible with the stored class fusions from `tblMG` to `tblG` and from `tblG` to `tblGA`. Note that the number of such orbit structures can be smaller than the number of the underlying table automorphisms.

Information about the progress is reported if the info level of `InfoCharacterTable`

(Reference: InfoCharacterTable) is at least \(1\) (see `SetInfoLevel`

(Reference: InfoLevel)).

`‣ CharacterTableOfTypeGS3` ( tbl, tbl2, tbl3, aut, identifier ) | ( function ) |

`‣ CharacterTableOfTypeGS3` ( modtbl, modtbl2, modtbl3, ordtbls3, identifier ) | ( function ) |

Let \(H\) be a group with a normal subgroup \(G\) such that \(H/G \cong S_3\), the symmetric group on three points, and let \(G.2\) and \(G.3\) be preimages of subgroups of order \(2\) and \(3\), respectively, under the natural projection onto this factor group.

In the first form, let `tbl`, `tbl2`, `tbl3` be the ordinary character tables of the groups \(G\), \(G.2\), and \(G.3\), respectively, and `aut` be the permutation of classes of `tbl3` induced by the action of \(H\) on \(G.3\). Furthermore assume that the class fusions from `tbl` to `tbl2` and `tbl3` are stored on `tbl` (see `StoreFusion`

(Reference: StoreFusion)). In particular, the two class fusions must be compatible in the sense that the induced action on the classes of `tbl` describes an action of \(S_3\).

In the second form, let `modtbl`, `modtbl2`, `modtbl3` be the \(p\)-modular character tables of the groups \(G\), \(G.2\), and \(G.3\), respectively, and `ordtbls3` be the ordinary character table of \(H\).

`CharacterTableOfTypeGS3`

returns a record with the following components.

`table`

the ordinary or \(p\)-modular character table of \(H\), respectively,

`tbl2fustbls3`

the fusion map from

`tbl2`into the table of \(H\), and`tbl3fustbls3`

the fusion map from

`tbl3`into the table of \(H\).

The returned table of \(H\) has the `Identifier`

(Reference: Identifier for character tables) value `identifier`. The classes of the table of \(H\) are sorted as follows. First come the classes contained in \(G.3\), sorted compatibly with the classes in `tbl3`, then the classes in \(H \setminus G.3\) follow, in the same ordering as the classes of \(G.2 \setminus G\).

In fact the code is applicable in the more general case that \(H/G\) is a Frobenius group \(F = K C\) with abelian kernel \(K\) and cyclic complement \(C\) of prime order, see [Bref]. Besides \(F = S_3\), e. g., the case \(F = A_4\) is interesting.

`‣ PossibleActionsForTypeGS3` ( tbl, tbl2, tbl3 ) | ( function ) |

Let the arguments be as described for `CharacterTableOfTypeGS3`

(5.2-1). `PossibleActionsForTypeGS3`

returns the set of those table automorphisms (see `AutomorphismsOfTable`

(Reference: AutomorphismsOfTable)) of `tbl3` that can be induced by the action of \(H\) on the classes of `tbl3`.

Information about the progress is reported if the info level of `InfoCharacterTable`

(Reference: InfoCharacterTable) is at least \(1\) (see `SetInfoLevel`

(Reference: InfoLevel)).

The following functions are thought for constructing the possible ordinary character tables of a group of structure \(G.2^2\) from the known tables of the three normal subgroups of type \(G.2\).

`‣ PossibleCharacterTablesOfTypeGV4` ( tblG, tblsG2, acts, identifier[, tblGfustblsG2] ) | ( function ) |

`‣ PossibleCharacterTablesOfTypeGV4` ( modtblG, modtblsG2, ordtblGV4[, ordtblsG2fusordtblG4] ) | ( function ) |

Let \(H\) be a group with a normal subgroup \(G\) such that \(H/G\) is a Klein four group, and let \(G.2_1\), \(G.2_2\), and \(G.2_3\) be the three subgroups of index two in \(H\) that contain \(G\).

In the first version, let `tblG` be the ordinary character table of \(G\), let `tblsG2` be a list containing the three character tables of the groups \(G.2_i\), and let `acts` be a list of three permutations describing the action of \(H\) on the conjugacy classes of the corresponding tables in `tblsG2`. If the class fusions from `tblG` into the tables in `tblsG2` are not stored on `tblG` (for example, because the three tables are equal) then the three maps must be entered in the list `tblGfustblsG2`.

In the second version, let `modtblG` be the \(p\)-modular character table of \(G\), `modtblsG` be the list of \(p\)-modular Brauer tables of the groups \(G.2_i\), and `ordtblGV4` be the ordinary character table of \(H\). In this case, the class fusions from the ordinary character tables of the groups \(G.2_i\) to `ordtblGV4` can be entered in the list `ordtblsG2fusordtblG4`.

`PossibleCharacterTablesOfTypeGV4`

returns a list of records describing all possible (ordinary or \(p\)-modular) character tables for groups \(H\) that are compatible with the arguments. Note that in general there may be several possible groups \(H\), and it may also be that "character tables" are constructed for which no group exists. Each of the records in the result has the following components.

`table`

a possible (ordinary or \(p\)-modular) character table for \(H\), and

`G2fusGV4`

the list of fusion maps from the tables in

`tblsG2`into the`table`

component.

The possible tables differ w.r.t. the irreducible characters and perhaps the table automorphisms; in particular, the `G2fusGV4`

component is the same in all records.

The returned tables have the `Identifier`

(Reference: Identifier for character tables) value `identifier`. The classes of these tables are sorted as follows. First come the classes contained in \(G\), sorted compatibly with the classes in `tblG`, then the outer classes in the tables in `tblsG2` follow, in the same ordering as in these tables.

`‣ PossibleActionsForTypeGV4` ( tblG, tblsG2 ) | ( function ) |

Let the arguments be as described for `PossibleCharacterTablesOfTypeGV4`

(5.3-1). `PossibleActionsForTypeGV4`

returns the list of those triples \([ \pi_1, \pi_2, \pi_3 ]\) of permutations for which a group \(H\) may exist that contains \(G.2_1\), \(G.2_2\), \(G.2_3\) as index \(2\) subgroups which intersect in the index \(4\) subgroup \(G\).

Information about the progress is reported if the level of `InfoCharacterTable`

(Reference: InfoCharacterTable) is at least \(1\) (see `SetInfoLevel`

(Reference: InfoLevel)).

The following functions are thought for constructing the possible ordinary or Brauer character tables of a group of structure \(2^2.G\) from the known tables of the three factor groups modulo the normal order two subgroups in the central Klein four group.

Note that in the ordinary case, only a list of possibilities can be computed whereas in the modular case, where the ordinary character table is assumed to be known, the desired table is uniquely determined.

`‣ PossibleCharacterTablesOfTypeV4G` ( tblG, tbls2G, id[, fusions] ) | ( function ) |

`‣ PossibleCharacterTablesOfTypeV4G` ( tblG, tbl2G, aut, id ) | ( function ) |

Let \(H\) be a group with a central subgroup \(N\) of type \(2^2\), and let \(Z_1\), \(Z_2\), \(Z_3\) be the order \(2\) subgroups of \(N\).

In the first form, let `tblG` be the ordinary character table of \(H/N\), and `tbls2G` be a list of length three, the entries being the ordinary character tables of the groups \(H/Z_i\). In the second form, let `tbl2G` be the ordinary character table of \(H/Z_1\) and `aut` be a permutation; here it is assumed that the groups \(Z_i\) are permuted under an automorphism \(\sigma\) of order \(3\) of \(H\), and that \(\sigma\) induces the permutation `aut` on the classes of `tblG`.

The class fusions onto `tblG` are assumed to be stored on the tables in `tbls2G` or `tbl2G`, respectively, except if they are explicitly entered via the optional argument `fusions`.

`PossibleCharacterTablesOfTypeV4G`

returns the list of all possible character tables for \(H\) in this situation. The returned tables have the `Identifier`

(Reference: Identifier for character tables) value `id`.

`‣ BrauerTableOfTypeV4G` ( ordtblV4G, modtbls2G ) | ( function ) |

`‣ BrauerTableOfTypeV4G` ( ordtblV4G, modtbl2G, aut ) | ( function ) |

Let \(H\) be a group with a central subgroup \(N\) of type \(2^2\), and let `ordtblV4G` be the ordinary character table of \(H\). Let \(Z_1\), \(Z_2\), \(Z_3\) be the order \(2\) subgroups of \(N\). In the first form, let `modtbls2G` be the list of the \(p\)-modular Brauer tables of the factor groups \(H/Z_1\), \(H/Z_2\), and \(H/Z_3\), for some prime integer \(p\). In the second form, let `modtbl2G` be the \(p\)-modular Brauer table of \(H/Z_1\) and `aut` be a permutation; here it is assumed that the groups \(Z_i\) are permuted under an automorphism \(\sigma\) of order \(3\) of \(H\), and that \(\sigma\) induces the permutation `aut` on the classes of the ordinary character table of \(H\) that is stored in `ordtblV4G`.

The class fusions from `ordtblV4G` to the ordinary character tables of the tables in `modtbls2G` or `modtbl2G` are assumed to be stored.

`BrauerTableOfTypeV4G`

returns the \(p\)-modular character table of \(H\).

The following function is thought for constructing the (ordinary or Brauer) character tables of certain subdirect products from the known tables of the factor groups and normal subgroups involved.

`‣ CharacterTableOfIndexTwoSubdirectProduct` ( tblH1, tblG1, tblH2, tblG2, identifier ) | ( function ) |

Returns: a record containing the character table of the subdirect product \(G\) that is described by the first four arguments.

Let `tblH1`, `tblG1`, `tblH2`, `tblG2` be the character tables of groups \(H_1\), \(G_1\), \(H_2\), \(G_2\), such that \(H_1\) and \(H_2\) have index two in \(G_1\) and \(G_2\), respectively, and such that the class fusions corresponding to these embeddings are stored on `tblH1` and `tblH1`, respectively.

In this situation, the direct product of \(G_1\) and \(G_2\) contains a unique subgroup \(G\) of index two that contains the direct product of \(H_1\) and \(H_2\) but does not contain any of the groups \(G_1\), \(G_2\).

The function `CharacterTableOfIndexTwoSubdirectProduct`

returns a record with the following components.

`table`

the character table of \(G\),

`H1fusG`

the class fusion from

`tblH1`into the table of \(G\), and`H2fusG`

the class fusion from

`tblH2`into the table of \(G\).

If the first four arguments are *ordinary* character tables then the fifth argument `identifier` must be a string; this is used as the `Identifier`

(Reference: Identifier for character tables) value of the result table.

If the first four arguments are *Brauer* character tables for the same characteristic then the fifth argument must be the ordinary character table of the desired subdirect product.

`‣ ConstructIndexTwoSubdirectProduct` ( tbl, tblH1, tblG1, tblH2, tblG2, permclasses, permchars ) | ( function ) |

`ConstructIndexTwoSubdirectProduct`

constructs the irreducible characters of the ordinary character table `tbl` of the subdirect product of index two in the direct product of `tblG1` and `tblG2`, which contains the direct product of `tblH1` and `tblH2` but does not contain any of the direct factors `tblG1`, `tblG2`. W. r. t. the default ordering obtained from that given by `CharacterTableDirectProduct`

(Reference: CharacterTableDirectProduct), the columns and the rows of the matrix of irreducibles are permuted with the permutations `permclasses` and `permchars`, respectively.

`‣ ConstructIndexTwoSubdirectProductInfo` ( tbl[, tblH1, tblG1, tblH2, tblG2] ) | ( function ) |

Returns: a list of constriction descriptions, or a construction description, or `fail`

.

Called with one argument `tbl`, an ordinary character table of the group \(G\), say, `ConstructIndexTwoSubdirectProductInfo`

analyzes the possibilities to construct `tbl` from character tables of subgroups \(H_1\), \(H_2\) and factor groups \(G_1\), \(G_2\), using `CharacterTableOfIndexTwoSubdirectProduct`

(5.5-1). The return value is a list of records with the following components.

`kernels`

the list of class positions of \(H_1\), \(H_2\) in

`tbl`,`kernelsizes`

the list of orders of \(H_1\), \(H_2\),

`factors`

the list of

`Identifier`

(Reference: Identifier for character tables) values of the**GAP**library tables of the factors \(G_2\), \(G_1\) of \(G\) by \(H_1\), \(H_2\); if no such table is available then the entry is`fail`

, and`subgroups`

the list of

`Identifier`

(Reference: Identifier for character tables) values of the**GAP**library tables of the subgroups \(H_2\), \(H_1\) of \(G\); if no such tables are available then the entries are`fail`

.

If the returned list is empty then either `tbl` does not have the desired structure as a subdirect product, *or* `tbl` is in fact a nontrivial direct product.

Called with five arguments, the ordinary character tables of \(G\), \(H_1\), \(G_1\), \(H_2\), \(G_2\), `ConstructIndexTwoSubdirectProductInfo`

returns a list that can be used as the `ConstructionInfoCharacterTable`

(3.7-4) value for the character table of \(G\) from the other four character tables using `CharacterTableOfIndexTwoSubdirectProduct`

(5.5-1); if this is not possible then `fail`

is returned.

As for the construction of Brauer character tables from known tables, the functions `PossibleCharacterTablesOfTypeMGA`

(5.1-1), `CharacterTableOfTypeGS3`

(5.2-1), and `PossibleCharacterTablesOfTypeGV4`

(5.3-1) work for both ordinary and Brauer tables. The following function is designed specially for Brauer tables.

`‣ IBrOfExtensionBySingularAutomorphism` ( modtbl, act ) | ( function ) |

Let `modtbl` be a \(p\)-modular Brauer table of the group \(G\), say, and suppose that the group \(H\), say, is an upward extension of \(G\) by an automorphism of order \(p\).

The second argument `act` describes the action of this automorphism. It can be either a permutation of the columns of `modtbl`, or a list of the \(H\)-orbits on the columns of `modtbl`, or the ordinary character table of \(H\) such that the class fusion from the ordinary table of `modtbl` into this table is stored. In all these cases, `IBrOfExtensionBySingularAutomorphism`

returns the values lists of the irreducible \(p\)-modular Brauer characters of \(H\).

Note that the table head of the \(p\)-modular Brauer table of \(H\), in general without the `Irr`

(Reference: Irr) attribute, can be obtained by applying `CharacterTableRegular`

(Reference: CharacterTableRegular) to the ordinary character table of \(H\), but `IBrOfExtensionBySingularAutomorphism`

can be used also if the ordinary character table of \(H\) is not known, and just the \(p\)-modular character table of \(G\) and the action of \(H\) on the classes of \(G\) are given.

`‣ CharacterTableOfCommonCentralExtension` ( tblG, tblmG, tblnG, id ) | ( function ) |

Let `tblG` be the ordinary character table of a group \(G\), say, and let `tblmG` and `tblnG` be the ordinary character tables of central extensions \(m.G\) and \(n.G\) of \(G\) by cyclic groups of prime orders \(m\) and \(n\), respectively, with \(m \not= n\). We assume that the factor fusions from `tblmG` and `tblnG` to `tblG` are stored on the tables. `CharacterTableOfCommonCentralExtension`

returns a record with the following components.

`tblmnG`

the character table \(t\), say, of the corresponding central extension of \(G\) by a cyclic group of order \(m n\) that factors through \(m.G\) and \(n.G\); the

`Identifier`

(Reference: Identifier for character tables) value of this table is`id`,`IsComplete`

`true`

if the`Irr`

(Reference: Irr) value is stored in \(t\), and`false`

otherwise,`irreducibles`

the list of irreducibles of \(t\) that are known; it contains the inflated characters of the factor groups \(m.G\) and \(n.G\), plus those irreducibles that were found in tensor products of characters of these groups.

Note that the conjugacy classes and the power maps of \(t\) are uniquely determined by the input data. Concerning the irreducible characters, we try to extract them from the tensor products of characters of the given factor groups by reducing with known irreducibles and applying the LLL algorithm (see `ReducedClassFunctions`

(Reference: ReducedClassFunctions) and `LLL`

(Reference: LLL)).

The following functions are used in the **GAP** Character Table Library, for encoding table constructions via the mechanism that is based on the attribute `ConstructionInfoCharacterTable`

(3.7-4). All construction functions take as their first argument a record that describes the table to be constructed, and the function adds only those components that are not yet contained in this record.

`‣ ConstructMGA` ( tbl, subname, factname, plan, perm ) | ( function ) |

`ConstructMGA`

constructs the irreducible characters of the ordinary character table `tbl` of a group \(m.G.a\) where the automorphism \(a\) (a group of prime order) of \(m.G\) acts nontrivially on the central subgroup \(m\) of \(m.G\). `subname` is the name of the subgroup \(m.G\) which is a (not necessarily cyclic) central extension of the (not necessarily simple) group \(G\), `factname` is the name of the factor group \(G.a\). Then the faithful characters of `tbl` are induced from \(m.G\).

`plan` is a list, each entry being a list containing positions of characters of \(m.G\) that form an orbit under the action of \(a\) (the induction of characters is encoded this way).

`perm` is the permutation that must be applied to the list of characters that is obtained on appending the faithful characters to the inflated characters of the factor group. A nonidentity permutation occurs for example for groups of structure \(12.G.2\) that are encoded via the subgroup \(12.G\) and the factor group \(6.G.2\), where the faithful characters of \(4.G.2\) shall precede those of \(6.G.2\), as in the **Atlas**.

Examples where `ConstructMGA`

is used to encode library tables are the tables of \(3.F_{{3+}}.2\) (subgroup \(3.F_{{3+}}\), factor group \(F_{{3+}}.2\)) and \(12_1.U_4(3).2_2\) (subgroup \(12_1.U_4(3)\), factor group \(6_1.U_4(3).2_2\)).

`‣ ConstructMGAInfo` ( tblmGa, tblmG, tblGa ) | ( function ) |

Let `tblmGa` be the ordinary character table of a group of structure \(m.G.a\) where the factor group of prime order \(a\) acts nontrivially on the normal subgroup of order \(m\) that is central in \(m.G\), `tblmG` be the character table of \(m.G\), and `tblGa` be the character table of the factor group \(G.a\).

`ConstructMGAInfo`

returns the list that is to be stored in the library version of `tblmGa`: the first entry is the string `"ConstructMGA"`

, the remaining four entries are the last four arguments for the call to `ConstructMGA`

(5.8-1).

`‣ ConstructGS3` ( tbls3, tbl2, tbl3, ind2, ind3, ext, perm ) | ( function ) |

`‣ ConstructGS3Info` ( tbl2, tbl3, tbls3 ) | ( function ) |

`ConstructGS3`

constructs the irreducibles of an ordinary character table `tbls3` of type \(G.S_3\) from the tables with names `tbl2` and `tbl3`, which correspond to the groups \(G.2\) and \(G.3\), respectively. `ind2` is a list of numbers referring to irreducibles of `tbl2`. `ind3` is a list of pairs, each referring to irreducibles of `tbl3`. `ext` is a list of pairs, each referring to one irreducible character of `tbl2` and one of `tbl3`. `perm` is a permutation that must be applied to the irreducibles after the construction.

`ConstructGS3Info`

returns a record with the components `ind2`

, `ind3`

, `ext`

, `perm`

, and `list`

, as are needed for `ConstructGS3`

.

`‣ ConstructV4G` ( tbl, facttbl, aut ) | ( function ) |

Let `tbl` be the character table of a group of type \(2^2.G\) where an outer automorphism of order \(3\) permutes the three involutions in the central \(2^2\). Let `aut` be the permutation of classes of `tbl` induced by that automorphism, and `facttbl` be the name of the character table of the factor group \(2.G\). Then `ConstructV4G`

constructs the irreducible characters of `tbl` from that information.

`‣ ConstructProj` ( tbl, irrinfo ) | ( function ) |

`‣ ConstructProjInfo` ( tbl, kernel ) | ( function ) |

`ConstructProj`

constructs the irreducible characters of the record encoding the ordinary character table `tbl` from projective characters of tables of factor groups, which are stored in the `ProjectivesInfo`

(3.7-2) value of the smallest factor; the information about the name of this factor and the projectives to take is stored in `irrinfo`.

`ConstructProjInfo`

takes an ordinary character table `tbl` and a list `kernel` of class positions of a cyclic kernel of order dividing \(12\), and returns a record with the components

`tbl`

a character table that is permutation isomorphic with

`tbl`, and sorted such that classes that differ only by multiplication with elements in the classes of`kernel`are consecutive,`projectives`

a record being the entry for the

`projectives`

list of the table of the factor of`tbl`by`kernel`, describing this part of the irreducibles of`tbl`, and`info`

the value of

`irrinfo`that is needed for constructing the irreducibles of the`tbl`

component of the result (*not*the irreducibles of the argument`tbl`!) via`ConstructProj`

.

`‣ ConstructDirectProduct` ( tbl, factors[, permclasses, permchars] ) | ( function ) |

The direct product of the library character tables described by the list `factors` of table names is constructed using `CharacterTableDirectProduct`

(Reference: CharacterTableDirectProduct), and all its components that are not yet stored on `tbl` are added to `tbl`.

The `ComputedClassFusions`

(Reference: ComputedClassFusions) value of `tbl` is enlarged by the factor fusions from the direct product to the factors.

If the optional arguments `permclasses`, `permchars` are given then the classes and characters of the result are sorted accordingly.

`factors` must have length at least two; use `ConstructPermuted`

(5.8-11) in the case of only one factor.

`‣ ConstructCentralProduct` ( tbl, factors, Dclasses[, permclasses, permchars] ) | ( function ) |

The library table `tbl` is completed with help of the table obtained by taking the direct product of the tables with names in the list `factors`, and then factoring out the normal subgroup that is given by the list `Dclasses` of class positions.

If the optional arguments `permclasses`, `permchars` are given then the classes and characters of the result are sorted accordingly.

`‣ ConstructSubdirect` ( tbl, factors, choice ) | ( function ) |

The library table `tbl` is completed with help of the table obtained by taking the direct product of the tables with names in the list `factors`, and then taking the table consisting of the classes in the list `choice`.

Note that in general, the restriction to the classes of a normal subgroup is not sufficient for describing the irreducible characters of this normal subgroup.

`‣ ConstructWreathSymmetric` ( tbl, subname, n[, permclasses, permchars] ) | ( function ) |

The wreath product of the library character table with identifier value `subname` with the symmetric group on `n` points is constructed using `CharacterTableWreathSymmetric`

(Reference: CharacterTableWreathSymmetric), and all its components that are not yet stored on `tbl` are added to `tbl`.

If the optional arguments `permclasses`, `permchars` are given then the classes and characters of the result are sorted accordingly.

`‣ ConstructIsoclinic` ( tbl, factors[, nsg[, centre]][, permclasses, permchars] ) | ( function ) |

constructs first the direct product of library tables as given by the list `factors` of admissible character table names, and then constructs the isoclinic table of the result.

If the argument `nsg` is present and a record or a list then `CharacterTableIsoclinic`

(Reference: CharacterTableIsoclinic) gets called, and `nsg` (as well as `centre` if present) is passed to this function.

In both cases, if the optional arguments `permclasses`, `permchars` are given then the classes and characters of the result are sorted accordingly.

`‣ ConstructPermuted` ( tbl, libnam[, permclasses, permchars] ) | ( function ) |

The library table `tbl` is computed from the library table with the name `libnam`, by permuting the classes and the characters by the permutations `permclasses` and `permchars`, respectively.

So `tbl` and the library table with the name `libnam` are permutation equivalent. With the more general function `ConstructAdjusted`

(5.8-12), one can derive character tables that are not necessarily permutation equivalent, by additionally replacing some defining data.

The two permutations are optional. If they are missing then the lists of irreducible characters and the power maps of the two character tables coincide. However, different class fusions may be stored on the two tables. This is used for example in situations where a group has several classes of isomorphic maximal subgroups whose class fusions are different; different character tables (with different identifiers) are stored for the different classes, each with appropriate class fusions, and all these tables except the one for the first class of subgroups can be derived from this table via `ConstructPermuted`

.

`‣ ConstructAdjusted` ( tbl, libnam, pairs[, permclasses, permchars] ) | ( function ) |

The defining attribute values of the library table `tbl` are given by the attribute values described by the list `pairs` and –for those attributes which do not appear in `pairs`– by the attribute values of the library table with the name `libnam`, whose classes and characters have been permuted by the optional permutations `permclasses` and `permchars`, respectively.

This construction can be used to derive a character table from another library table (the one with the name `libnam`) that is *not* permutation equivalent to this table. For example, it may happen that the character tables of a split and a nonsplit extension differ only by some power maps and element orders. In this case, one can encode one of the tables via `ConstructAdjusted`

, by prescribing just the power maps in the list `pairs`.

If no replacement of components is needed then one should better use `ConstructPermuted`

(5.8-11), because the system can then exploit the fact that the two tables are permutation equivalent.

`‣ ConstructFactor` ( tbl, libnam, kernel ) | ( function ) |

The library table `tbl` is completed with help of the library table with name `libnam`, by factoring out the classes in the list `kernel`.

generated by GAPDoc2HTML