3 The User Interface to the **GAP** Character Table Library

When you access a character table from the **GAP** Character Table Library, this table is specified by an admissible name.

Admissible names for the *ordinary character table* \(tbl\) of the group \(G\) are

an

**Atlas**like name if \(tbl\) is an**Atlas**table (see Section 4.3), for example`"M22"`

for the table of the Mathieu group \(M_{22}\),`"L2(13).2"`

for \(L_2(13):2\), and`"12_1.U4(3).2_1"`

for \(12_1.U_4(3).2_1\).(The difference to the name printed in the

**Atlas**is that subscripts and superscripts are omitted except if they are used to qualify integer values, and double dots are replaced by a single dot.)the names that were admissible for tables of \(G\) in the

**CAS**system if the**CAS**table library contained a table of \(G\), for example`sl42`

for the table of the alternating group \(A_8\).(But note that the ordering of rows and columns of the

**GAP**table may be different from that in**CAS**, see Section 4.4.)some "relative" names, as follows.

If \(G\) is the \(n\)-th maximal subgroup (in decreasing group order) of a group whose library table \(subtbl\) is available in

**GAP**and stores the`Maxes`

(3.7-1) value, and if`name`

is an admissible name for \(subtbl\) then`name`

M\(n\) is admissible for \(tbl\). For example, the name`"J3M2"`

can be used to access the second maximal subgroup of the sporadic simple Janko group \(J_3\) which has the admissible name`"J3"`

.If \(G\) is a nontrivial Sylow \(p\) normalizer in a sporadic simple group with admissible name

`name`

–where nontrivial means that \(G\) is not isomorphic to a subgroup of \(p:(p-1)\)– then`name`

N\(p\) is an admissible name of \(tbl\). For example, the name`"J4N11"`

can be used to access the table of the Sylow \(11\) normalizer in the sporadic simple Janko group \(J_4\).In a few cases, the table of the Sylow \(p\)-subgroup of \(G\) is accessible via the name

`name`

Syl\(p\) where`name`

is an admissible name of the table of \(G\). For example,`"A11Syl2"`

is an admissible name for the table of the Sylow \(2\)-subgroup of the alternating group \(A_{11}\).In a few cases, the table of an element centralizer in \(G\) is accessible via the name

`name`

C\(cl\) where`name`

is an admissible name of the table of \(G\). For example,`"M11C2"`

is an admissible name for the table of an involution centralizer in the Mathieu group \(M_{11}\).

The recommended way to access a *Brauer table* is via applying the `mod`

operator to the ordinary table and the desired characteristic (see `BrauerTable`

(Reference: BrauerTable) and Section Reference: Operators for Character Tables), so it is not necessary to define admissible names of Brauer tables.

A *generic character table* (see Section 4.2) is accessible only by the name given by its `Identifier`

(Reference: Identifier for character tables) value.

`‣ CharacterTable` ( tblname[, para1[, para2]] ) | ( method ) |

If the only argument is a string `tblname` and if this is an admissible name (see 3.1-1) of a library character table then `CharacterTable`

returns this library table, otherwise `fail`

.

If `CharacterTable`

is called with more than one argument then the first must be a string `tblname` specifying a series of groups which is implemented via a generic character table, for example `"Symmetric"`

for symmetric groups; the remaining arguments specialize the desired member of the series (see Section 4.2 for a list of available generic tables). If no generic table with name `tblname` is available or if the parameters are not admissible then `CharacterTable`

returns `fail`

.

A call of `CharacterTable`

may cause that some library files are read and that some table objects are constructed from the data stored in these files, so fetching a library table may take more time than one expects.

Case is not significant for `tblname`. For example, both `"suzm3"`

and `"SuzM3"`

can be entered in order to access the character table of the third class of maximal subgroups of the sporadic simple Suzuki group.

gap> s5:= CharacterTable( "A5.2" ); CharacterTable( "A5.2" ) gap> sym5:= CharacterTable( "Symmetric", 5 ); CharacterTable( "Sym(5)" ) gap> TransformingPermutationsCharacterTables( s5, sym5 ); rec( columns := (2,3,4,7,5), group := Group(()), rows := (1,7,3,4,6,5,2) )

The above two tables are tables of the symmetric group on five letters; the first is in **Atlas** format (see Section 4.3), the second is constructed from the generic table for symmetric groups (see 4.2).

gap> CharacterTable( "J5" ); fail gap> CharacterTable( "A5" ) mod 2; BrauerTable( "A5", 2 )

`‣ BrauerTable` ( tblname, p ) | ( operation ) |

Called with a string `tblname` and a prime integer `p`, `BrauerTable`

returns the `p`-modular character table of the ordinary character table with admissible name `tblname`, if such an ordinary character table exists and if **GAP** can compute its `p`-modular table. Otherwise `fail`

is returned.

The default method delegates to `BrauerTable`

(Reference: BrauerTable for a character table, and a prime integer) with arguments the `CharacterTable`

(3.1-2) value of `tblname` and `p`.

gap> BrauerTable( "A5", 2 ); BrauerTable( "A5", 2 ) gap> BrauerTable( "J5", 2 ); # no ordinary table with name J5 fail gap> BrauerTable( "M", 2 ); # Brauer table not known fail

`‣ AllCharacterTableNames` ( [func, val, ...[, OfThose, func]]: OrderedBy := func ) | ( function ) |

Similar to group libraries (see Chapter Reference: Group Libraries), the **GAP** Character Table Library can be used to search for ordinary character tables with prescribed properties.

A specific library table can be selected by an admissible name, see 3.1-1.

The *selection function* (see Reference: Selection Functions) for character tables from the **GAP** Character Table Library that have certain abstract properties is `AllCharacterTableNames`

. Contrary to the situation in the case of group libraries, the selection function returns a list not of library character tables but of their names; using `CharacterTable`

(3.1-2) one can then access the tables themselves.

`AllCharacterTableNames`

takes an arbitrary even number of arguments. The argument at each odd position must be a function, and the argument at the subsequent even position must be either a value that this function must return when called for the character table in question, in order to have the name of the table included in the selection, or a list of such values, or a function that returns `true`

for such a value, and `false`

otherwise. For example,

gap> names:= AllCharacterTableNames();;

returns a list containing one admissible name of each ordinary character table in the **GAP** library,

gap> simpnames:= AllCharacterTableNames( IsSimple, true, > IsAbelian, false );;

returns a list containing an admissible name of each ordinary character table in the **GAP** library whose groups are nonabelian and simple, and

gap> AllCharacterTableNames( IsSimple, true, IsAbelian, false, > Size, [ 1 .. 100 ] ); [ "A5", "A6M2", "Alt(5)" ]

returns a list containing an admissible name of each ordinary character table in the **GAP** library whose groups are nonabelian and simple and have order at most \(100\), respectively. (Note that `"A5"`

, `"A6M2"`

, and `"Alt(5)"`

are identifiers of permutation equivalent character tables. It would be possible to exclude duplicates, see Section 3.6).

Similarly,

gap> AllCharacterTableNames( Size, IsPrimeInt ); [ "2.Alt(2)", "Alt(3)", "C2", "C3", "Sym(2)" ]

returns the list of all identifiers of library tables whose `Size`

(Reference: Size) value is a prime integer, and

gap> AllCharacterTableNames( Identifier, > x -> PositionSublist( x, "L8" ) <> fail ); [ "L8(2)", "P1L82", "P2L82" ]

returns the identifiers that contain the string `"L8"`

as a substring.

For the sake of efficiency, the attributes whose names are listed in `CTblLib.SupportedAttributes`

are handled in a special way, **GAP** need not read all files of the table library in these cases in order to find the desired names.

gap> CTblLib.SupportedAttributes; [ "AbelianInvariants", "Identifier", "IdentifiersOfDuplicateTables", "InfoText", "IsAbelian", "IsAlmostSimple", "IsDuplicateTable", "IsNontrivialDirectProduct", "IsPerfect", "IsQuasisimple", "IsSimple", "IsSporadicSimple", "KnowsDeligneLusztigNames", "KnowsSomeGroupInfo", "Maxes", "NamesOfFusionSources", "NrConjugacyClasses", "Size" ]

