Goto Chapter: Top 1 2 3 4 5 6 7 Bib Ind
[Top of Book] [Contents] [Previous Chapter] [Next Chapter]

[MathJax off]

5 Functions for Character Table Constructions
5.1 Character Tables of Groups of Structure \(M.G.A\)
5.1-1 PossibleCharacterTablesOfTypeMGA
5.1-2 BrauerTableOfTypeMGA
5.1-3 PossibleActionsForTypeMGA
5.2 Character Tables of Groups of Structure \(G.S_3\)
5.2-1 CharacterTableOfTypeGS3
5.2-2 PossibleActionsForTypeGS3
5.3 Character Tables of Groups of Structure \(G.2^2\)
5.3-1 PossibleCharacterTablesOfTypeGV4
5.3-2 PossibleActionsForTypeGV4
5.4 Character Tables of Groups of Structure \(2^2.G\)
5.4-1 PossibleCharacterTablesOfTypeV4G
5.4-2 BrauerTableOfTypeV4G
5.5 Character Tables of Subdirect Products of Index Two
5.5-1 CharacterTableOfIndexTwoSubdirectProduct
5.5-2 ConstructIndexTwoSubdirectProduct
5.5-3 ConstructIndexTwoSubdirectProductInfo
5.6 Brauer Tables of Extensions by \(p\)-regular Automorphisms
5.6-1 IBrOfExtensionBySingularAutomorphism
5.7 Character Tables of Coprime Central Extensions
5.7-1 CharacterTableOfCommonCentralExtension
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 Functions for Character Table Constructions

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

#### 5.1 Character Tables of Groups of Structure \(M.G.A\)

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

##### 5.1-1 PossibleCharacterTablesOfTypeMGA

`‣ 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\).

##### 5.1-2 BrauerTableOfTypeMGA

`‣ 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\).

##### 5.1-3 PossibleActionsForTypeMGA

`‣ 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)).

#### 5.2 Character Tables of Groups of Structure \(G.S_3\)

##### 5.2-1 CharacterTableOfTypeGS3

`‣ 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.

##### 5.2-2 PossibleActionsForTypeGS3

`‣ 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)).

#### 5.3 Character Tables of Groups of Structure \(G.2^2\)

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\).

##### 5.3-1 PossibleCharacterTablesOfTypeGV4

`‣ 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.

##### 5.3-2 PossibleActionsForTypeGV4

`‣ 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)).

#### 5.4 Character Tables of Groups of Structure \(2^2.G\)

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.

##### 5.4-1 PossibleCharacterTablesOfTypeV4G

`‣ 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.

##### 5.4-2 BrauerTableOfTypeV4G

`‣ 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\).

#### 5.5 Character Tables of Subdirect Products of Index Two

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.

##### 5.5-1 CharacterTableOfIndexTwoSubdirectProduct

`‣ 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.

##### 5.5-2 ConstructIndexTwoSubdirectProduct

`‣ 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.

##### 5.5-3 ConstructIndexTwoSubdirectProductInfo

`‣ 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.

#### 5.6 Brauer Tables of Extensions by \(p\)-regular Automorphisms

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.

##### 5.6-1 IBrOfExtensionBySingularAutomorphism

`‣ 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.

#### 5.7 Character Tables of Coprime Central Extensions

##### 5.7-1 CharacterTableOfCommonCentralExtension

`‣ 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)).

#### 5.8 Construction Functions used in the Character Table Library

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.

##### 5.8-1 ConstructMGA

`‣ 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\)).

##### 5.8-2 ConstructMGAInfo

`‣ 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).

##### 5.8-3 ConstructGS3

`‣ 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`.

##### 5.8-4 ConstructV4G

`‣ 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.

##### 5.8-5 ConstructProj

`‣ 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`.

##### 5.8-6 ConstructDirectProduct

`‣ 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.

##### 5.8-7 ConstructCentralProduct

`‣ 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.

##### 5.8-8 ConstructSubdirect

`‣ 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.

##### 5.8-9 ConstructWreathSymmetric

`‣ 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.

##### 5.8-10 ConstructIsoclinic

`‣ 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.

##### 5.8-11 ConstructPermuted

`‣ 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`.

##### 5.8-12 ConstructAdjusted

`‣ 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.

##### 5.8-13 ConstructFactor

`‣ 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.

[Top of Book] [Contents] [Previous Chapter] [Next Chapter]
Goto Chapter: Top 1 2 3 4 5 6 7 Bib Ind

generated by GAPDoc2HTML