If the **Browse** package (see [BL23]) is not loaded then `CTblLib.SupportedAttributes`

contains only `"Identifier"`

, and `AllCharacterTableNames`

will be very slow when one selects character tables according to other attributes from the list shown above.

The global option `OrderedBy`

can be used to prescribe the ordering of the result. The value of this option, if given, must be a function that takes a character table as its unique argument; the result list is then sorted according to the results of this function (w. r. t. the comparison by **GAP**'s `\<`

operation).

For example, we may be interested in the tables of small sporadic simple groups, ordered alphabetically or by size (`Size`

(Reference: Size for a character table)) or by the number of conjugacy classes (`NrConjugacyClasses`

(Reference: NrConjugacyClasses for a character table)).

gap> AllCharacterTableNames( IsSporadicSimple, true, > Size, [ 1 .. 10^6 ], > IsDuplicateTable, false ); [ "J1", "J2", "M11", "M12", "M22" ] gap> AllCharacterTableNames( IsSporadicSimple, true, > Size, [ 1 .. 10^6 ], > IsDuplicateTable, false : OrderedBy:= Size ); [ "M11", "M12", "J1", "M22", "J2" ] gap> AllCharacterTableNames( IsSporadicSimple, true, > Size, [ 1 .. 10^6 ], > IsDuplicateTable, false : OrderedBy:= NrConjugacyClasses ); [ "M11", "M22", "J1", "M12", "J2" ]

(Note that the alphabtical ordering could also be achieved by entering `OrderedBy:= Identifier`

.)

If the dummy function `OfThose`

is an argument at an odd position then the following argument `func` must be a function that takes a character table and returns a name of a character table or a list of names; this is interpreted as replacement of the names computed up to this position by the union of names returned by `func`. For example, `func` may be `Maxes`

(3.7-1) or `NamesOfFusionSources`

(Reference: NamesOfFusionSources)).

gap> maxesnames:= AllCharacterTableNames( IsSporadicSimple, true, > HasMaxes, true, > OfThose, Maxes );;

returns the union of names of ordinary tables of those maximal subgroups of sporadic simple groups that are contained in the table library in the sense that the attribute `Maxes`

(3.7-1) is set.

For the sake of efficiency, `OfThose`

followed by one of the arguments `AutomorphismGroup`

(Reference: AutomorphismGroup), `SchurCover`

(Reference: SchurCover), `CompleteGroup`

is handled in a special way.

`‣ OneCharacterTableName` ( [func, val, ...[, OfThose, func]]: OrderedBy := func ) | ( function ) |

The example function for character tables from the **GAP** Character Table Library that have certain abstract properties is `OneCharacterTableName`

. It is analogous to the selection function `AllCharacterTableNames`

(3.1-4), the difference is that it returns one `Identifier`

(Reference: Identifier for character tables) value of a character table with the properties in question instead of the list of all such values. If no table with the required properties is contained in the **GAP** Character Table Library then `fail`

is returned.

gap> OneCharacterTableName( IsSimple, true, Size, 60 ); "A5" gap> OneCharacterTableName( IsSimple, true, Size, 20 ); fail

The global option `OrderedBy`

can be used to search for a "smallest" example, according to the value of the option. If this function is one of the attributes whose names are listed in `CTblLib.SupportedAttributes`

then the tables are processed according to increasing values of the option, which may speed up the search.

`‣ NameOfEquivalentLibraryCharacterTable` ( ordtbl ) | ( function ) |

`‣ NamesOfEquivalentLibraryCharacterTables` ( ordtbl ) | ( function ) |

Let `ordtbl` be an ordinary character table. `NameOfEquivalentLibraryCharacterTable`

returns the `Identifier`

(Reference: Identifier for character tables) value of a character table in the **GAP** Character Table Library that is permutation equivalent to `ordtbl` (see `TransformingPermutationsCharacterTables`

(Reference: TransformingPermutationsCharacterTables)) if such a character table exists, and `fail`

otherwise. `NamesOfEquivalentLibraryCharacterTables`

returns the list of all `Identifier`

(Reference: Identifier for character tables) values of character tables in the **GAP** Character Table Library that are permutation equivalent to `ordtbl`; thus an empty list is returned in this case if no equivalent library table exists.

gap> tbl:= CharacterTable( "Alternating", 5 );; gap> NameOfEquivalentLibraryCharacterTable( tbl ); "A5" gap> NamesOfEquivalentLibraryCharacterTables( tbl ); [ "A5", "A6M2", "Alt(5)" ] gap> tbl:= CharacterTable( "Cyclic", 17 );; gap> NameOfEquivalentLibraryCharacterTable( tbl ); fail gap> NamesOfEquivalentLibraryCharacterTables( tbl ); [ ]

The **GAP** Character Table Library contains ordinary character tables of all groups for which the **TomLib** package [MNP19] contains the table of marks. This section describes the mapping between these character tables and their tables of marks.

If the **TomLib** package is not loaded then `FusionToTom`

(3.2-4) is the only available function from this section, but of course it is of little interest in this situation.

`‣ TableOfMarks` ( tbl ) | ( method ) |

Let `tbl` be an ordinary character table from the **GAP** Character Table Library, for the group \(G\), say. If the **TomLib** package is loaded and contains the table of marks of \(G\) then there is a method based on `TableOfMarks`

(Reference: TableOfMarks for a string) that returns this table of marks. If there is no such table of marks but `tbl` knows its underlying group then this method delegates to the group. Otherwise `fail`

is returned.

gap> TableOfMarks( CharacterTable( "A5" ) ); TableOfMarks( "A5" ) gap> TableOfMarks( CharacterTable( "M" ) ); fail

`‣ CharacterTable` ( tom ) | ( method ) |

For a table of marks `tom`, this method for `CharacterTable`

(Reference: CharacterTable for a group) returns the character table corresponding to `tom`.

If `tom` comes from the **TomLib** package, the character table comes from the **GAP** Character Table Library. Otherwise, if `tom` stores an `UnderlyingGroup`

(Reference: UnderlyingGroup for tables of marks) value then the task is delegated to a `CharacterTable`

(Reference: CharacterTable for a group) method for this group, and if no underlying group is available then `fail`

is returned.

gap> CharacterTable( TableOfMarks( "A5" ) ); CharacterTable( "A5" )

`‣ FusionCharTableTom` ( tbl, tom ) | ( method ) |

Let `tbl` be an ordinary character table from the **GAP** Character Table Library with the attribute `FusionToTom`

(3.2-4), and let `tom` be the table of marks from the **GAP** package **TomLib** that corresponds to `tbl`. In this case, a method for `FusionCharTableTom`

(Reference: FusionCharTableTom) is available that returns the fusion from `tbl` to `tom` that is given by the `FusionToTom`

(3.2-4) value of `tbl`.

gap> tbl:= CharacterTable( "A5" ); CharacterTable( "A5" ) gap> tom:= TableOfMarks( "A5" ); TableOfMarks( "A5" ) gap> FusionCharTableTom( tbl, tom ); [ 1, 2, 3, 5, 5 ]

`‣ FusionToTom` ( tbl ) | ( attribute ) |

If this attribute is set for an ordinary character table `tbl` then the **GAP** Library of Tables of Marks contains the table of marks of the group of `tbl`, and the attribute value is a record with the following components.

`name`

the

`Identifier`

(Reference: Identifier for tables of marks) component of the table of marks of`tbl`,`map`

the fusion map,

`text`

(optional)a string describing the status of the fusion, and

`perm`

(optional)a permutation that establishes the bijection between the classes of maximal subgroups in the table of marks (see

`MaximalSubgroupsTom`

(Reference: MaximalSubgroupsTom)) and the`Maxes`

(3.7-1) list of`tbl`. Applying the permutation to the sublist of permutation characters (see`PermCharsTom`

(Reference: PermCharsTom via fusion map)) at the positions of the maximal subgroups of the table of marks yields the list of primitive permutation characters computed from the character tables described by the`Maxes`

(3.7-1) list. Usually, there is no`perm`

component, which means that the two lists of primitive permutation characters are equal. See Section 2.3-5 for an example.

gap> FusionToTom( CharacterTable( "2.A6" ) ); rec( map := [ 1, 2, 5, 4, 8, 3, 7, 11, 11, 6, 13, 6, 13 ], name := "2.A6", perm := (4,5), text := "fusion map is unique up to table autom." )

`‣ NameOfLibraryCharacterTable` ( tomname ) | ( function ) |

This function returns the `Identifier`

(Reference: Identifier for character tables) value of the character table corresponding to the table of marks with `Identifier`

(Reference: Identifier for tables of marks) value `tomname`. If no such character table exists in the **GAP** Character Table Library or if the **TomLib** package is not loaded then `fail`

is returned.

gap> NameOfLibraryCharacterTable( "A5" ); "A5" gap> NameOfLibraryCharacterTable( "S5" ); "A5.2"

Sometimes it is useful to extend a character-theoretic computation with computations involving a group that has the character table in question. For many character tables in the **GAP** Character Table Library, corresponding groups can be found in the various group libraries that are distributed with **GAP**. This section describes how one can access the library groups that belong to a given character table.

`‣ GroupInfoForCharacterTable` ( tbl ) | ( attribute ) |

Let `tbl` be an ordinary character table from the **GAP** Character Table Library. `GroupInfoForCharacterTable`

returns a sorted list of pairs such that calling `GroupForGroupInfo`

(3.3-4) with any of these pairs yields a group whose ordinary character table is `tbl`, up to permutations of rows and columns.

Note that this group is in general *not* determined up to isomorphism, since nonisomorphic groups may have the same character table (including power maps).

Contrary to the attribute `UnderlyingGroup`

(Reference: UnderlyingGroup for tables of marks), the entries of the `GroupInfoForCharacterTable`

list for `tbl` are not related to the ordering of the conjugacy classes in `tbl`.

Sources for this attribute are the **GAP** databases of groups described in Chapter Reference: Group Libraries, and the packages **AtlasRep** and **TomLib**, see also `GroupForTom`

(3.3-5) and `AtlasStabilizer`

(3.3-6). If these packages are not loaded then part of the information may be missing. If the **Browse** package (see [BL23]) is not loaded then `GroupInfoForCharacterTable`

returns always an empty list.

gap> GroupInfoForCharacterTable( CharacterTable( "A5" ) ); [ [ "AlternatingGroup", [ 5 ] ], [ "AtlasGroup", [ "A5" ] ], [ "AtlasStabilizer", [ "A6", "A6G1-p6aB0" ] ], [ "AtlasStabilizer", [ "A6", "A6G1-p6bB0" ] ], [ "AtlasStabilizer", [ "L2(11)", "L211G1-p11aB0" ] ], [ "AtlasStabilizer", [ "L2(11)", "L211G1-p11bB0" ] ], [ "AtlasStabilizer", [ "L2(19)", "L219G1-p57aB0" ] ], [ "AtlasStabilizer", [ "L2(19)", "L219G1-p57bB0" ] ], [ "AtlasSubgroup", [ "A5.2", 1 ] ], [ "AtlasSubgroup", [ "A6", 1 ] ] , [ "AtlasSubgroup", [ "A6", 2 ] ], [ "AtlasSubgroup", [ "J2", 9 ] ], [ "AtlasSubgroup", [ "L2(109)", 4 ] ], [ "AtlasSubgroup", [ "L2(109)", 5 ] ], [ "AtlasSubgroup", [ "L2(11)", 1 ] ], [ "AtlasSubgroup", [ "L2(11)", 2 ] ], [ "AtlasSubgroup", [ "S6(3)", 11 ] ], [ "GroupForTom", [ "2^4:A5", 68 ] ], [ "GroupForTom", [ "2^4:A5`", 56 ] ], [ "GroupForTom", [ "A5" ] ], [ "GroupForTom", [ "A5xA5", 85 ] ], [ "GroupForTom", [ "A6", 21 ] ], [ "GroupForTom", [ "J2", 99 ] ], [ "GroupForTom", [ "L2(109)", 25 ] ], [ "GroupForTom", [ "L2(11)", 15 ] ], [ "GroupForTom", [ "L2(125)", 18 ] ], [ "GroupForTom", [ "L2(16)", 18 ] ], [ "GroupForTom", [ "L2(19)", 17 ] ], [ "GroupForTom", [ "L2(29)", 19 ] ], [ "GroupForTom", [ "L2(31)", 25 ] ], [ "GroupForTom", [ "S5", 18 ] ], [ "PSL", [ 2, 4 ] ], [ "PSL", [ 2, 5 ] ], [ "PerfectGroup", [ 60, 1 ] ], [ "PrimitiveGroup", [ 5, 4 ] ], [ "PrimitiveGroup", [ 6, 1 ] ], [ "PrimitiveGroup", [ 10, 1 ] ], [ "SmallGroup", [ 60, 5 ] ], [ "TransitiveGroup", [ 5, 4 ] ], [ "TransitiveGroup", [ 6, 12 ] ], [ "TransitiveGroup", [ 10, 7 ] ], [ "TransitiveGroup", [ 12, 33 ] ], [ "TransitiveGroup", [ 15, 5 ] ], [ "TransitiveGroup", [ 20, 15 ] ], [ "TransitiveGroup", [ 30, 9 ] ] ]

`‣ KnowsSomeGroupInfo` ( tbl ) | ( property ) |

For an ordinary character table `tbl`, this function returns `true`

if the list returned by `GroupInfoForCharacterTable`

(3.3-1) is nonempty, and `false`

otherwise.

gap> KnowsSomeGroupInfo( CharacterTable( "A5" ) ); true gap> KnowsSomeGroupInfo( CharacterTable( "M" ) ); false

`‣ CharacterTableForGroupInfo` ( info ) | ( attribute ) |

This function is a partial inverse of `GroupInfoForCharacterTable`

(3.3-1). If `info` has the form `[ `

\(funcname\)`, `

\(args\)` ]`

and occurs in the list returned by `GroupInfoForCharacterTable`

(3.3-1) when called with a character table \(t\), say, then `CharacterTableForGroupInfo`

returns a character table from the **GAP** Character Table that is equivalent to \(t\). Otherwise `fail`

is returned.

gap> CharacterTableForGroupInfo( [ "AlternatingGroup", [ 5 ] ] ); CharacterTable( "A5" )

`‣ GroupForGroupInfo` ( info ) | ( attribute ) |

If `info` has the form `[ `

\(funcname\)`, `

\(args\)` ]`

and occurs in the list returned by `GroupInfoForCharacterTable`

(3.3-1) when called with a character table \(tbl\), say, then `GroupForGroupInfo`

returns a group that is described by `info` and whose character table is equal to \(tbl\), up to permutations of rows and columns. Otherwise `fail`

is returned.

Typically, \(funcname\) is a string that is the name of a global **GAP** function \(fun\), say, and \(args\) is a list of arguments for this function such that `CallFuncList( `

\(fun\)`, `

\(args\)` )`

yields the desired group.

gap> GroupForGroupInfo( [ "AlternatingGroup", [ 5 ] ] ); Alt( [ 1 .. 5 ] ) gap> GroupForGroupInfo( [ "PrimitiveGroup", [ 5, 4 ] ] ); A(5)

`‣ GroupForTom` ( tomidentifier[, repnr] ) | ( attribute ) |

Let `tomidentifier` be a string that is an admissible name for a table of marks from the **GAP** Library of Tables of Marks (the **TomLib** package [MNP19]). Called with one argument, `GroupForTom`

returns the `UnderlyingGroup`

(Reference: UnderlyingGroup for tables of marks) value of this table of marks. If a positive integer `repnr` is given as the second argument then a representative of the `repnr`-th class of subgroups of this group is returned, see `RepresentativeTom`

(Reference: RepresentativeTom).

The string`"GroupForTom"`

may occur in the entries of the list returned by `GroupInfoForCharacterTable`

(3.3-1), and therefore may be called by `GroupForGroupInfo`

(3.3-4).

If the **TomLib** package is not loaded or if it does not contain a table of marks with identifier `tomidentifier` then `fail`

is returned.

gap> g:= GroupForTom( "A5" ); u:= GroupForTom( "A5", 2 ); Group([ (2,4)(3,5), (1,2,5) ]) Group([ (2,3)(4,5) ]) gap> IsSubset( g, u ); true gap> GroupForTom( "J4" ); fail

`‣ AtlasStabilizer` ( gapname, repname ) | ( function ) |

Let `gapname` be an admissible name of a group \(G\), say, in the sense of the **AtlasRep** package (see Section AtlasRep: Group Names Used in the AtlasRep Package), and `repname` be a string that occurs as the `repname`

component of a record returned by `AllAtlasGeneratingSetInfos`

(AtlasRep: AllAtlasGeneratingSetInfos) when this function is called with first argument `gapname` and further arguments `IsTransitive`

(Reference: IsTransitive) and `true`

. In this case, `repname` describes a transitive permutation representation of \(G\).

If the **AtlasRep** package is available and if the permutation group in question can be fetched then `AtlasStabilizer`

returns a point stabilizer. Otherwise `fail`

is returned.

The string`"AtlasStabilizer"`

may occur in the entries of the list returned by `GroupInfoForCharacterTable`

(3.3-1), and therefore may be called by `GroupForGroupInfo`

(3.3-4).

gap> AtlasStabilizer( "A5","A5G1-p5B0"); Group([ (1,2)(3,4), (2,3,4) ])

`‣ IsNontrivialDirectProduct` ( tbl ) | ( property ) |

For an ordinary character table `tbl` of the group \(G\), say, this function returns `true`

if \(G\) is the direct product of smaller groups, and `false`

otherwise.

gap> mx:= Maxes( CharacterTable( "J1" ) ); [ "L2(11)", "2^3.7.3", "2xA5", "19:6", "11:10", "D6xD10", "7:6" ] gap> List( mx, name -> IsNontrivialDirectProduct( > CharacterTable( name ) ) ); [ false, false, true, false, false, true, false ]

Unipotent characters are defined for finite groups of Lie type. For most of these groups whose character table is in the **GAP** Character Table Library, the unipotent characters are known and parametrised by labels. This labeling is due to the work of P. Deligne and G. Lusztig, thus the label of a unipotent character is called its Deligne-Lusztig name (see [CH05]).

`‣ UnipotentCharacter` ( tbl, label ) | ( function ) |

Let `tbl` be the ordinary character table of a finite group of Lie type in the **GAP** Character Table Library. `UnipotentCharacter`

returns the unipotent character with Deligne-Lusztig name `label`.

The object `label` must be either a list of integers which describes a partition (if the finite group of Lie type is of the type \(A_l\) or \({}^2\!A_l\)), a list of two lists of integers which describes a symbol (if the group is of classical type other than \(A_l\) and \({}^2\!A_l\)) or a string (if the group is of exceptional type).

A call of `UnipotentCharacter`

sets the attribute `DeligneLusztigNames`

(3.4-2) for `tbl`.

gap> tbl:= CharacterTable( "U4(2).2" );; gap> UnipotentCharacter( tbl, [ [ 0, 1 ], [ 2 ] ] ); Character( CharacterTable( "U4(2).2" ), [ 15, 7, 3, -3, 0, 3, -1, 1, 0, 1, -2, 1, 0, 0, -1, 5, 1, 3, -1, 2, -1, 1, -1, 0, 0 ] )

`‣ DeligneLusztigNames` ( obj ) | ( attribute ) |

For a character table `obj`, `DeligneLusztigNames`

returns a list of Deligne-Lusztig names of the the unipotent characters of `obj`. If the \(i\)-th entry is bound then it is the name of the \(i\)-th irreducible character of `obj`, and this character is irreducible. If an irreducible character is not unipotent the accordant position is unbound.

`DeligneLusztigNames`

called with a string `obj`, calls itself with the argument `CharacterTable( `

.`obj` )

When `DeligneLusztigNames`

is called with a record `obj` then this should have the components `isoc`

, `isot`

, `l`

, and `q`

, where `isoc`

and `isot`

are strings defining the isogeny class and isogeny type, and `l`

and `q`

are integers. These components define a finite group of Lie type uniquely. Moreover this way one can choose Deligne-Lusztig names for a prescribed type in those cases where a group has more than one interpretation as a finite group of Lie type, see the example below. (The first call of `DeligneLusztigNames`

sets the attribute value in the character table.)

gap> DeligneLusztigNames( "L2(7)" ); [ [ 2 ],,,, [ 1, 1 ] ] gap> tbl:= CharacterTable( "L2(7)" ); CharacterTable( "L3(2)" ) gap> HasDeligneLusztigNames( tbl ); true gap> DeligneLusztigNames( rec( isoc:= "A", isot:= "simple", > l:= 2, q:= 2 ) ); [ [ 3 ],,, [ 2, 1 ],, [ 1, 1, 1 ] ]

`‣ DeligneLusztigName` ( chi ) | ( function ) |

For a unipotent character `chi`, `DeligneLusztigName`

returns the Deligne-Lusztig name of `chi`. For that, `DeligneLusztigNames`

(3.4-2) is called with the argument `UnderlyingCharacterTable( `

.`chi` )

gap> tbl:= CharacterTable( "F4(2)" );; gap> DeligneLusztigName( Irr( tbl )[9] ); fail gap> HasDeligneLusztigNames( tbl ); true gap> List( [ 1 .. 8 ], i -> DeligneLusztigName( Irr( tbl )[i] ) ); [ "phi{1,0}", "[ [ 2 ], [ ] ]", "phi{2,4}''", "phi{2,4}'", "F4^II[1]", "phi{4,1}", "F4^I[1]", "phi{9,2}" ]

`‣ KnowsDeligneLusztigNames` ( tbl ) | ( property ) |

For an ordinary character table `tbl`, this function returns `true`

if `DeligneLusztigNames`

(3.4-2) returns the list of Deligne-Lusztig names of the unipotent characters of `tbl`, and `false`

otherwise.

gap> KnowsDeligneLusztigNames( CharacterTable( "A5" ) ); true gap> KnowsDeligneLusztigNames( CharacterTable( "M" ) ); false

The following functions are available only if the **GAP** package **Browse** (see [BL23]) is loaded. The function `DisplayCTblLibInfo`

(3.5-1) shows details about an ordinary or modular character table in a pager, the other functions can be used to show the following information via browse tables.

An overview of the

**GAP**Character Table Library, and details pages about ordinary and modular character tables (see`BrowseCTblLibInfo`

(3.5-2)), which allow one to navigate to related pages and to pages showing for example decomposition matrices (cf.`BrowseDecompositionMatrix`

(Browse: BrowseDecompositionMatrix)),an alternative display function that shows character tables from the

**Atlas**of Finite Groups [CCN+85] and the**Atlas**of Brauer Characters [JLPW95] in a format similar to the one used in these books (see`BrowseAtlasTable`

(3.5-9), cf.`Browse (for character tables)`

(Browse: Browse for character tables) for the default display format for character tables),an overview of the names of simple groups for which the

**Atlas**of Finite Groups [CCN+85] and the**Atlas**of Brauer Characters [JLPW95] show the character tables and other information (see`BrowseAtlasContents`

(3.5-5), a variant that doe not rely on**Browse**is`DisplayAtlasContents`

(3.5-6)),a function that shows the

**Atlas**map of the bicyclic extensions of a simple**Atlas**group (see`BrowseAtlasMap`

(3.5-7), a variant that does not rely on**Browse**is`DisplayAtlasMap`

(3.5-8)),an overview of the "atomic irrationalities" that occur in

**Atlas**character tables (see`BrowseCommonIrrationalities`

(3.5-3)),an overview of the lists of improvements to the

**Atlas**of Finite Groups (see`BrowseAtlasImprovements`

(3.5-10)).an overview of the differences between the character table data since version 1.1.3 of the

**CTblLib**package (see`BrowseCTblLibDifferences`

(3.5-4)),

The functions `BrowseCTblLibInfo`

(3.5-2), `BrowseCommonIrrationalities`

(3.5-3), `BrowseCTblLibDifferences`

(3.5-4), `BrowseAtlasContents`

(3.5-5), and `BrowseAtlasImprovements`

(3.5-10) occur also in the list of choices shown by `BrowseGapData`

(Browse: BrowseGapData).

`‣ DisplayCTblLibInfo` ( tbl ) | ( function ) |

`‣ DisplayCTblLibInfo` ( name[, p] ) | ( function ) |

`‣ StringCTblLibInfo` ( tbl ) | ( function ) |

`‣ StringCTblLibInfo` ( name[, p] ) | ( function ) |

When `DisplayCTblLibInfo`

is called with an ordinary or modular character table `tbl` then an overview of the information available for this character table is shown via the function that is given by the user preference 4.5-3. When `DisplayCTblLibInfo`

is called with a string `name` that is an admissible name for an ordinary character table then the overview for this character table is shown. If a prime integer `p` is entered in addition to `name` then information about the `p`-modular character table is shown instead.

An interactive variant of `DisplayCTblLibInfo`

is `BrowseCTblLibInfo`

(3.5-2).

The string that is shown by `DisplayCTblLibInfo`

can be computed using `StringCTblLibInfo`

, with the same arguments.

gap> StringCTblLibInfo( CharacterTable( "A5" ) );; gap> StringCTblLibInfo( CharacterTable( "A5" ) mod 2 );; gap> StringCTblLibInfo( "A5" );; gap> StringCTblLibInfo( "A5", 2 );;

`‣ BrowseCTblLibInfo` ( [func, val, ...] ) | ( function ) |

`‣ BrowseCTblLibInfo` ( tbl ) | ( function ) |

`‣ BrowseCTblLibInfo` ( name[, p] ) | ( function ) |

Returns: nothing.

Called without arguments, `BrowseCTblLibInfo`

shows the contents of the **GAP** Character Table Library in an *overview table*, see below.

When arguments `func`, `val`, `...` are given that are admissible arguments for `AllCharacterTableNames`

(3.1-4) –in particular, the first argument must be a function– then the overview is restricted to those character tables that match the conditions. The global option `"OrderedBy"`

is supported as in `AllCharacterTableNames`

(3.1-4).

When `BrowseCTblLibInfo`

is called with a character table `tbl` then a *details table* is opened that gives an overview of the information available for this character table. When `BrowseCTblLibInfo`

is called with a string `name` that is an admissible name for an ordinary character table then the details table for this character table is opened. If a prime integer `p` is entered in addition to `name` then information about the `p`-modular character table is shown instead.

The overview table has the following columns.

`name`

the

`Identifier`

(Reference: Identifier for character tables) value of the table,`size`

the group order,

`nccl`

the number of conjugacy classes,

`fusions -> G`

the list of identifiers of tables on which a fusion to the given table is stored, and

`fusions G ->`

the list of identifiers of tables to which a fusion is stored on the given table.

The details table for a given character table has exactly one column. Only part of the functionality of the function `NCurses.BrowseGeneric`

(Browse: NCurses.BrowseGeneric) is available in such a table. On the other hand, the details tables contain "links" to other Browse applications, for example other details tables.

When one "clicks" on a row or an entry in the overview table then the details table for the character table in question is opened. One can navigate from this details table to a related one, by first *activating* a link (via repeatedly hitting the **Tab** key) and then *following* the active link (via hitting the **Return** key). If mouse actions are enabled (by hitting the **M** key, see `NCurses.UseMouse`

(Browse: NCurses.UseMouse)) then one can alternatively activate a link and click on it via mouse actions.

gap> tab:= [ 9 ];; # hit the TAB key gap> n:= [ 14, 14, 14 ];; # ``do nothing'' input (means timeout) gap> BrowseData.SetReplay( Concatenation( > # select the first column, search for the name A5 > "sc/A5", [ NCurses.keys.DOWN, NCurses.keys.DOWN, > NCurses.keys.RIGHT, NCurses.keys.ENTER ], > # open the details table for A5 > [ NCurses.keys.ENTER ], n, n, > # activate the link to the character table of A5 > tab, n, n, > # show the character table of A5 > [ NCurses.keys.ENTER ], n, n, "seddrr", n, n, > # close this character table > "Q", > # activate the link to the maximal subgroup D10 > tab, tab, n, n, > # jump to the details table for D10 > [ NCurses.keys.ENTER ], n, n, > # close this details table > "Q", > # activate the link to a decomposition matrix > tab, tab, tab, tab, tab, n, n, > # show the decomposition matrix > [ NCurses.keys.ENTER ], n, n, > # close this table > "Q", > # activate the link to the AtlasRep overview > tab, tab, tab, tab, tab, tab, tab, n, n, > # show the overview > [ NCurses.keys.ENTER ], n, n, > # close this table > "Q", > # and quit the applications > "QQ" ) ); gap> BrowseCTblLibInfo(); gap> BrowseData.SetReplay( false );

`‣ BrowseCommonIrrationalities` ( ) | ( function ) |

Returns: a list of info records for the irrationalities that have been "clicked" in visual mode.

This function shows the atomic irrationalities that occur in character tables in the **Atlas** of Finite Groups [CCN+85] or the **Atlas** of Brauer Characters [JLPW95], together with descriptions of their reductions to the relevant finite fields in a browse table with the following columns. The format is the same as in [JLPW95, Appendix 1].

`name`

the name of the irrationality, see

`AtlasIrrationality`

(Reference: AtlasIrrationality),`p`

the characteristic,

`value mod C_n`

the corresponding reduction to a finite field of characteristic

`p`

, given by the residue modulo the`n`

-th Conway polynomial (see`ConwayPolynomial`

(Reference: ConwayPolynomial)),`n`

the degree of the smallest extension of the prime field of characteristic

`p`

that contains the reduction.

gap> n:= [ 14, 14, 14 ];; # ``do nothing'' input (means timeout) gap> BrowseData.SetReplay( Concatenation( > # categorize the table by the characteristics > "scrsc", n, n, > # expand characteristic 2 > "srxq", n, n, > # scroll down > "DDD", n, n, > # and quit the application > "Q" ) ); gap> BrowseCommonIrrationalities();; gap> BrowseData.SetReplay( false );

`‣ BrowseCTblLibDifferences` ( ) | ( function ) |

Returns: nothing.

`BrowseCTblLibDifferences`

lists the differences between the versions of the character table data in the **CTblLib** package, since version 1.1.3.

The overview table contains one row for each change, where "change" means the addition, modification, or removal of information, and has the following columns.

`Identifier`

the

`Identifier`

(Reference: Identifier for character tables) value of the character table,`Type`

one of

`NEW`

(for the addition of previously not available information),`***`

(for a bugfix), or`C`

(for a change that does not really fix a bug, typically a change motivated by a new consistency criterion),`What`

one of

`class fusions`

(some class fusions from or to the table in question were changed),`maxes`

(the value of the attribute`Maxes`

(3.7-1) was changed),`names`

(incorrect admissible names were removed),`table`

or`table mod`

\(p\) (the ordinary or \(p\)-modular character table was changed),`maxes`

(the value of the attribute`Maxes`

(3.7-1) was changed),`tom fusion`

(the value of the attribute`FusionToTom`

(3.2-4) was changed),`Description`

a description what has been changed,

`Flag`

one of

`Dup`

(the table is a duplicate, in the sense of`IsDuplicateTable`

(3.6-1)),`Der`

(the row belongs to a character table that is derived from other tables),`Fus`

(the row belongs to the addition of class fusions),`Max`

(the row belongs to a character table that was added because its group is maximal in another group), or`None`

(in all other cases –these rows are to some extent the interesting ones). The information in this column can be used to restrict the overview to interesting subsets.`Vers.`

the package version in which the change described by the row appeared first.

The full functionality of the function `NCurses.BrowseGeneric`

(Browse: NCurses.BrowseGeneric) is available.

The following examples show the input for

restricting the overview to error rows,

restricting the overview to "None" rows, and

restricting the overview to rows about a particular table.

gap> n:= [ 14, 14, 14, 14, 14, 14 ];; # ``do nothing'' gap> enter:= [ NCurses.keys.ENTER ];; gap> down:= [ NCurses.keys.DOWN ];; gap> right:= [ NCurses.keys.RIGHT ];; gap> BrowseData.SetReplay( Concatenation( > "scr", # select the 'Type' column, > "f***", enter, # filter rows containing '***', > n, "Q" ) ); # and quit gap> BrowseCTblLibDifferences(); gap> BrowseData.SetReplay( Concatenation( > "scrrrr", # select the 'Flag' column, > "fNone", enter, # filter rows containing 'None', > n, "Q" ) ); # and quit gap> BrowseCTblLibDifferences(); gap> BrowseData.SetReplay( Concatenation( > "fM", # filter rows containing 'M', > down, down, down, right, # but 'M' as a whole word, > enter, # > n, "Q" ) ); # and quit gap> BrowseCTblLibDifferences(); gap> BrowseData.SetReplay( false );

`‣ BrowseAtlasContents` ( ) | ( function ) |

Returns: nothing.

`BrowseAtlasContents`

shows the list of names of simple groups and the corresponding page numbers in the **Atlas** of Finite Groups [CCN+85], as given on page v of this book, plus a few groups for which [JLPW95, Appendix 2] states that their character tables in **Atlas** format have been obtained; if applicable then also the corresponding page numbers in the **Atlas** of Brauer Characters [JLPW95] are shown.

Clicking on a page number opens the **Atlas** map for the group in question, see `BrowseAtlasMap`

(3.5-7). (From the map, one can open the **Atlas** style display using the input `"T"`

.)

gap> d:= [ NCurses.keys.DOWN ];; r:= [ NCurses.keys.RIGHT ];; gap> c:= [ NCurses.keys.ENTER ];; gap> BrowseData.SetReplay( Concatenation( > "/J2", # Find the string J2, > c, # start the search, > r, # select the page for the ordinary table, > c, # click the entry, > "se", # select the box of the simple group, > c, # click the box, > "Q", # quit the info overview for J2, > d, # move down to 2.J2, > c, # click the box, > "Q", # quit the info overview for 2.J2, > "T", # show the ATLAS table for (extensions of) J2 > "Q", # quit the ATLAS table, > "Q", # quit the map, > r, # select the page for the 2-modular table, > c, # click the entry, > "T", # show the 2-modular ATLAS table > "Q", # quit the ATLAS table, > "Q", # quit the map, > "Q" ) ); # and quit the application. gap> BrowseAtlasContents(); gap> BrowseData.SetReplay( false );

`‣ DisplayAtlasContents` ( ) | ( function ) |

`‣ StringAtlasContents` ( ) | ( function ) |

`DisplayAtlasContents`

calls the function that is given by the user preference 4.5-3, in order to show the list of names of simple groups and the corresponding page numbers in the **Atlas** of Finite Groups [CCN+85], as given on page v of this book, plus a few groups for which [JLPW95, Appendix 2] states that their character tables in **Atlas** format have been obtained; if applicable then also the corresponding page numbers in the **Atlas** of Brauer Characters [JLPW95] are shown.

An interactive variant of `DisplayAtlasContents`

is `BrowseAtlasContents`

(3.5-5).

The string that is shown by `DisplayAtlasContents`

can be computed using `StringAtlasContents`

.

gap> str:= StringAtlasContents();; gap> pos:= PositionNthOccurrence( str, '\n', 10 );; gap> Print( str{ [ 1 .. pos ] } ); A5 = L2(4) = L2(5) 2 2:2, 3:2, 5:2 L3(2) = L2(7) 3 2:3, 3:3, 7:3 A6 = L2(9) = S4(2)' 4 2:4, 3:4, 5:5 L2(8) = R(3)' 6 2:6, 3:6, 7:6 L2(11) 7 2:7, 3:7, 5:8, 11:8 L2(13) 8 2:9, 3:9, 7:10, 13:10 L2(17) 9 2:11, 3:11, 17:12 A7 10 2:13, 3:13, 5:14, 7:15 L2(19) 11 2:16, 3:16, 5:17, 19:18 L2(16) 12 2:19, 3:20, 5:20, 17:21

`‣ BrowseAtlasMap` ( name[, p] ) | ( function ) |

Returns: nothing.

For a string `name` that is the identifier of the character table of a simple group from the **Atlas** of Finite Groups [CCN+85], `BrowseAtlasMap`

shows the map that describes the bicyclic extensions of this group, see [CCN+85, Chapter 6]. If the optional argument `p` is not given or if `p` is zero then the map for the ordinary character tables is shown, if `p` is a prime integer then the map for the `p`-modular Brauer character tables is shown, as in [JLPW95].

Clicking on a square of the map opens the character table information for the extension in question, by calling `BrowseCTblLibInfo`

(3.5-2).

gap> d:= [ NCurses.keys.DOWN ];; r:= [ NCurses.keys.RIGHT ];; gap> c:= [ NCurses.keys.ENTER ];; gap> BrowseData.SetReplay( Concatenation( > "T", # show the ATLAS table for (extensions of) M12 > "Q", # quit the ATLAS table, > "se", # select the box of the simple group, > c, # click the box, > "Q", # quit the info overview for M12, > r, d, # select the box for the bicyclic extension, > c, # click the box, > "Q", # quit the info overview, > "Q" ) ); # and quit the application. gap> BrowseAtlasMap( "M12" ); gap> BrowseData.SetReplay( false );

`‣ DisplayAtlasMap` ( name[, p] ) | ( function ) |

`‣ DisplayAtlasMap` ( arec ) | ( function ) |

`‣ StringsAtlasMap` ( name[, p] ) | ( function ) |

`‣ StringsAtlasMap` ( arec ) | ( function ) |

Returns: `DisplayAtlasMap`

returns nothing, `StringsAtlasMap`

returns either `fail`

or the list of strings that form the rows of the **Atlas** map of the group in question.

Let `name` be an admissible name for the character table of a simple **Atlas** group, and `p` be a prime integer or \(0\) (which is the default). `DisplayAtlasMap`

shows the map for the group and its extensions, similar to the map shown in the **Atlas**. `StringsAtlasMap`

returns the list of strings that form the rows of this map.

gap> DisplayAtlasMap( "M12" ); --------- --------- | | | | | G | | G.2 | 15 | | | | --------- --------- --------- --------- | | | | | 2.G | | 2.G.2 | 11 | | | | --------- --------- 15 9 gap> DisplayAtlasMap( "M12", 2 ); --------- --------- | | | | | G | | G.2 | 6 | | | | --------- --------- 6 0 gap> StringsAtlasMap( "M11" ); [ "--------- ", "| | ", "| G | 10", "| | ", "--------- ", " 10 " ]

More generally, `name` can be an admissible name for a character with known `ExtensionInfoCharacterTable`

(3.7-3) value and such that the strings describing multiplier and outer automorphism group in this value occur in the lists `CTblLib.AtlasMapMultNames`

and `CTblLib.AtlasMapOutNames`

, respectively. If not all character tables of bicyclic extensions of the simple group in question are available then `StringsAtlasMap`

returns `fail`

, and `DisplayAtlasMap`

shows nothing.

gap> DisplayAtlasMap( "S10(2)" ); --------- | | | G | 198 | | --------- 198 gap> DisplayAtlasMap( "L12(27)" ); gap> StringsAtlasMap( "L12(27)" ); fail

If the abovementioned requirements are not satisfied for the character tables in question then one can provide the necessary information via a record `arec`.

The following example shows the "**Atlas** map" for the alternating group on four points, viewed as an extension of the trivial group by a Klein four group and a group of order three.

gap> DisplayAtlasMap( rec( > labels:= [ [ "G", "G.3" ], > [ "2.G", "" ], > [ "2'.G", "" ], > [ "2''.G", "" ] ], > shapes:= [ [ "closed", "closed" ], > [ "closed", "empty" ], > [ "closed", "empty" ], > [ "closed", "empty" ] ], > labelscol:= [ "1", "1" ], > labelsrow:= [ "1", "1", "1", "1" ], > dashedhorz:= [ false, false, true, true ], > dashedvert:= [ false, false ], > showdashedrows:= true ) ); --------- --------- | | | | | G | | G.3 | 1 | | | | --------- --------- --------- | | | 2.G | 1 | | --------- 2'.G --------- --------- 2''.G --------- --------- 1 1

The next example shows the "**Atlas** map" for the symmetric group on three points, viewed as a bicyclic extension of the trivial group by groups of the orders three and two, respectively.

gap> DisplayAtlasMap( rec( > labels:= [ [ "G", "G.2" ], > [ "3.G", "3.G.2" ] ], > shapes:= [ [ "closed", "closed" ], > [ "closed", "open" ] ], > labelscol:= [ "1", "1" ], > labelsrow:= [ "1", "1" ], > dashedhorz:= [ false, false ], > dashedvert:= [ false, false ], > showdashedrows:= true ) ); --------- --------- | | | | | G | | G.2 | 1 | | | | --------- --------- --------- -------- | | | | 3.G | | 3.G.2 1 | | | --------- 1 1

(Depending on the terminal capabilities, the results may look nicer than the "ASCII only" graphics shown above.)

The following components of `arec` are supported.

`name`

a string, the name of the (simple) group;

`char`

the characteristic, the default is \(0\);

`identifiers`

an \(m\) by \(n\) matrix whose entries are

`fail`

or the`Identifier`

(Reference: Identifier for tables of marks) values of the character tables of the extensions in question;`labels`

an \(m\) by \(n\) matrix whose entries are

`fail`

or the strings that shall be used as the labels of the boxes;`shapes`

an \(m\) by \(n\) matrix whose entries are the strings

`"closed"`

,`"open"`

,`"broken"`

, and`"empty"`

, describing the boxes that occur;`labelscol`

a list of length \(n\) that contains the labels to be shown below the last row of boxes, intended to show the numbers of classes in this column of boxes;

`labelsrow`

a list of length \(m\) that contains the labels to be shown on the right of the last column of boxes, intended to show the numbers of characters in this row of boxes;

`dashedhorz`

a list of length \(m\) with entries

`true`

(the boxes in this row shall have small height) or`false`

(the boxes in this row shall have normal height);`dashedvert`

a list of length \(n\) with entries

`true`

(the boxes in this column shall have small width) or`false`

(the boxes in this column shall have normal width);`showdashedrows`

`true`

or`false`

, the default is to show rows of "dashed" boxes in the case of ordinary tables, and to omit them in the case of Brauer tables, as happens in the printed Atlases;`onlyasciiboxes`

`true`

(show only ASCII characters when drawing the boxes) or`false`

(use line drawing characters), the default is the value returned by`CTblLib.ShowOnlyASCII`

;`onlyasciilabels`

`true`

(show only ASCII characters in the labels inside the boxes) or`false`

(default, use subscripts if applicable); the default is the value returned by`CTblLib.ShowOnlyASCII`

;`specialshapes`

a list of length three that describes exceptional cases (intended for the treatment of "dashed names" and "broken boxes", look at the values in

`CTblLib.AtlasMapBoxesSpecial`

where this component is actually used).

`‣ BrowseAtlasTable` ( name[, p] ) | ( function ) |

Returns: nothing.

`BrowseAtlasTable`

displays the character tables of bicyclic extensions of the simple group with the name `name` in a window, in the same format as the **Atlas** of Finite Groups [CCN+85] and the **Atlas** of Brauer Characters [JLPW95] do. For that, it is necessary that these tables are known, as well as the class fusions between them and perhaps additional information (e. g., about the existence of certain extensions). These requirements are fulfilled if the tables are contained in the **Atlas**, but they may hold also in other cases.

If a prime `p` is given as the second argument then the `p`-modular Brauer tables are shown, otherwise (or if `p` is zero) the ordinary tables are shown.

gap> d:= [ NCurses.keys.DOWN ];; r:= [ NCurses.keys.RIGHT ];; gap> c:= [ NCurses.keys.ENTER ];; gap> BrowseData.SetReplay( Concatenation( > "/y", # Find the string y, > c, # start the search, > "nnnn", # Find more occurrences, > "Q" ) ); # and quit the application. gap> BrowseAtlasTable( "A6" ); gap> BrowseData.SetReplay( false );

The function uses `NCurses.BrowseGeneric`

(Browse: NCurses.BrowseGeneric). The identifier of the table is used as the static header. The strings `X_1`

, `X_2`

, \(\ldots\) are used as row labels for those table rows that contain character values, and column labels are given by centralizer orders, power map information, and class names.

`‣ BrowseAtlasImprovements` ( [choice] ) | ( function ) |

Returns: nothing.

Called without argument or with the string `"ordinary"`

, `BrowseAtlasImprovements`

shows the lists of improvements to the **Atlas** of Finite Groups [CCN+85] that are contained in [BN95] and [Nor].

Called with the string `"modular"`

, `BrowseAtlasImprovements`

shows the list of improvements to the **Atlas** of Brauer Characters [JLPW95] that are contained in [ABC].

Called with `true`

, the concatenation of the above lists are shown.

The overview table contains one row for each improvement, and has the following columns.

`Section`

the part in the

**Atlas**to which the entry belongs (Introduction, The Groups, Additional information, Bibliography, Appendix 1, Appendix 2),`Src`

`1`

for entries from [BN95],`2`

for entries from [Nor], and`3`

for entries from [ABC],`Typ`

the type of the improvement, one of

`***`

(for mathematical errors),`NEW`

(for new information),`C`

(for improvements concerning grammar or notational consistency), or`M`

(for misprints or cases of illegibility),`Page`

the page and perhaps the line in the (ordinary or modular)

**Atlas**,`Group`

the name of the simple group to which the entry belongs (empty for entries not from the section "The Groups"),

`Text`

the description of the entry,

`**`

for each entry of the type

`***`

, the subtype of the error to which some statements in [BMO17] refer, one of`CH`

(character values),`P`

(power maps, element orders, and class names),`FI`

(fusions and indicators),`I`

(Introduction, Bibliography, the list showing the orders of multipliers and outer automorphism group, and the list of Conway polynomials),`MP`

(maps),`MX`

(descriptions of maximal subgroups), and`G`

(other information about the group).

The full functionality of the function `NCurses.BrowseGeneric`

(Browse: NCurses.BrowseGeneric) is available.

The following example shows the input for first restricting the list to errors (type `***`

), then categorizing the filtered list by the subtype of the error, and then expanding the category for the subtype `CH`

.

gap> n:= [ 14, 14, 14, 14, 14, 14 ];; # ``do nothing'' gap> enter:= [ NCurses.keys.ENTER ];; gap> BrowseData.SetReplay( Concatenation( > "scrr", # select the 'Typ' column, > "f***", enter, # filter rows containing '***', > "scrrrrrrsc", enter, # categorize by the error kind > "sr", enter, # expand the 'CH' category > n, "Q" ) ); # and quit gap> BrowseAtlasImprovements(); gap> BrowseData.SetReplay( false );

It can be useful to deal with different instances of "the same" character table. An example is the situation that a group \(G\), say, contains several classes of isomorphic maximal subgroups that have different class fusions; the attribute `Maxes`

(3.7-1) of the character table of \(G\) then contains several entries that belong to the same group, but the identifiers of the character tables are different.

On the other hand, it can be useful to consider only one of the different instances when one searches for character tables with certain properties, for example using `OneCharacterTableName`

(3.1-5).

For that, we introduce the following concept. A character table \(t_1\) is said to be a *duplicate* of another character table \(t_2\) if the attribute `IdentifierOfMainTable`

(3.6-2) returns the `Identifier`

(Reference: Identifier for character tables) value of \(t_2\) when it is called with \(t_1\), and we call \(t_2\) the *main table* of \(t_1\). In this case, `IsDuplicateTable`

(3.6-1) returns `true`

for \(t_1\).

If the character table \(t_1\) is not a duplicate of any other library table then `IdentifierOfMainTable`

(3.6-2) returns `fail`

for \(t_1\) and `IsDuplicateTable`

(3.6-1) returns `false`

.

See `AllCharacterTableNames`

(3.1-4) for examples how to apply `IsDuplicateTable`

(3.6-1) in practice.

We do *not* promise that two library tables for which `IsDuplicateTable`

(3.6-1) returns `false`

are necessarily different. (And since nonisomorphic groups may have the same character table, it would not make sense to think about restricting a search to a subset of library tables that belong to pairwise nonisomorphic groups.)

Currently `IdentifierOfMainTable`

(3.6-2) does not return `fail`

for \(t_1\) if `ConstructionInfoCharacterTable`

(3.7-4) is set in \(t_1\), the first entry of the attribute value is `"ConstructPermuted"`

, and one of the following holds.

The second entry of the

`ConstructionInfoCharacterTable`

(3.7-4) value is a list of length \(1\) that contains the`Identifier`

(Reference: Identifier for character tables) value of \(t_2\).The

**SpinSym**package is loaded and \(t_1\) is one of the character tables provided by this package. These tables are not declared as permuted tables of library tables, but we*want*to regard them as duplicates.

`‣ IsDuplicateTable` ( tbl ) | ( property ) |

For an ordinary character table `tbl` from the **GAP** Character Table Library, this function returns `true`

if `tbl` was constructed from another library character table by permuting rows and columns, via the attribute `ConstructionInfoCharacterTable`

(3.7-4). Otherwise `false`

is returned, in particular if `tbl` is not a character table from the **GAP** Character Table Library.

One application of this function is to restrict the search with `AllCharacterTableNames`

(3.1-4) to only one library character table for each class of permutation equivalent tables. Note that this does property of the search result cannot be guaranteed if private character tables have been added to the library, see `NotifyCharacterTable`

(4.7-5).

gap> Maxes( CharacterTable( "A6" ) ); [ "A5", "A6M2", "3^2:4", "s4", "A6M5" ] gap> IsDuplicateTable( CharacterTable( "A5" ) ); false gap> IsDuplicateTable( CharacterTable( "A6M2" ) ); true

`‣ IdentifierOfMainTable` ( tbl ) | ( attribute ) |

If `tbl` is an ordinary character table that is a duplicate in the sense of the introduction to Section 3.6 then this function returns the `Identifier`

(Reference: Identifier for character tables) value of the main table of `tbl`. Otherwise `fail`

is returned.

gap> Maxes( CharacterTable( "A6" ) ); [ "A5", "A6M2", "3^2:4", "s4", "A6M5" ] gap> IdentifierOfMainTable( CharacterTable( "A5" ) ); fail gap> IdentifierOfMainTable( CharacterTable( "A6M2" ) ); "A5"

`‣ IdentifiersOfDuplicateTables` ( tbl ) | ( attribute ) |

For an ordinary character table `tbl`, this function returns the list of `Identifier`

(Reference: Identifier for character tables) values of those character tables from the **GAP** Character Table Library that are duplicates of `tbl`, in the sense of the introduction to Section 3.6.

gap> Maxes( CharacterTable( "A6" ) ); [ "A5", "A6M2", "3^2:4", "s4", "A6M5" ] gap> IdentifiersOfDuplicateTables( CharacterTable( "A5" ) ); [ "A6M2", "Alt(5)" ] gap> IdentifiersOfDuplicateTables( CharacterTable( "A6M2" ) ); [ ]

This section describes certain attributes which are set only for certain (not necessarily all) character tables from the **GAP** Character Table Library. The attribute values are part of the database, there are no methods for *computing* them, except for `InfoText`

(3.7-5).

Other such attributes and properties are described in manual sections because the context fits better. These attributes are `FusionToTom`

(3.2-4), `GroupInfoForCharacterTable`

(3.3-1), `KnowsSomeGroupInfo`

(3.3-2), `IsNontrivialDirectProduct`

(3.3-7), `DeligneLusztigNames`

(3.4-2), `DeligneLusztigName`

(3.4-3), `KnowsDeligneLusztigNames`

(3.4-4), `IsDuplicateTable`

(3.6-1), and `CASInfo`

(4.4-1).

`‣ Maxes` ( tbl ) | ( attribute ) |

If this attribute is set for an ordinary character table `tbl` then the value is a list of identifiers of the ordinary character tables of all maximal subgroups of `tbl`. There is no default method to *compute* this value from `tbl`.

If the `Maxes`

value of `tbl` is stored then it lists exactly one representative for each conjugacy class of maximal subgroups of the group of `tbl`, and the character tables of these maximal subgroups are available in the **GAP** Character Table Library, and compatible class fusions to `tbl` are stored on these tables (see the example in Section 2.3-5).

gap> tbl:= CharacterTable( "M11" );; gap> HasMaxes( tbl ); true gap> maxes:= Maxes( tbl ); [ "A6.2_3", "L2(11)", "3^2:Q8.2", "A5.2", "2.S4" ] gap> CharacterTable( maxes[1] ); CharacterTable( "A6.2_3" )

`‣ ProjectivesInfo` ( tbl ) | ( attribute ) |

If this attribute is set for an ordinary character table `tbl` then the value is a list of records, each with the following components.

`name`

the

`Identifier`

(Reference: Identifier for character tables) value of the character table of the covering whose faithful irreducible characters are described by the record,`chars`

a list of values lists of faithful projective irreducibles; only one representative of each family of Galois conjugates is contained in this list. and

gap> ProjectivesInfo( CharacterTable( "A5" ) ); [ rec( chars := [ [ 2, 0, -1, E(5)+E(5)^4, E(5)^2+E(5)^3 ], [ 2, 0, -1, E(5)^2+E(5)^3, E(5)+E(5)^4 ], [ 4, 0, 1, -1, -1 ], [ 6, 0, 0, 1, 1 ] ], name := "2.A5" ) ]

`‣ ExtensionInfoCharacterTable` ( tbl ) | ( attribute ) |

Let `tbl` be the ordinary character table of a group \(G\), say. If this attribute is set for `tbl` then the value is a list of length two, the first entry being a string `M`

that describes the Schur multiplier of \(G\) and the second entry being a string `A`

that describes the outer automorphism group of \(G\). Trivial multiplier or outer automorphism group are denoted by an empty string.

If `tbl` is a table from the **GAP** Character Table Library and \(G\) is (nonabelian and) simple then the value is set. In this case, an admissible name for the character table of a universal covering group of \(G\) (if this table is available and different from `tbl`) is given by the concatenation of `M`

, `"."`

, and the `Identifier`

(Reference: Identifier for character tables) value of `tbl`. Analogously, an admissible name for the character table of the automorphism group of \(G\) (if this table is available and different from `tbl`) is given by the concatenation of the `Identifier`

(Reference: Identifier for character tables) value of `tbl`, `"."`

, and `A`

.

gap> ExtensionInfoCharacterTable( CharacterTable( "A5" ) ); [ "2", "2" ]

`‣ ConstructionInfoCharacterTable` ( tbl ) | ( attribute ) |

If this attribute is set for an ordinary character table `tbl` then the value is a list that describes how this table was constructed. The first entry is a string that is the identifier of the function that was applied to the pre-table record; the remaining entries are the arguments for that function, except that the pre-table record must be prepended to these arguments.

`‣ InfoText` ( tbl ) | ( method ) |

This method for library character tables returns an empty string if no `InfoText`

value is stored on the table `tbl`.

Without this method, it would be impossible to use `InfoText`

in calls to `AllCharacterTableNames`

(3.1-4), as in the following example.

gap> AllCharacterTableNames( InfoText, > s -> PositionSublist( s, "tests:" ) <> fail );;

generated by GAPDoc2HTML