Ziele Untersuchung
mit Columbo Integrität von
Datenbanken Interaktion und
Portierbarkeit Ergonomie der
Schnittstellen

Angebot Produkte Projekt Beratung

Mittel Analytik Modellierung Sprachen Algebra Logik Hardware Denken Kreativität

Zusammenhänge Gesellschaft Wirtschaft Branche Firma


products/Sources/formale Sprachen/GAP/lib/ (Algebra von RWTH Aachen Version 4.15.1^©) Datei vom 18.9.2025 mit Größe 177 kB

Quelle ctbl.gd Sprache: unbekannt

Spracherkennung für: .gd vermutete Sprache: Unknown {[0] [0] [0]} [Methode: Schwerpunktbildung, einfache Gewichte, sechs Dimensionen]

#############################################################################
##
## This file is part of GAP, a system for computational discrete algebra.
## This file's authors include Thomas Breuer, Götz Pfeiffer.
##
## Copyright of GAP belongs to its developers, whose names are too numerous
## to list here. Please refer to the COPYRIGHT file for details.
##
## SPDX-License-Identifier: GPL-2.0-or-later
##
## This file contains the definition of categories of character table like
## objects, and their properties, attributes, operations, and functions.
##
## 1. Some Remarks about Character Theory in GAP
## 2. Character Table Categories
## 3. The Interface between Character Tables and Groups
## 4. Operators for Character Tables
## 5. Attributes and Properties for Groups as well as for Character Tables
## 6. Attributes and Properties only for Character Tables
## x. Operations Concerning Blocks
## 7. Other Operations for Character Tables
## 8. Creating Character Tables
## 9. Printing Character Tables
## 10. Constructing Character Tables from Others
## 11. Sorted Character Tables
## 12. Storing Normal Subgroup Information
## 13. Auxiliary Stuff
##

#T when are two character tables equal? -> same identifier & same permutation?)

#############################################################################
##
#T TODO:
##
#T (about incomplete tables!)
#T
#T For character tables that do *not* store an underlying group,
#T there is no notion of generation, contrary to all &GAP; domains.
#T Consequently, the correctness or even the consistency of such a character
#T table is hard to decide.
#T Nevertheless, one may want to work with incomplete character tables or
#T hypothetical tables which are, strictly speaking, not character tables
#T but shall be handled like character tables.
#T In such cases, one often has to set attribute values by hand;
#T no need to say that one must be very careful then.
##
#T introduce fusion objects?
##
#T improve `CompatibleConjugacyClasses',
#T unify it with `TransformingPermutationsCharacterTables'!
##

#############################################################################
##
## 1. Some Remarks about Character Theory in GAP
##
## <#GAPDoc Label="[1]{ctbl}">
## It seems to be necessary to state some basic facts
## –and maybe warnings–
## at the beginning of the character theory package.
## This holds for people who are familiar with character theory because
## there is no global reference on computational character theory,
## although there are many papers on this topic,
## such as <Cite Key="NPP84"/> or <Cite Key="LP91"/>.
## It holds, however, also for people who are familiar with &GAP; because
## the general concept of domains (see Chapter <Ref Sect="Domains"/>)
## plays no important role here
## –we will justify this later in this section.
## 
## Intuitively, <E>characters</E> (or more generally,
## <E>class functions</E>) of a finite group <M>G</M> can be thought of as
## certain mappings defined on <M>G</M>,
## with values in the complex number field;
## the set of all characters of <M>G</M> forms a semiring, with both
## addition and multiplication defined pointwise, which is naturally
## embedded into the ring of <E>generalized</E> (or <E>virtual</E>)
## <E>characters</E> in the natural way.
## A <M>&ZZ;</M>-basis of this ring, and also a vector space basis of the
## complex vector space of class functions of <M>G</M>,
## is given by the irreducible characters of <M>G</M>.
## 
## At this stage one could ask where there is a problem, since all these
## algebraic structures are supported by &GAP;.
## But in practice, these structures are of minor importance,
## compared to individual characters and the <E>character tables</E>
## themselves (which are not domains in the sense of &GAP;).
## 
## For computations with characters of a finite group <M>G</M> with <M>n</M>
## conjugacy classes, we fix an ordering of the classes, and then
## identify each class with its position according to this ordering.
## Each character of <M>G</M> can be represented by a list of length
## <M>n</M> in which the character value for elements of the <M>i</M>-th
## class is stored at the <M>i</M>-th position.
## Note that we need not know the conjugacy classes of <M>G</M> physically,
## even our knowledge of <M>G</M> may be implicit in the sense that, e.g.,
## we know how many classes of involutions <M>G</M> has, and which length
## these classes have, but we never have seen an element of <M>G</M>,
## or a presentation or representation of <M>G</M>.
## This allows us to work with the character tables of very large groups,
## e.g., of the so-called monster, where &GAP; has (currently) no chance
## to deal with the group.
## 
## As a consequence, also other information involving characters is given
## implicitly. For example, we can talk about the kernel of a character not
## as a group but as a list of classes (more exactly: a list of their
## positions according to the chosen ordering of classes) forming this
## kernel; we can deduce the group order, the contained cyclic subgroups
## and so on, but we do not get the group itself.
## 
## So typical calculations with characters involve loops over lists of
## character values.
## For example, the scalar product of two characters <M>\chi</M>,
## <M>\psi</M> of <M>G</M> given by
## <Display Mode="M">
## [ \chi, \psi ] =
## \left( \sum_{{g \in G}} \chi(g) \psi(g^{{-1}}) \right) / |G|
## </Display>
## can be written as
## <Listing><![CDATA[
## Sum( [ 1 .. n ], i -> SizesConjugacyClasses( t )[i] * chi[i]
## * ComplexConjugate( psi[i] ) ) / Size( t );
## ]]></Listing>
## where <C>t</C> is the character table of <M>G</M>, and <C>chi</C>,
## <C>psi</C> are the lists of values of <M>\chi</M>, <M>\psi</M>,
## respectively.
## 
## It is one of the advantages of character theory that after one has
## translated a problem concerning groups into a problem concerning
## only characters, the necessary calculations are mostly simple.
## For example, one can often prove that a group is a Galois group over the
## rationals using calculations with structure constants that can be
## computed from the character table,
## and information about (the character tables of) maximal subgroups.
## When one deals with such questions,
## the translation back to groups is just an interpretation by the user,
## it does not take place in &GAP;.
## 
## &GAP; uses character <E>tables</E> to store information such as class
## lengths, element orders, the irreducible characters of <M>G</M>
## etc. in a consistent way;
## in the example above, we have seen that
## <Ref Attr="SizesConjugacyClasses"/> returns
## the list of class lengths of its argument.
## Note that the values of these attributes rely on the chosen ordering
## of conjugacy classes,
## a character table is not determined by something similar to generators
## of groups or rings in &GAP; where knowledge could in principle be
## recovered from the generators but is stored mainly for the sake of
## efficiency.
## 
## Note that the character table of a group <M>G</M> in &GAP; must
## <E>not</E> be mixed up with the list of complex irreducible characters
## of <M>G</M>.
## The irreducible characters are stored in a character table via the
## attribute <Ref Attr="Irr" Label="for a group"/>.
## 
## Two further important instances of information that depends on the
## ordering of conjugacy classes are <E>power maps</E> and
## <E>fusion maps</E>.
## Both are represented as lists of integers in &GAP;.
## The <M>k</M>-th power map maps each class to the class of <M>k</M>-th
## powers of its elements, the corresponding list contains at each position
## the position of the image.
## A class fusion map between the classes of a subgroup <M>H</M> of <M>G</M>
## and the classes of <M>G</M> maps each class <M>c</M> of <M>H</M> to that
## class of <M>G</M> that contains <M>c</M>, the corresponding list contains
## again the positions of image classes;
## if we know only the character tables of <M>H</M> and <M>G</M> but not the
## groups themselves,
## this means with respect to a fixed embedding of <M>H</M> into <M>G</M>.
## More about power maps and fusion maps can be found in
## Chapter <Ref Chap="Maps Concerning Character Tables"/>.
## 
## So class functions, power maps, and fusion maps are represented by lists
## in &GAP;.
## If they are plain lists then they are regarded as class functions
## etc. of an appropriate character table when they are passed to &GAP;
## functions that expect class functions etc.
## For example, a list with all entries equal to 1 is regarded as the
## trivial character if it is passed to a function that expects a character.
## Note that this approach requires the character table as an argument for
## such a function.
## 
## One can construct class function objects that store their underlying
## character table and other attribute values
## (see Chapter <Ref Chap="Class Functions"/>).
## This allows one to omit the character table argument in many functions,
## and it allows one to use infix operations for tensoring or inducing
## class functions.
## <#/GAPDoc>
##

#############################################################################
##
## 2. Character Table Categories
##

#############################################################################
##
#V InfoCharacterTable
##
## <#GAPDoc Label="InfoCharacterTable">
## <ManSection>
## <InfoClass Name="InfoCharacterTable"/>
##
## <Description>
## is the info class (see <Ref Sect="Info Functions"/>) for
## computations with character tables.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareInfoClass( "InfoCharacterTable" );

#############################################################################
##
#C IsNearlyCharacterTable( <obj> )
#C IsCharacterTable( <obj> )
#C IsOrdinaryTable( <obj> )
#C IsBrauerTable( <obj> )
#C IsCharacterTableInProgress( <obj> )
##
## <#GAPDoc Label="IsNearlyCharacterTable">
## <ManSection>
## <Filt Name="IsNearlyCharacterTable" Arg='obj' Type='Category'/>
## <Filt Name="IsCharacterTable" Arg='obj' Type='Category'/>
## <Filt Name="IsOrdinaryTable" Arg='obj' Type='Category'/>
## <Filt Name="IsBrauerTable" Arg='obj' Type='Category'/>
## <Filt Name="IsCharacterTableInProgress" Arg='obj' Type='Category'/>
##
## <Description>
## Every <Q>character table like object</Q> in &GAP; lies in the category
## <Ref Filt="IsNearlyCharacterTable"/>.
## There are four important subcategories,
## namely the <E>ordinary</E> tables in <Ref Filt="IsOrdinaryTable"/>,
## the <E>Brauer</E> tables in <Ref Filt="IsBrauerTable"/>,
## the union of these two in <Ref Filt="IsCharacterTable"/>,
## and the <E>incomplete ordinary</E> tables in
## <Ref Filt="IsCharacterTableInProgress"/>.
## 
## We want to distinguish ordinary and Brauer tables because a Brauer table
## may delegate tasks to the ordinary table of the same group,
## for example the computation of power maps.
## A Brauer table is constructed from an ordinary table and stores this
## table upon construction
## (see <Ref Attr="OrdinaryCharacterTable" Label="for a group"/>).
## 
## Furthermore, <Ref Filt="IsOrdinaryTable"/> and
## <Ref Filt="IsBrauerTable"/> denote character tables that provide enough
## information to compute all power maps and irreducible characters (and in
## the case of Brauer tables to get the ordinary table), for example because
## the underlying group
## (see <Ref Attr="UnderlyingGroup" Label="for character tables"/>) is
## known or because the table is a library table
## (see the manual of the &GAP; Character Table Library).
## We want to distinguish these tables from partially known ordinary tables
## that cannot be asked for all power maps or all irreducible characters.
## 
## The character table objects in <Ref Filt="IsCharacterTable"/> are always
## immutable (see <Ref Sect="Mutability and Copyability"/>).
## This means mainly that the ordering of conjugacy classes used for the
## various attributes of the character table cannot be changed;
## see <Ref Sect="Sorted Character Tables"/> for how to compute a
## character table with a different ordering of classes.
## 
## The &GAP; objects in <Ref Filt="IsCharacterTableInProgress"/> represent
## incomplete ordinary character tables.
## This means that not all irreducible characters, not all power maps are
## known, and perhaps even the number of classes and the centralizer orders
## are known.
## Such tables occur when the character table of a group <M>G</M> is
## constructed using character tables of related groups and information
## about <M>G</M> but for example without explicitly computing the conjugacy
## classes of <M>G</M>.
## An object in <Ref Filt="IsCharacterTableInProgress"/> is first of all
## <E>mutable</E>,
## so <E>nothing is stored automatically</E> on such a table,
## since otherwise one has no control of side-effects when
## a hypothesis is changed.
## Operations for such tables may return more general values than for
## other tables, for example class functions may contain unknowns
## (see Chapter <Ref Chap="Unknowns"/>) or lists of possible values in
## certain positions,
## the same may happen also for power maps and class fusions
## (see <Ref Sect="Parametrized Maps"/>).
## <E>Incomplete tables in this sense are currently not supported and will be
## described in a chapter of their own when they become available.</E>
## Note that the term <Q>incomplete table</Q> shall express that &GAP; cannot
## compute certain values such as irreducible characters or power maps.
## A table with access to its group is therefore always complete,
## also if its irreducible characters are not yet stored.
## 
## <Example><![CDATA[
## gap> g:= SymmetricGroup( 4 );;
## gap> tbl:= CharacterTable( g ); modtbl:= tbl mod 2;
## CharacterTable( Sym( [ 1 .. 4 ] ) )
## BrauerTable( Sym( [ 1 .. 4 ] ), 2 )
## gap> IsCharacterTable( tbl ); IsCharacterTable( modtbl );
## true
## true
## gap> IsBrauerTable( modtbl ); IsBrauerTable( tbl );
## true
## false
## gap> IsOrdinaryTable( tbl ); IsOrdinaryTable( modtbl );
## true
## false
## gap> IsCharacterTable( g ); IsCharacterTable( Irr( g ) );
## false
## false
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareCategory( "IsNearlyCharacterTable", IsObject, 20 );
DeclareCategory( "IsCharacterTable", IsNearlyCharacterTable );
DeclareCategory( "IsOrdinaryTable", IsCharacterTable );
DeclareCategory( "IsBrauerTable", IsCharacterTable );
DeclareCategory( "IsCharacterTableInProgress", IsNearlyCharacterTable );

#############################################################################
##
#V NearlyCharacterTablesFamily
##
## <#GAPDoc Label="NearlyCharacterTablesFamily">
## <ManSection>
## <Fam Name="NearlyCharacterTablesFamily"/>
##
## <Description>
## Every character table like object lies in this family
## (see <Ref Sect="Families"/>).
## </Description>
## </ManSection>
## <#/GAPDoc>
##
BindGlobal( "NearlyCharacterTablesFamily",
 NewFamily( "NearlyCharacterTablesFamily", IsNearlyCharacterTable ) );

#############################################################################
##
#V SupportedCharacterTableInfo
##
## <#GAPDoc Label="SupportedCharacterTableInfo">
## <ManSection>
## <Var Name="SupportedCharacterTableInfo"/>
##
## <Description>
## <Ref Var="SupportedCharacterTableInfo"/> is a list that contains
## at position <M>3i-2</M> an attribute getter function,
## at position <M>3i-1</M> the name of this attribute,
## and at position <M>3i</M> a list containing a subset of
## <C>[ "character", "class", "mutable" ]</C>,
## depending on whether the attribute value relies on the ordering of
## characters or classes, or whether the attribute value is a mutable
## list or record.
## 
## When (ordinary or Brauer) character table objects are created from
## records, using <Ref Func="ConvertToCharacterTable"/>,
## <Ref Var="SupportedCharacterTableInfo"/> specifies those
## record components that shall be used as attribute values;
## other record components are <E>not</E> be regarded as attribute
## values in the conversion process.
## 
## New attributes and properties can be notified to
## <Ref Var="SupportedCharacterTableInfo"/> by creating them with
## <C>DeclareAttributeSuppCT</C> and <C>DeclarePropertySuppCT</C> instead of
## <Ref Func="DeclareAttribute"/> and
## <Ref Func="DeclareProperty"/>.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
BindGlobal( "SupportedCharacterTableInfo", [] );

#############################################################################
##
#F DeclareAttributeSuppCT( <name>, <filter>[, "mutable"], <depend> )
#F DeclarePropertySuppCT( <name>, <filter> )
##
## <ManSection>
## <Func Name="DeclareAttributeSuppCT"
## Arg='name, filter[, "mutable"], depend'/>
## <Func Name="DeclarePropertySuppCT" Arg='name, filter'/>
##
## <Description>
## do the same as <Ref Func="DeclareAttribute"/> and
## <Ref Func="DeclareProperty"/>,
## except that the list <Ref Var="SupportedOrdinaryTableInfo"/> is extended
## by an entry corresponding to the attribute.
## </Description>
## </ManSection>
##
BindGlobal( "DeclareAttributeSuppCT", function( name, filter, arg... )
 local mutflag, depend;

 # Check the arguments.
 if not ( IsString( name ) and IsFilter( filter ) ) then
 Error( "<name> must be a string, <filter> must be a filter" );
 elif Length( arg ) = 1 and IsList( arg[1] ) then
 mutflag:= false;
 depend:= arg[1];
 elif Length( arg ) = 2 and arg[1] = "mutable" and IsList( arg[2] ) then
 mutflag:= true;
 depend:= arg[2];
 else
 Error( "usage: DeclareAttributeSuppCT( <name>,\n",
 " <filter>[, \"mutable\"], <depend> )" );
 fi;
 if not ForAll( depend, str -> str in [ "class", "character" ] ) then
 Error( "<depend> must contain only \"class\", \"character\"" );
 fi;

 # Create/change the attribute as `DeclareAttribute' does.
 if mutflag then
 DeclareAttribute( name, filter, "mutable" );
 depend:= Concatenation( depend, [ "mutable" ] );
 else
 DeclareAttribute( name, filter );
 fi;

 # Do the additional magic.
 Append( SupportedCharacterTableInfo,
 [ ValueGlobal( name ), name, depend ] );
end );

BindGlobal( "DeclarePropertySuppCT", function( name, filter )
 # Check the arguments.
 if not ( IsString( name ) and IsFilter( filter ) ) then
 Error( "<name> must be a string, <filter> must be a filter" );
 fi;

 # Create/change the property as `DeclareProperty' does.
 DeclareProperty( name, filter );

 # Do the additional magic.
 Append( SupportedCharacterTableInfo, [ ValueGlobal( name ), name, [] ] );
end );

#############################################################################
##
## 3. The Interface between Character Tables and Groups
##
## <#GAPDoc Label="[2]{ctbl}">
## For a character table with underlying group
## (see <Ref Attr="UnderlyingGroup" Label="for character tables"/>),
## the interface between table and group consists of three attribute values,
## namely the <E>group</E>, the <E>conjugacy classes</E> stored in the table
## (see <Ref Attr="ConjugacyClasses" Label="for character tables"/> below)
## and the <E>identification</E> of the conjugacy classes of table and group
## (see <Ref Attr="IdentificationOfConjugacyClasses"/> below).
## 
## Character tables constructed from groups know these values upon
## construction,
## and for character tables constructed without groups, these values are
## usually not known and cannot be computed from the table.
## 
## However, given a group <M>G</M> and a character table of a group
## isomorphic to <M>G</M> (for example a character table from the
## &GAP; table library),
## one can tell &GAP; to compute a new instance of the given table and to
## use it as the character table of <M>G</M>
## (see <Ref Func="CharacterTableWithStoredGroup"/>).
## 
## Tasks may be delegated from a group to its character table or vice versa
## only if these three attribute values are stored in the character table.
## <#/GAPDoc>
##

#############################################################################
##
#A UnderlyingGroup( <ordtbl> )
##
## <#GAPDoc Label="UnderlyingGroup:ctbl">
## <ManSection>
## <Attr Name="UnderlyingGroup" Arg='ordtbl' Label="for character tables"/>
##
## <Description>
## For an ordinary character table <A>ordtbl</A> of a finite group,
## the group can be stored as value of
## <Ref Attr="UnderlyingGroup" Label="for character tables"/>.
## 
## Brauer tables do not store the underlying group,
## they access it via the ordinary table
## (see <Ref Attr="OrdinaryCharacterTable" Label="for a character table"/>).
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttributeSuppCT( "UnderlyingGroup", IsOrdinaryTable, [] );

#############################################################################
##
#A ConjugacyClasses( <tbl> )
##
## <#GAPDoc Label="ConjugacyClasses:ctbl">
## <ManSection>
## <Attr Name="ConjugacyClasses" Arg='tbl' Label="for character tables"/>
##
## <Description>
## For a character table <A>tbl</A> with known underlying group <M>G</M>,
## the <Ref Attr="ConjugacyClasses" Label="for character tables"/> value of
## <A>tbl</A> is a list of conjugacy classes of <M>G</M>.
## All those lists stored in the table that are related to the ordering
## of conjugacy classes (such as sizes of centralizers and conjugacy
## classes, orders of representatives, power maps, and all class functions)
## refer to the ordering of this list.
## 
## This ordering need <E>not</E> coincide with the ordering of conjugacy
## classes as stored in the underlying group of the table
## (see <Ref Sect="Sorted Character Tables"/>).
## One reason for this is that otherwise we would not be allowed to
## use a library table as the character table of a group for which the
## conjugacy classes are stored already.
## (Another, less important reason is that we can use the same group as
## underlying group of character tables that differ only w.r.t. the
## ordering of classes.)
## 
## The class of the identity element must be the first class
## (see <Ref Sect="Conventions for Character Tables"/>).
## 
## If <A>tbl</A> was constructed from <M>G</M> then the conjugacy classes
## have been stored at the same time when <M>G</M> was stored.
## If <M>G</M> and <A>tbl</A> have been connected later than in the
## construction of <A>tbl</A>, the recommended way to do this is via
## <Ref Func="CharacterTableWithStoredGroup"/>.
## So there is no method for
## <Ref Attr="ConjugacyClasses" Label="for character tables"/> that computes
## the value for <A>tbl</A> if it is not yet stored.
## 
## Brauer tables do not store the (<M>p</M>-regular) conjugacy classes,
## they access them via the ordinary table
## (see <Ref Attr="OrdinaryCharacterTable" Label="for a character table"/>)
## if necessary.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttributeSuppCT( "ConjugacyClasses", IsOrdinaryTable, [ "class" ] );

#############################################################################
##
#A IdentificationOfConjugacyClasses( <tbl> )
##
## <#GAPDoc Label="IdentificationOfConjugacyClasses">
## <ManSection>
## <Attr Name="IdentificationOfConjugacyClasses" Arg='tbl'/>
##
## <Description>
## For an ordinary character table <A>tbl</A> with known underlying group
## <M>G</M>, <Ref Attr="IdentificationOfConjugacyClasses"/> returns a list
## of positive integers that contains at position <M>i</M> the position of
## the <M>i</M>-th conjugacy class of <A>tbl</A> in the
## <Ref Attr="ConjugacyClasses" Label="for character tables"/> value of
## <M>G</M>.
## 
## <Example><![CDATA[
## gap> g:= SymmetricGroup( 4 );;
## gap> repres:= [ (1,2), (1,2,3), (1,2,3,4), (1,2)(3,4), () ];;
## gap> ccl:= List( repres, x -> ConjugacyClass( g, x ) );;
## gap> SetConjugacyClasses( g, ccl );
## gap> tbl:= CharacterTable( g );; # the table stores already the values
## gap> HasConjugacyClasses( tbl ); HasUnderlyingGroup( tbl );
## true
## true
## gap> UnderlyingGroup( tbl ) = g;
## true
## gap> HasIdentificationOfConjugacyClasses( tbl );
## true
## gap> IdentificationOfConjugacyClasses( tbl );
## [ 5, 1, 2, 3, 4 ]
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttributeSuppCT( "IdentificationOfConjugacyClasses", IsOrdinaryTable,
 [ "class" ] );

#############################################################################
##
#F CharacterTableWithStoredGroup( <G>, <tbl>[, <info>] )
##
## <#GAPDoc Label="CharacterTableWithStoredGroup">
## <ManSection>
## <Func Name="CharacterTableWithStoredGroup" Arg='G, tbl[, info]'/>
##
## <Description>
## Let <A>G</A> be a group and <A>tbl</A> a character table of (a group
## isomorphic to) <A>G</A>, such that <A>G</A> does not store its
## <Ref Attr="OrdinaryCharacterTable" Label="for a group"/> value.
## <Ref Func="CharacterTableWithStoredGroup"/> calls
## <Ref Oper="CompatibleConjugacyClasses"/>,
## trying to identify the classes of <A>G</A> with the columns of
## <A>tbl</A>.
## 
## If this identification is unique up to automorphisms of <A>tbl</A>
## (see <Ref Attr="AutomorphismsOfTable"/>) then <A>tbl</A> is stored
## as <Ref Oper="CharacterTable" Label="for a group"/> value of <A>G</A>,
## and a new character table is returned that is equivalent to <A>tbl</A>,
## is sorted in the same way as <A>tbl</A>, and has the values of
## <Ref Attr="UnderlyingGroup" Label="for character tables"/>,
## <Ref Attr="ConjugacyClasses" Label="for character tables"/>, and
## <Ref Attr="IdentificationOfConjugacyClasses"/> set.
## 
## Otherwise, i.e., if &GAP; cannot identify the classes of <A>G</A> up to
## automorphisms of <A>tbl</A>, <K>fail</K> is returned.
## 
## If a record is present as the third argument <A>info</A>,
## its meaning is the same as the optional argument <A>arec</A> for
## <Ref Oper="CompatibleConjugacyClasses"/>.
## 
## If a list is entered as third argument <A>info</A>
## it is used as value of <Ref Attr="IdentificationOfConjugacyClasses"/>,
## relative to the
## <Ref Attr="ConjugacyClasses" Label="for character tables"/>
## value of <A>G</A>, without further checking,
## and the corresponding character table is returned.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareGlobalFunction( "CharacterTableWithStoredGroup" );

#############################################################################
##
#O CompatibleConjugacyClasses( [<G>, <ccl>, ]<tbl>[, <arec>] )
##
## <#GAPDoc Label="CompatibleConjugacyClasses">
## <ManSection>
## <Oper Name="CompatibleConjugacyClasses" Arg='[G, ccl, ]tbl[, arec]'/>
##
## <Description>
## If the arguments <A>G</A> and <A>ccl</A> are present then <A>ccl</A> must
## be a list of the conjugacy classes of the group <A>G</A>,
## and <A>tbl</A> the ordinary character table of <A>G</A>.
## Then <Ref Oper="CompatibleConjugacyClasses"/> returns a list <M>l</M> of
## positive integers that describes an identification of the columns of
## <A>tbl</A> with the conjugacy classes <A>ccl</A> in the sense that
## <M>l[i]</M> is the position in <A>ccl</A> of the class corresponding to
## the <M>i</M>-th column of <A>tbl</A>, if this identification is unique up
## to automorphisms of <A>tbl</A>
## (see <Ref Attr="AutomorphismsOfTable"/>);
## if &GAP; cannot identify the classes, <K>fail</K> is returned.
## 
## If <A>tbl</A> is the first argument then it must be an ordinary character
## table, and <Ref Oper="CompatibleConjugacyClasses"/> checks whether the
## columns of <A>tbl</A> can be identified with the conjugacy classes of
## a group isomorphic to that for which <A>tbl</A> is the character table;
## the return value is a list of all those sets of class positions for which
## the columns of <A>tbl</A> cannot be distinguished with the invariants
## used, up to automorphisms of <A>tbl</A>.
## So the identification is unique if and only if the returned list is
## empty.
## 
## The usual approach is that one first calls
## <Ref Oper="CompatibleConjugacyClasses"/>
## in the second form for checking quickly whether the first form will be
## successful, and only if this is the case the more time consuming
## calculations with both group and character table are done.
## 
## The following invariants are used.
## <Enum>
## <Item>
## element orders (see <Ref Attr="OrdersClassRepresentatives"/>),
## </Item>
## <Item>
## class lengths (see <Ref Attr="SizesConjugacyClasses"/>),
## </Item>
## <Item>
## power maps (see <Ref Oper="PowerMap"/>,
## <Ref Attr="ComputedPowerMaps"/>),
## </Item>
## <Item>
## symmetries of the table (see <Ref Attr="AutomorphismsOfTable"/>).
## </Item>
## </Enum>
## 
## If the optional argument <A>arec</A> is present then it must be a record
## whose components describe additional information for the class
## identification.
## The following components are supported.
## <List>
## <C>natchar</C> 
## <Item>
## if <M>G</M> is a permutation group or matrix group then the value of
## this component is regarded as the list of values of the natural
## character (see <Ref Attr="NaturalCharacter" Label="for a group"/>)
## of <A>G</A>, w.r.t. the ordering of classes in <A>tbl</A>,
## </Item>
## <C>bijection</C> 
## <Item>
## a list describing a partial bijection; the <M>i</M>-th entry, if bound,
## is the position of the <M>i</M>-th conjugacy class of <A>tbl</A> in the
## list <A>ccl</A>.
## </Item>
## </List>
## 
## <Example><![CDATA[
## gap> g:= AlternatingGroup( 5 );
## Alt( [ 1 .. 5 ] )
## gap> tbl:= CharacterTable( "A5" );
## CharacterTable( "A5" )
## gap> HasUnderlyingGroup( tbl ); HasOrdinaryCharacterTable( g );
## false
## false
## gap> CompatibleConjugacyClasses( tbl ); # unique identification
## [ ]
## gap> new:= CharacterTableWithStoredGroup( g, tbl );
## CharacterTable( Alt( [ 1 .. 5 ] ) )
## gap> Irr( new ) = Irr( tbl );
## true
## gap> HasConjugacyClasses( new ); HasUnderlyingGroup( new );
## true
## true
## gap> IdentificationOfConjugacyClasses( new );
## [ 1, 2, 3, 4, 5 ]
## gap> # Here is an example where the identification is not unique.
## gap> CompatibleConjugacyClasses( CharacterTable( "J2" ) );
## [ [ 17, 18 ], [ 9, 10 ] ]
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareOperation( "CompatibleConjugacyClasses",
 [ IsGroup, IsList, IsOrdinaryTable ] );
DeclareOperation( "CompatibleConjugacyClasses",
 [ IsGroup, IsList, IsOrdinaryTable, IsRecord ] );
DeclareOperation( "CompatibleConjugacyClasses", [ IsOrdinaryTable ] );
DeclareOperation( "CompatibleConjugacyClasses",
 [ IsOrdinaryTable, IsRecord ] );

#############################################################################
##
#F CompatibleConjugacyClassesDefault( <G>, <ccl>, <tbl>, <arec> )
#F CompatibleConjugacyClassesDefault( false, false, <tbl>, <arec> )
##
## <ManSection>
## <Func Name="CompatibleConjugacyClassesDefault" Arg='G, ccl, tbl, arec'/>
## <Func Name="CompatibleConjugacyClassesDefault"
## Arg='false, false, tbl, arec'/>
##
## <Description>
## This is installed as a method for
## <Ref Func="CompatibleConjugacyClasses"/>.
## It uses the following invariants.
## Element orders, class lengths, cosets of the derived subgroup,
## power maps of prime divisors of the group order, automorphisms of
## <A>tbl</A>.
## </Description>
## </ManSection>
##
DeclareGlobalFunction( "CompatibleConjugacyClassesDefault" );

#############################################################################
##
## 4. Operators for Character Tables
##
## <#GAPDoc Label="[3]{ctbl}">
## <Index Key="*" Subkey="for character tables"><C>*</C></Index>
## <Index Key="/" Subkey="for character tables"><C>/</C></Index>
## <Index Key="mod" Subkey="for character tables"><K>mod</K></Index>
## <Index Subkey="infix operators">character tables</Index>
## The following infix operators are defined for character tables.
## <List>
## <C><A>tbl1</A> * <A>tbl2</A></C>
## <Item>
## the direct product of two character tables
## (see <Ref Oper="CharacterTableDirectProduct"/>),
## </Item>
## <C><A>tbl</A> / <A>list</A></C>
## <Item>
## the table of the factor group modulo the normal subgroup spanned by
## the classes in the list <A>list</A>
## (see <Ref Oper="CharacterTableFactorGroup"/>),
## </Item>
## <C><A>tbl</A> mod <A>p</A></C>
## <Item>
## the <A>p</A>-modular Brauer character table corresponding to
## the ordinary character table <A>tbl</A>
## (see <Ref Oper="BrauerTable"
## Label="for a character table, and a prime integer"/>),
## </Item>
## <C><A>tbl</A>.<A>name</A></C>
## <Item>
## the position of the class with name <A>name</A> in <A>tbl</A>
## (see <Ref Attr="ClassNames"/>).
## </Item>
## </List>
## <#/GAPDoc>
##

#############################################################################
##
## 5. Attributes and Properties for Groups as well as for Character Tables
##
## <#GAPDoc Label="[4]{ctbl}">
## Several <E>attributes for groups</E> are valid also for character tables.
## 
## These are first those that have the same meaning for both
## the group and its character table,
## and whose values can be read off or computed, respectively,
## from the character table,
## such as <Ref Attr="Size" Label="for a character table"/>,
## <Ref Prop="IsAbelian" Label="for a character table"/>,
## or <Ref Prop="IsSolvable" Label="for a character table"/>.
## 
## Second, there are attributes whose meaning for character
## tables is different from the meaning for groups, such as
## <Ref Attr="ConjugacyClasses" Label="for character tables"/>.
## <#/GAPDoc>
##

#############################################################################
##
#A CharacterDegrees( <G>[, ] )
#A CharacterDegrees( <tbl> )
##
## <#GAPDoc Label="CharacterDegrees">
## <ManSection>
## <Heading>CharacterDegrees</Heading>
## <Attr Name="CharacterDegrees" Arg='G[, p]' Label="for a group"/>
## <Attr Name="CharacterDegrees" Arg='tbl' Label="for a character table"/>
##
## <Description>
## In the first form, <Ref Attr="CharacterDegrees" Label="for a group"/>
## returns a collected list of the degrees of the absolutely irreducible
## characters of the group <A>G</A>;
## the optional second argument <A>p</A> must be either zero or a prime
## integer denoting the characteristic, the default value is zero.
## In the second form, <A>tbl</A> must be an (ordinary or Brauer) character
## table, and <Ref Attr="CharacterDegrees" Label="for a character table"/>
## returns a collected list of the degrees of the absolutely irreducible
## characters of <A>tbl</A>.
## 
## (The default method for the call with only argument a group is to call
## the operation with second argument <C>0</C>.)
## 
## For solvable groups,
## the default method is based on <Cite Key="Con90b"/>.
## 
## <Example><![CDATA[
## gap> CharacterDegrees( SymmetricGroup( 4 ) );
## [ [ 1, 2 ], [ 2, 1 ], [ 3, 2 ] ]
## gap> CharacterDegrees( SymmetricGroup( 4 ), 2 );
## [ [ 1, 1 ], [ 2, 1 ] ]
## gap> CharacterDegrees( CharacterTable( "A5" ) );
## [ [ 1, 1 ], [ 3, 2 ], [ 4, 1 ], [ 5, 1 ] ]
## gap> CharacterDegrees( CharacterTable( "A5" ) mod 2 );
## [ [ 1, 1 ], [ 2, 2 ], [ 4, 1 ] ]
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "CharacterDegrees", IsGroup );
DeclareOperation( "CharacterDegrees", [ IsGroup, IsInt ] );
DeclareAttributeSuppCT( "CharacterDegrees", IsNearlyCharacterTable, [] );

InstallIsomorphismMaintenance( CharacterDegrees,
 IsGroup and HasCharacterDegrees, IsGroup );

#############################################################################
##
#A Irr( <G>[, ] )
#A Irr( <tbl> )
##
## <#GAPDoc Label="Irr">
## <ManSection>
## <Heading>Irr</Heading>
## <Attr Name="Irr" Arg='G[, p]' Label="for a group"/>
## <Attr Name="Irr" Arg='tbl' Label="for a character table"/>
##
## <Description>
## Called with a group <A>G</A>, <Ref Attr="Irr" Label="for a group"/>
## returns the irreducible characters of the ordinary character table of
## <A>G</A>.
## Called with a group <A>G</A> and a prime integer <A>p</A>,
## <Ref Attr="Irr" Label="for a group"/> returns the irreducible characters
## of the <A>p</A>-modular Brauer table of <A>G</A>.
## Called with an (ordinary or Brauer) character table <A>tbl</A>,
## <Ref Attr="Irr" Label="for a group"/> returns the list of all
## complex absolutely irreducible characters of <A>tbl</A>.
## 
## For a character table <A>tbl</A> with underlying group,
## <Ref Attr="Irr" Label="for a character table"/> may delegate to the group.
## For a group <A>G</A>, <Ref Attr="Irr" Label="for a group"/> may delegate
## to its character table only if the irreducibles are already stored there.
## 
## (If <A>G</A> is <A>p</A>-solvable (see <Ref Oper="IsPSolvable"/>)
## then the <A>p</A>-modular irreducible characters can be computed by the
## Fong-Swan Theorem; in all other cases, there may be no method.)
## 
## Note that the ordering of columns in the
## <Ref Attr="Irr" Label="for a group"/> matrix of the
## group <A>G</A> refers to the ordering of conjugacy classes in the
## <Ref Oper="CharacterTable" Label="for a group"/> value of <A>G</A>,
## which may differ from the ordering of conjugacy classes in <A>G</A>
## (see <Ref Sect="The Interface between Character Tables and Groups"/>).
## As an extreme example, for a character table obtained from sorting the
## classes of the <Ref Oper="CharacterTable" Label="for a group"/>
## value of <A>G</A>,
## the ordering of columns in the <Ref Attr="Irr" Label="for a group"/>
## matrix respects the
## sorting of classes (see <Ref Sect="Sorted Character Tables"/>),
## so the irreducibles of such a table will in general not coincide with
## the irreducibles stored as the <Ref Attr="Irr" Label="for a group"/>
## value of <A>G</A> although also the sorted table stores the group
## <A>G</A>.
## 
## The ordering of the entries in the attribute
## <Ref Attr="Irr" Label="for a group"/> of a group
## need <E>not</E> coincide with the ordering of its
## <Ref Attr="IrreducibleRepresentations"/> value.
## 
## <Example><![CDATA[
## gap> Irr( SymmetricGroup( 4 ) );
## [ Character( CharacterTable( Sym( [ 1 .. 4 ] ) ), [ 1, -1, 1, 1, -1
## ] ), Character( CharacterTable( Sym( [ 1 .. 4 ] ) ),
## [ 3, -1, -1, 0, 1 ] ),
## Character( CharacterTable( Sym( [ 1 .. 4 ] ) ), [ 2, 0, 2, -1, 0 ] )
## , Character( CharacterTable( Sym( [ 1 .. 4 ] ) ),
## [ 3, 1, -1, 0, -1 ] ),
## Character( CharacterTable( Sym( [ 1 .. 4 ] ) ), [ 1, 1, 1, 1, 1 ] )
## ]
## gap> Irr( SymmetricGroup( 4 ), 2 );
## [ Character( BrauerTable( Sym( [ 1 .. 4 ] ), 2 ), [ 1, 1 ] ),
## Character( BrauerTable( Sym( [ 1 .. 4 ] ), 2 ), [ 2, -1 ] ) ]
## gap> Irr( CharacterTable( "A5" ) );
## [ Character( CharacterTable( "A5" ), [ 1, 1, 1, 1, 1 ] ),
## Character( CharacterTable( "A5" ),
## [ 3, -1, 0, -E(5)-E(5)^4, -E(5)^2-E(5)^3 ] ),
## Character( CharacterTable( "A5" ),
## [ 3, -1, 0, -E(5)^2-E(5)^3, -E(5)-E(5)^4 ] ),
## Character( CharacterTable( "A5" ), [ 4, 0, 1, -1, -1 ] ),
## Character( CharacterTable( "A5" ), [ 5, 1, -1, 0, 0 ] ) ]
## gap> Irr( CharacterTable( "A5" ) mod 2 );
## [ Character( BrauerTable( "A5", 2 ), [ 1, 1, 1, 1 ] ),
## Character( BrauerTable( "A5", 2 ),
## [ 2, -1, E(5)+E(5)^4, E(5)^2+E(5)^3 ] ),
## Character( BrauerTable( "A5", 2 ),
## [ 2, -1, E(5)^2+E(5)^3, E(5)+E(5)^4 ] ),
## Character( BrauerTable( "A5", 2 ), [ 4, 1, -1, -1 ] ) ]
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "Irr", IsGroup );
DeclareOperation( "Irr", [ IsGroup, IsInt ] );
DeclareAttributeSuppCT( "Irr", IsNearlyCharacterTable,
 [ "character", "class" ] );

#############################################################################
##
#A LinearCharacters( <G>[, ] )
#A LinearCharacters( <tbl> )
##
## <#GAPDoc Label="LinearCharacters">
## <ManSection>
## <Heading>LinearCharacters</Heading>
## <Attr Name="LinearCharacters" Arg='G[, p]' Label="for a group"/>
## <Attr Name="LinearCharacters" Arg='tbl' Label="for a character table"/>
##
## <Description>
## <Ref Attr="LinearCharacters" Label="for a group"/> returns the linear
## (i.e., degree <M>1</M>) characters in the
## <Ref Attr="Irr" Label="for a group"/> list of the group
## <A>G</A> or the character table <A>tbl</A>, respectively.
## In the second form,
## <Ref Attr="LinearCharacters" Label="for a character table"/> returns the
## <A>p</A>-modular linear characters of the group <A>G</A>.
## 
## For a character table <A>tbl</A> with underlying group,
## <Ref Attr="LinearCharacters" Label="for a character table"/> may delegate
## to the group.
## For a group <A>G</A>, <Ref Attr="LinearCharacters" Label="for a group"/>
## may delegate to its character table only if the irreducibles
## are already stored there.
## 
## The ordering of linear characters in <A>tbl</A> need not coincide with the
## ordering of linear characters in the irreducibles of <A>tbl</A>
## (see <Ref Attr="Irr" Label="for a character table"/>).
## 
## <Example><![CDATA[
## gap> LinearCharacters( SymmetricGroup( 4 ) );
## [ Character( CharacterTable( Sym( [ 1 .. 4 ] ) ), [ 1, 1, 1, 1, 1 ] ),
## Character( CharacterTable( Sym( [ 1 .. 4 ] ) ), [ 1, -1, 1, 1, -1
## ] ) ]
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "LinearCharacters", IsGroup );
DeclareOperation( "LinearCharacters", [ IsGroup, IsInt ] );
DeclareAttributeSuppCT( "LinearCharacters", IsNearlyCharacterTable,
 [ "class" ] );

#############################################################################
##
#A IBr( <modtbl> )
#O IBr( <G>, )
##
## <ManSection>
## <Heading>IBr</Heading>
## <Attr Name="IBr" Arg='modtbl' Label="for a character table"/>
## <Oper Name="IBr" Arg='G, p' Label="for a group, and a prime integer"/>
##
## <Description>
## For a Brauer table <A>modtbl</A> or a group <A>G</A> and a prime integer
## <A>p</A>, <Ref Oper="IBr" Label="for a character table"/> delegates to
## <Ref Attr="Irr" Label="for a character table"/>.
## 
## </Description>
## </ManSection>
##
DeclareAttribute( "IBr", IsBrauerTable );
DeclareOperation( "IBr", [ IsGroup, IsPosInt ] );

#############################################################################
##
#A OrdinaryCharacterTable( <G> ) . . . . . . . . . . . . . . . . for a group
#A OrdinaryCharacterTable( <modtbl> ) . . . . for a Brauer character table
##
## <#GAPDoc Label="OrdinaryCharacterTable">
## <ManSection>
## <Heading>OrdinaryCharacterTable</Heading>
## <Attr Name="OrdinaryCharacterTable" Arg='G' Label="for a group"/>
## <Attr Name="OrdinaryCharacterTable" Arg='modtbl'
## Label="for a character table"/>
##
## <Description>
## <Ref Attr="OrdinaryCharacterTable" Label="for a group"/> returns the
## ordinary character table of the group <A>G</A>
## or the Brauer character table <A>modtbl</A>, respectively.
## 
## Since Brauer character tables are constructed from ordinary tables,
## the attribute value for <A>modtbl</A> is already stored
## (cf. <Ref Sect="Character Table Categories"/>).
## 
## <Example><![CDATA[
## gap> OrdinaryCharacterTable( SymmetricGroup( 4 ) );
## CharacterTable( Sym( [ 1 .. 4 ] ) )
## gap> tbl:= CharacterTable( "A5" );; modtbl:= tbl mod 2;
## BrauerTable( "A5", 2 )
## gap> OrdinaryCharacterTable( modtbl ) = tbl;
## true
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttributeSuppCT( "OrdinaryCharacterTable", IsGroup, [] );

#############################################################################
##
#A AbelianInvariants( <tbl> )
#A CommutatorLength( <tbl> )
#A Exponent( <tbl> )
#P IsAbelian( <tbl> )
#P IsAlmostSimple( <tbl> )
#P IsCyclic( <tbl> )
#P IsElementaryAbelian( <tbl> )
#P IsFinite( <tbl> )
#P IsMonomial( <tbl> )
#P IsNilpotent( <tbl> )
#P IsPerfect( <tbl> )
#P IsQuasisimple( <tbl> )
#P IsSimple( <tbl> )
#P IsSporadicSimple( <tbl> )
#P IsSupersolvable( <tbl> )
#A IsomorphismTypeInfoFiniteSimpleGroup( <tbl> )
#A NrConjugacyClasses( <tbl> )
#A Size( <tbl> )
##
## <#GAPDoc Label="[5]{ctbl}">
## <ManSection>
## <Heading>Group Operations Applicable to Character Tables</Heading>
## <Attr Name="AbelianInvariants" Arg='tbl' Label="for a character table"/>
## <Attr Name="CommutatorLength" Arg='tbl' Label="for a character table"/>
## <Attr Name="Exponent" Arg='tbl' Label="for a character table"/>
## <Prop Name="IsAbelian" Arg='tbl' Label="for a character table"/>
## <Prop Name="IsAlmostSimple" Arg='tbl' Label="for a character table"/>
## <Prop Name="IsCyclic" Arg='tbl' Label="for a character table"/>
## <Prop Name="IsElementaryAbelian" Arg='tbl' Label="for a character table"/>
## <Prop Name="IsFinite" Arg='tbl' Label="for a character table"/>
## <Prop Name="IsMonomial" Arg='tbl' Label="for a character table"/>
## <Prop Name="IsNilpotent" Arg='tbl' Label="for a character table"/>
## <Prop Name="IsPerfect" Arg='tbl' Label="for a character table"/>
## <Prop Name="IsQuasisimple" Arg='tbl' Label="for a character table"/>
## <Prop Name="IsSimple" Arg='tbl' Label="for a character table"/>
## <Prop Name="IsSolvable" Arg='tbl' Label="for a character table"/>
## <Prop Name="IsSporadicSimple" Arg='tbl' Label="for a character table"/>
## <Prop Name="IsSupersolvable" Arg='tbl' Label="for a character table"/>
## <Attr Name="IsomorphismTypeInfoFiniteSimpleGroup" Arg='tbl'
## Label="for a character table"/>
## <Attr Name="NrConjugacyClasses" Arg='tbl' Label="for a character table"/>
## <Attr Name="Size" Arg='tbl' Label="for a character table"/>
##
## <Description>
## These operations for groups are applicable to character tables
## and mean the same for a character table as for its underlying group;
## see Chapter <Ref Chap="Groups"/> for the definitions.
## The operations are mainly useful for selecting character tables with
## certain properties, also for character tables without access to a group.
## 
## <Example><![CDATA[
## gap> tables:= [ CharacterTable( CyclicGroup( 3 ) ),
## > CharacterTable( SymmetricGroup( 4 ) ),
## > CharacterTable( AlternatingGroup( 5 ) ),
## > CharacterTable( SL( 2, 5 ) ) ];;
## gap> List( tables, AbelianInvariants );
## [ [ 3 ], [ 2 ], [ ], [ ] ]
## gap> List( tables, CommutatorLength );
## [ 1, 1, 1, 1 ]
## gap> List( tables, Exponent );
## [ 3, 12, 30, 60 ]
## gap> List( tables, IsAbelian );
## [ true, false, false, false ]
## gap> List( tables, IsAlmostSimple );
## [ false, false, true, false ]
## gap> List( tables, IsCyclic );
## [ true, false, false, false ]
## gap> List( tables, IsFinite );
## [ true, true, true, true ]
## gap> List( tables, IsMonomial );
## [ true, true, false, false ]
## gap> List( tables, IsNilpotent );
## [ true, false, false, false ]
## gap> List( tables, IsPerfect );
## [ false, false, true, true ]
## gap> List( tables, IsQuasisimple );
## [ false, false, true, true ]
## gap> List( tables, IsSimple );
## [ true, false, true, false ]
## gap> List( tables, IsSolvable );
## [ true, true, false, false ]
## gap> List( tables, IsSupersolvable );
## [ true, false, false, false ]
## gap> List( tables, NrConjugacyClasses );
## [ 3, 5, 5, 9 ]
## gap> List( tables, Size );
## [ 3, 24, 60, 120 ]
## gap> IsomorphismTypeInfoFiniteSimpleGroup( CharacterTable( "C5" ) );
## rec( name := "Z(5)", parameter := 5, series := "Z", shortname := "C5"
## )
## gap> IsomorphismTypeInfoFiniteSimpleGroup( CharacterTable( "S3" ) );
## fail
## gap> IsomorphismTypeInfoFiniteSimpleGroup( CharacterTable( "S6(3)" ) );
## rec( name := "C(3,3) = S(6,3)", parameter := [ 3, 3 ], series := "C",
## shortname := "S6(3)" )
## gap> IsomorphismTypeInfoFiniteSimpleGroup( CharacterTable( "O7(3)" ) );
## rec( name := "B(3,3) = O(7,3)", parameter := [ 3, 3 ], series := "B",
## shortname := "O7(3)" )
## gap> IsomorphismTypeInfoFiniteSimpleGroup( CharacterTable( "A8" ) );
## rec( name := "A(8) ~ A(3,2) = L(4,2) ~ D(3,2) = O+(6,2)",
## parameter := 8, series := "A", shortname := "A8" )
## gap> IsomorphismTypeInfoFiniteSimpleGroup( CharacterTable( "L3(4)" ) );
## rec( name := "A(2,4) = L(3,4)", parameter := [ 3, 4 ], series := "L",
## shortname := "L3(4)" )
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttributeSuppCT( "AbelianInvariants", IsNearlyCharacterTable, [] );
DeclareAttributeSuppCT( "CommutatorLength", IsNearlyCharacterTable, [] );
DeclareAttributeSuppCT( "Exponent", IsNearlyCharacterTable, [] );
DeclarePropertySuppCT( "IsAbelian", IsNearlyCharacterTable );
DeclarePropertySuppCT( "IsCyclic", IsNearlyCharacterTable );
DeclarePropertySuppCT( "IsElementaryAbelian", IsNearlyCharacterTable );
DeclarePropertySuppCT( "IsFinite", IsNearlyCharacterTable );
DeclareAttributeSuppCT( "IsomorphismTypeInfoFiniteSimpleGroup",
 IsNearlyCharacterTable, [] );
DeclareAttributeSuppCT( "NrConjugacyClasses", IsNearlyCharacterTable, [] );
DeclareAttributeSuppCT( "Size", IsNearlyCharacterTable, [] );

#############################################################################
##
#P IsAlmostSimpleCharacterTable( <tbl> )
#P IsMonomialCharacterTable( <tbl> )
#P IsNilpotentCharacterTable( <tbl> )
#P IsPerfectCharacterTable( <tbl> )
#P IsQuasisimpleCharacterTable( <tbl> )
#P IsSimpleCharacterTable( <tbl> )
#P IsSolvableCharacterTable( <tbl> )
#P IsSporadicSimpleCharacterTable( <tbl> )
#P IsSupersolvableCharacterTable( <tbl> )
##
## <ManSection>
## <Heading>Properties for Character Tables</Heading>
## <Prop Name="IsAlmostSimpleCharacterTable" Arg='tbl'/>
## <Prop Name="IsMonomialCharacterTable" Arg='tbl'/>
## <Prop Name="IsNilpotentCharacterTable" Arg='tbl'/>
## <Prop Name="IsPerfectCharacterTable" Arg='tbl'/>
## <Prop Name="IsQuasisimpleCharacterTable" Arg='tbl'/>
## <Prop Name="IsSimpleCharacterTable" Arg='tbl'/>
## <Prop Name="IsSolvableCharacterTable" Arg='tbl'/>
## <Prop Name="IsSolubleCharacterTable" Arg='tbl'/>
## <Prop Name="IsSporadicSimpleCharacterTable" Arg='tbl'/>
## <Prop Name="IsSupersolvableCharacterTable" Arg='tbl'/>
## <Prop Name="IsSupersolubleCharacterTable" Arg='tbl'/>
##
## <Description>
## These properties belong to the <Q>overloaded</Q> operations,
## methods for the unqualified properties with argument an ordinary
## character table are installed in <F>lib/overload.g</F>.
## </Description>
## </ManSection>
##
DeclarePropertySuppCT( "IsAlmostSimpleCharacterTable",
 IsNearlyCharacterTable );
DeclarePropertySuppCT( "IsMonomialCharacterTable", IsNearlyCharacterTable );
DeclarePropertySuppCT( "IsNilpotentCharacterTable", IsNearlyCharacterTable );
DeclarePropertySuppCT( "IsPerfectCharacterTable", IsNearlyCharacterTable );
DeclarePropertySuppCT( "IsQuasisimpleCharacterTable",
 IsNearlyCharacterTable );
DeclarePropertySuppCT( "IsSimpleCharacterTable", IsNearlyCharacterTable );
DeclarePropertySuppCT( "IsSolvableCharacterTable", IsNearlyCharacterTable );
DeclarePropertySuppCT( "IsSporadicSimpleCharacterTable",
 IsNearlyCharacterTable );
DeclarePropertySuppCT( "IsSupersolvableCharacterTable",
 IsNearlyCharacterTable );

DeclareSynonymAttr( "IsSolubleCharacterTable", IsSolvableCharacterTable );
DeclareSynonymAttr( "IsSupersolubleCharacterTable",
 IsSupersolvableCharacterTable );

InstallTrueMethod( IsAbelian, IsOrdinaryTable and IsCyclic );
InstallTrueMethod( IsAbelian, IsOrdinaryTable and IsElementaryAbelian );
InstallTrueMethod( IsMonomialCharacterTable,
 IsOrdinaryTable and IsSupersolvableCharacterTable and IsFinite );
InstallTrueMethod( IsNilpotentCharacterTable,
 IsOrdinaryTable and IsAbelian );
InstallTrueMethod( IsPerfectCharacterTable,
 IsOrdinaryTable and IsQuasisimpleCharacterTable );
InstallTrueMethod( IsSimpleCharacterTable,
 IsOrdinaryTable and IsSporadicSimpleCharacterTable );
InstallTrueMethod( IsSolvableCharacterTable,
 IsOrdinaryTable and IsSupersolvableCharacterTable );
InstallTrueMethod( IsSolvableCharacterTable,
 IsOrdinaryTable and IsMonomialCharacterTable );
InstallTrueMethod( IsSupersolvableCharacterTable,
 IsOrdinaryTable and IsNilpotentCharacterTable );

#############################################################################
##
#F CharacterTable_IsNilpotentFactor( <tbl>, <N> )
##
## <ManSection>
## <Func Name="CharacterTable_IsNilpotentFactor" Arg='tbl, N'/>
##
## <Description>
## returns whether the factor group by the normal subgroup described by the
## classes at positions in the list <A>N</A> is nilpotent.
## </Description>
## </ManSection>
##
DeclareGlobalFunction( "CharacterTable_IsNilpotentFactor" );

#############################################################################
##
#F CharacterTable_IsNilpotentNormalSubgroup( <tbl>, <N> )
##
## <ManSection>
## <Func Name="CharacterTable_IsNilpotentNormalSubgroup" Arg='tbl, N'/>
##
## <Description>
## returns whether the normal subgroup described by the classes at positions
## in the list <A>N</A> is nilpotent.
## </Description>
## </ManSection>
##
DeclareGlobalFunction( "CharacterTable_IsNilpotentNormalSubgroup" );

#############################################################################
##
## 6. Attributes and Properties only for Character Tables
##
## <#GAPDoc Label="[6]{ctbl}">
## The following three <E>attributes for character tables</E>
## –<Ref Attr="OrdersClassRepresentatives"/>,
## <Ref Attr="SizesCentralizers"/>, and
## <Ref Attr="SizesConjugacyClasses"/>– would make sense
## also for groups but are in fact <E>not</E> used for groups.
## This is because the values depend on the ordering of conjugacy classes
## stored as the value of
## <Ref Attr="ConjugacyClasses" Label="for character tables"/>,
## and this value may differ for a group and its character table
## (see <Ref Sect="The Interface between Character Tables and Groups"/>).
## Note that for character tables, the consistency of attribute values must
## be guaranteed,
## whereas for groups, there is no need to impose such a consistency rule.
## 
## The other attributes introduced in this section apply only to character
## tables, not to groups.
## <#/GAPDoc>
##

#############################################################################
##
#A OrdersClassRepresentatives( <tbl> )
##
## <#GAPDoc Label="OrdersClassRepresentatives">
## <ManSection>
## <Attr Name="OrdersClassRepresentatives" Arg='tbl'/>
##
## <Description>
## is a list of orders of representatives of conjugacy classes of the
## character table <A>tbl</A>,
## in the same ordering as the conjugacy classes of <A>tbl</A>.
## 
## <Example><![CDATA[
## gap> tbl:= CharacterTable( "A5" );;
## gap> OrdersClassRepresentatives( tbl );
## [ 1, 2, 3, 5, 5 ]
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttributeSuppCT( "OrdersClassRepresentatives",
 IsNearlyCharacterTable, [ "class" ] );

#############################################################################
##
#A SizesCentralizers( <tbl> )
##
## <#GAPDoc Label="SizesCentralizers">
## <ManSection>
## <Attr Name="SizesCentralizers" Arg='tbl'/>
## <Attr Name="SizesCentralisers" Arg='tbl'/>
##
## <Description>
## is a list that stores at position <M>i</M> the size of the centralizer of
## any element in the <M>i</M>-th conjugacy class of the character table
## <A>tbl</A>.
## 
## <Example><![CDATA[
## gap> tbl:= CharacterTable( "A5" );;
## gap> SizesCentralizers( tbl );
## [ 60, 4, 3, 5, 5 ]
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttributeSuppCT( "SizesCentralizers", IsNearlyCharacterTable,
 [ "class" ] );

DeclareSynonymAttr( "SizesCentralisers", SizesCentralizers );

#############################################################################
##
#A SizesConjugacyClasses( <tbl> )
##
## <#GAPDoc Label="SizesConjugacyClasses">
## <ManSection>
## <Attr Name="SizesConjugacyClasses" Arg='tbl'/>
##
## <Description>
## is a list that stores at position <M>i</M> the size of the <M>i</M>-th
## conjugacy class of the character table <A>tbl</A>.
## 
## <Example><![CDATA[
## gap> tbl:= CharacterTable( "A5" );;
## gap> SizesConjugacyClasses( tbl );
## [ 1, 15, 20, 12, 12 ]
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttributeSuppCT( "SizesConjugacyClasses", IsNearlyCharacterTable,
 [ "class" ] );

#############################################################################
##
#A AutomorphismsOfTable( <tbl> )
##
## <#GAPDoc Label="AutomorphismsOfTable">
## <ManSection>
## <Attr Name="AutomorphismsOfTable" Arg='tbl'/>
##
## <Description>
## is the permutation group of all column permutations of the character
## table <A>tbl</A> that leave the set of irreducibles and each power map of
## <A>tbl</A> invariant (see also <Ref Oper="TableAutomorphisms"/>).
## <Example><![CDATA[
## gap> tbl:= CharacterTable( "Dihedral", 8 );;
## gap> AutomorphismsOfTable( tbl );
## Group([ (4,5) ])
## gap> OrdersClassRepresentatives( tbl );
## [ 1, 4, 2, 2, 2 ]
## gap> SizesConjugacyClasses( tbl );
## [ 1, 2, 1, 2, 2 ]
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttributeSuppCT( "AutomorphismsOfTable", IsNearlyCharacterTable,
 [ "class" ] );
#T AutomorphismGroup( <tbl> ) ??

#############################################################################
##
#A UnderlyingCharacteristic( <tbl> )
#A UnderlyingCharacteristic( <psi> )
##
## <#GAPDoc Label="UnderlyingCharacteristic">
## <ManSection>
## <Heading>UnderlyingCharacteristic</Heading>
## <Attr Name="UnderlyingCharacteristic" Arg='tbl'
## Label="for a character table"/>
## <Attr Name="UnderlyingCharacteristic" Arg='psi' Label="for a character"/>
##
## <Description>
## For an ordinary character table <A>tbl</A>, the result is <C>0</C>,
## for a <M>p</M>-modular Brauer table <A>tbl</A>, it is <M>p</M>.
## The underlying characteristic of a class function <A>psi</A> is equal to
## that of its underlying character table.
## 
## The underlying characteristic must be stored when the table is
## constructed, there is no method to compute it.
## 
## We cannot use the attribute <Ref Attr="Characteristic"/>
## to denote this, since of course each Brauer character is an element
## of characteristic zero in the sense of &GAP;
## (see Chapter <Ref Chap="Class Functions"/>).
## 
## <Example><![CDATA[
## gap> tbl:= CharacterTable( "A5" );;
## gap> UnderlyingCharacteristic( tbl );
## 0
## gap> UnderlyingCharacteristic( tbl mod 17 );
## 17
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttributeSuppCT( "UnderlyingCharacteristic",
 IsNearlyCharacterTable, [] );

#############################################################################
##
#A ClassNames( <tbl>[, "ATLAS"] )
#A CharacterNames( <tbl> )
##
## <#GAPDoc Label="ClassNames">
## <ManSection>
## <Heading>Class Names and Character Names</Heading>
## <Attr Name="ClassNames" Arg='tbl[, "ATLAS"]'/>
## <Attr Name="CharacterNames" Arg='tbl'/>
##
## <Description>
## <Ref Attr="ClassNames"/> and <Ref Attr="CharacterNames"/> return lists of
## strings, one for each conjugacy class or irreducible character,
## respectively, of the character table <A>tbl</A>.
## These names are used when <A>tbl</A> is displayed.
## 
## The default method for <Ref Attr="ClassNames"/> computes class names
## consisting of the order of an element in the class and at least one
## distinguishing letter.
## 
## The default method for <Ref Attr="CharacterNames"/> returns the list
## <C>[ "X.1", "X.2", ... ]</C>, whose length is the number of
## irreducible characters of <A>tbl</A>.
## 
## The position of the class with name <A>name</A> in <A>tbl</A> can be
## accessed as <C><A>tbl</A>.<A>name</A></C>.
## 
## When <Ref Attr="ClassNames"/> is called with two arguments, the second
## being the string <C>"ATLAS"</C>, the class names returned obey the
## convention used in the &ATLAS; of Finite Groups
## <Cite Key="CCN85" Where="Chapter 7, Section 5"/>.
## If one is interested in <Q>relative</Q> class names of almost simple
## &ATLAS; groups, one can use the function
## <Ref Func="AtlasClassNames" BookName="atlasrep"/>.
## 
## <Example><![CDATA[
## gap> tbl:= CharacterTable( "A5" );;
## gap> ClassNames( tbl );
## [ "1a", "2a", "3a", "5a", "5b" ]
## gap> tbl.2a;
## 2
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttributeSuppCT( "ClassNames", IsNearlyCharacterTable,
 [ "class" ] );

DeclareOperation( "ClassNames", [ IsNearlyCharacterTable, IsString ] );

DeclareAttributeSuppCT( "CharacterNames", IsNearlyCharacterTable,
 [ "character" ] );

#############################################################################
##
#F ColumnCharacterTable( <tbl>,<nr> )
##
## <ManSection>
## <Func Name="ColumnCharacterTable" Arg='tbl, nr'/>
## <Description>
## returns a column vector that is the <A>nr</A>-th column of the character
## table <A>tbl</A>.
## </Description>
## </ManSection>
DeclareGlobalFunction("ColumnCharacterTable");

#############################################################################
##
#A ClassParameters( <tbl> )
#A CharacterParameters( <tbl> )
##
## <#GAPDoc Label="ClassParameters">
## <ManSection>
## <Heading>Class Parameters and Character Parameters</Heading>
## <Attr Name="ClassParameters" Arg='tbl'/>
## <Attr Name="CharacterParameters" Arg='tbl'/>
##
## <Description>
## The values of these attributes are lists containing a parameter for each
## conjugacy class or irreducible character, respectively,
## of the character table <A>tbl</A>.
## 
## It depends on <A>tbl</A> what these parameters are,
## so there is no default to compute class and character parameters.
## 
## For example, the classes of symmetric groups can be parametrized by
## partitions, corresponding to the cycle structures of permutations.
## Character tables constructed from generic character tables
## (see the manual of the &GAP; Character Table Library)
## usually have class and character parameters stored.
## 
## If <A>tbl</A> is a <M>p</M>-modular Brauer table such that class
## parameters are stored in the underlying ordinary table
## (see <Ref Attr="OrdinaryCharacterTable" Label="for a character table"/>)
## of <A>tbl</A> then <Ref Attr="ClassParameters"/> returns the sublist of
## class parameters of the ordinary table, for <M>p</M>-regular classes.
## 
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttributeSuppCT( "ClassParameters", IsNearlyCharacterTable,
 [ "class" ] );

DeclareAttributeSuppCT( "CharacterParameters", IsNearlyCharacterTable,
 [ "character" ] );

#############################################################################
##
#A Identifier( <tbl> )
##
## <#GAPDoc Label="Identifier:ctbl">
## <ManSection>
## <Attr Name="Identifier" Arg='tbl' Label="for character tables"/>
##
## <Description>
## is a string that identifies the character table <A>tbl</A> in the current
## &GAP; session.
## It is used mainly for class fusions into <A>tbl</A> that are stored on
## other character tables.
## For character tables without group,
## the identifier is also used to print the table;
## this is the case for library tables,
## but also for tables that are constructed as direct products, factors
## etc. involving tables that may or may not store their groups.
## 
## The default method for ordinary tables constructs strings of the form
## <C>"CT<A>n</A>"</C>, where <A>n</A> is a positive integer.
## <C>LARGEST_IDENTIFIER_NUMBER</C> is a list containing the largest integer
## <A>n</A> used in the current &GAP; session.
## 
## The default method for Brauer tables returns the concatenation of the
## identifier of the ordinary table, the string <C>"mod"</C>,
## and the (string of the) underlying characteristic.
## 
## <Example><![CDATA[
## gap> Identifier( CharacterTable( "A5" ) );
## "A5"
## gap> tbl:= CharacterTable( Group( () ) );;
## gap> Identifier( tbl ); Identifier( tbl mod 2 );
## "CT8"
## "CT8mod2"
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttributeSuppCT( "Identifier", IsNearlyCharacterTable, [] );

#############################################################################
##
#V LARGEST_IDENTIFIER_NUMBER
##
## <ManSection>
## <Var Name="LARGEST_IDENTIFIER_NUMBER"/>
##
## <Description>
## list containing the largest identifier of an ordinary character table in
## the current session.
## 
## </Description>
## </ManSection>
##
BindGlobal( "LARGEST_IDENTIFIER_NUMBER", FixedAtomicList([ 0 ]) );

#############################################################################
##
#M InfoText( <tbl> )
##
## <#GAPDoc Label="InfoText_ctbl">
## <ManSection>
## <Meth Name="InfoText" Arg='tbl' Label="for character tables"/>
##
## <Description>
## is a mutable string with information about the character table
## <A>tbl</A>.
## There is no default method to create an info text.
## 
## This attribute is used mainly for library tables (see the manual of the
## &GAP; Character Table Library).
## Usual parts of the information are the origin of the table,
## tests it has passed (<C>1.o.r.</C> for the test of orthogonality,
## <C>pow[<A>p</A>]</C> for the construction of the <A>p</A>-th power map,
## <C>DEC</C> for the decomposition of ordinary into Brauer characters,
## <C>TENS</C> for the decomposition of tensor products of irreducibles),
## and choices made without loss of generality.
## 
## <Example><![CDATA[
## gap> Print( InfoText( CharacterTable( "A5" ) ), "\n" );
## origin: ATLAS of finite groups, tests: 1.o.r., pow[2,3,5]
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
## Do not call 'DeclareAttributeSuppCT',
## since the attribute has already been declared for arbitrary GAP objects.
## A second declaration with requirement 'IsNearlyCharacterTable' would
## make the installation of a method with 'InstallMethod' impossible.
##
## We want, however, to add 'InfoText' to the list
## 'SupportedCharacterTableInfo'.
##
Append( SupportedCharacterTableInfo,
 [ InfoText, "InfoText", [ "mutable" ] ] );

#############################################################################
##
#A InverseClasses( <tbl> )
##
## <#GAPDoc Label="InverseClasses">
## <ManSection>
## <Attr Name="InverseClasses" Arg='tbl'/>
##
## <Description>
## For a character table <A>tbl</A>,
## <Ref Attr="InverseClasses"/> returns the list mapping
## each conjugacy class to its inverse class.
## This list can be regarded as <M>(-1)</M>-st power map of <A>tbl</A>
## (see <Ref Oper="PowerMap"/>).
## 
## <Example><![CDATA[
## gap> InverseClasses( CharacterTable( "A5" ) );
## [ 1, 2, 3, 4, 5 ]
## gap> InverseClasses( CharacterTable( "Cyclic", 3 ) );
## [ 1, 3, 2 ]
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "InverseClasses", IsNearlyCharacterTable );

#############################################################################
##
#A RealClasses( <tbl> ) . . . . . . real-valued classes of a character table
##
## <#GAPDoc Label="RealClasses">
## <ManSection>
## <Attr Name="RealClasses" Arg='tbl'/>
##
## <Description>
## <Index Subkey="real">classes</Index>
## For a character table <A>tbl</A>,
## <Ref Attr="RealClasses"/> returns the strictly sorted
## list of positions of classes in <A>tbl</A> that consist of real elements.
## 
## An element <M>x</M> is <E>real</E> iff it is conjugate to its inverse
## <M>x^{{-1}} = x^{{o(x)-1}}</M>.
## 
## <Example><![CDATA[
## gap> RealClasses( CharacterTable( "A5" ) );
## [ 1, 2, 3, 4, 5 ]
## gap> RealClasses( CharacterTable( "Cyclic", 3 ) );
## [ 1 ]
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttributeSuppCT( "RealClasses", IsNearlyCharacterTable, [ "class" ] );

#############################################################################
##
#O ClassOrbit( <tbl>, <cc> ) . . . . . . . . . classes of a cyclic subgroup
##
## <#GAPDoc Label="ClassOrbit">
## <ManSection>
## <Oper Name="ClassOrbit" Arg='tbl, cc'/>
##
## <Description>
## is the list of positions of those conjugacy classes
## of the character table <A>tbl</A> that are Galois conjugate to the
## <A>cc</A>-th class.
## That is, exactly the classes at positions given by the list returned by
## <Ref Oper="ClassOrbit"/> contain generators of the cyclic group generated
## by an element in the <A>cc</A>-th class.
## 
## This information is computed from the power maps of <A>tbl</A>.
## 
## <Example><![CDATA[
## gap> ClassOrbit( CharacterTable( "A5" ), 4 );
## [ 4, 5 ]
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareOperation( "ClassOrbit", [ IsNearlyCharacterTable, IsPosInt ] );

#############################################################################
##
#A ClassRoots( <tbl> ) . . . . . . . . . . . . nontrivial roots of elements
##
## <#GAPDoc Label="ClassRoots">
## <ManSection>
## <Attr Name="ClassRoots" Arg='tbl'/>
##
## <Description>
## For a character table <A>tbl</A>,
## <Ref Attr="ClassRoots"/> returns a list containing at position <M>i</M>
## the list of positions of the classes of all nontrivial <M>p</M>-th roots,
## where <M>p</M> runs over the prime divisors of the
## <Ref Attr="Size" Label="for a character table"/> value of <A>tbl</A>.
## 
## This information is computed from the power maps of <A>tbl</A>.
## 
## <Example><![CDATA[
## gap> ClassRoots( CharacterTable( "A5" ) );
## [ [ 2, 3, 4, 5 ], [ ], [ ], [ ], [ ] ]
## gap> ClassRoots( CharacterTable( "Cyclic", 6 ) );
## [ [ 3, 4, 5 ], [ ], [ 2 ], [ 2, 6 ], [ 6 ], [ ] ]
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "ClassRoots", IsCharacterTable );

#############################################################################
##
## <#GAPDoc Label="[8]{ctbl}">
## The following attributes for a character table <A>tbl</A> correspond to
## attributes for the group <M>G</M> of <A>tbl</A>.
## But instead of a normal subgroup (or a list of normal subgroups) of
## <M>G</M>, they return a strictly sorted list of positive integers (or a
## list of such lists) which are the positions
## –relative to the
## <Ref Attr="ConjugacyClasses" Label="for character tables"/>
## value of <A>tbl</A>–
## of those classes forming the normal subgroup in question.
## <#/GAPDoc>
##

#############################################################################
##
#A ClassPositionsOfNormalSubgroups( <ordtbl> )
#A ClassPositionsOfMaximalNormalSubgroups( <ordtbl> )
#A ClassPositionsOfMinimalNormalSubgroups( <ordtbl> )
##
## <#GAPDoc Label="ClassPositionsOfNormalSubgroups">
## <ManSection>
## <Attr Name="ClassPositionsOfNormalSubgroups" Arg='ordtbl'/>
## <Attr Name="ClassPositionsOfMaximalNormalSubgroups" Arg='ordtbl'/>
## <Attr Name="ClassPositionsOfMinimalNormalSubgroups" Arg='ordtbl'/>
##
## <Description>
## correspond to <Ref Attr="NormalSubgroups"/>,
## <Ref Attr="MaximalNormalSubgroups"/>,
## <Ref Attr="MinimalNormalSubgroups"/>
## for the group of the ordinary character table <A>ordtbl</A>.
## 
## The entries of the result lists are sorted according to increasing
## length.
## (So this total order respects the partial order of normal subgroups
## given by inclusion.)
## 
## <Example><![CDATA[
## gap> tbls4:= CharacterTable( "Symmetric", 4 );;
## gap> ClassPositionsOfNormalSubgroups( tbls4 );
## [ [ 1 ], [ 1, 3 ], [ 1, 3, 4 ], [ 1 .. 5 ] ]
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "ClassPositionsOfNormalSubgroups", IsOrdinaryTable );

DeclareAttribute( "ClassPositionsOfMaximalNormalSubgroups",
 IsOrdinaryTable );

DeclareAttribute( "ClassPositionsOfMinimalNormalSubgroups",
 IsOrdinaryTable );

#############################################################################
##
#O ClassPositionsOfAgemo( <ordtbl>, )
##
## <#GAPDoc Label="ClassPositionsOfAgemo">
## <ManSection>
## <Oper Name="ClassPositionsOfAgemo" Arg='ordtbl, p'/>
##
## <Description>
## corresponds to <Ref Func="Agemo"/>
## for the group of the ordinary character table <A>ordtbl</A>.
## 
## <Example><![CDATA[
## gap> tbls4:= CharacterTable( "Symmetric", 4 );;
## gap> ClassPositionsOfAgemo( tbls4, 2 );
## [ 1, 3, 4 ]
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareOperation( "ClassPositionsOfAgemo", [ IsOrdinaryTable, IsPosInt ] );

#############################################################################
##
#A ClassPositionsOfCentre( <ordtbl> )
##
## <#GAPDoc Label="ClassPositionsOfCentre:ctbl">
## <ManSection>
## <Attr Name="ClassPositionsOfCentre" Arg='ordtbl'
## Label="for a character table"/>
## <Attr Name="ClassPositionsOfCenter" Arg='ordtbl'
## Label="for a character table"/>
##
## <Description>
## corresponds to <Ref Attr="Centre"/>
## for the group of the ordinary character table <A>ordtbl</A>.
## 
## <Example><![CDATA[
## gap> tbld8:= CharacterTable( "Dihedral", 8 );;
## gap> ClassPositionsOfCentre( tbld8 );
## [ 1, 3 ]
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "ClassPositionsOfCentre", IsOrdinaryTable );

DeclareSynonymAttr( "ClassPositionsOfCenter", ClassPositionsOfCentre );

#############################################################################
##
#A ClassPositionsOfDirectProductDecompositions( <tbl>[, <nclasses>] )
##
## <#GAPDoc Label="ClassPositionsOfDirectProductDecompositions">
## <ManSection>
## <Attr Name="ClassPositionsOfDirectProductDecompositions"
## Arg='tbl[, nclasses]'/>
##
## <Description>
## Let <A>tbl</A> be the ordinary character table of the group <M>G</M>,
## say.
## Called with the only argument <A>tbl</A>,
## <Ref Attr="ClassPositionsOfDirectProductDecompositions"/> returns
## the list of all those pairs <M>[ l_1, l_2 ]</M> where <M>l_1</M> and
## <M>l_2</M> are lists of class positions of normal subgroups <M>N_1</M>,
## <M>N_2</M> of <M>G</M> such that <M>G</M> is their direct product and
## <M>|N_1| \leq |N_2|</M> holds.
## Called with second argument a list <A>nclasses</A> of class positions of
## a normal subgroup <M>N</M> of <M>G</M>,
## <Ref Attr="ClassPositionsOfDirectProductDecompositions"/> returns
## the list of pairs describing the decomposition of <M>N</M> as a direct
## product of two normal subgroups of <M>G</M>.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttributeSuppCT( "ClassPositionsOfDirectProductDecompositions",
 IsOrdinaryTable, [ "class" ] );

DeclareOperation( "ClassPositionsOfDirectProductDecompositions",
 [ IsOrdinaryTable, IsList ] );

#############################################################################
##
#A ClassPositionsOfDerivedSubgroup( <ordtbl> )
##
## <#GAPDoc Label="ClassPositionsOfDerivedSubgroup">
## <ManSection>
## <Attr Name="ClassPositionsOfDerivedSubgroup" Arg='ordtbl'/>
##
## <Description>
## corresponds to <Ref Attr="DerivedSubgroup"/>
## for the group of the ordinary character table <A>ordtbl</A>.
## 
## <Example><![CDATA[
## gap> tbld8:= CharacterTable( "Dihedral", 8 );;
## gap> ClassPositionsOfDerivedSubgroup( tbld8 );
## [ 1, 3 ]
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "ClassPositionsOfDerivedSubgroup", IsOrdinaryTable );

#############################################################################
##
#A ClassPositionsOfElementaryAbelianSeries( <ordtbl> )
##
## <#GAPDoc Label="ClassPositionsOfElementaryAbelianSeries">
## <ManSection>
## <Attr Name="ClassPositionsOfElementaryAbelianSeries" Arg='ordtbl'/>
##
## <Description>
## corresponds to <Ref Attr="ElementaryAbelianSeries" Label="for a group"/>
## for the group of the ordinary character table <A>ordtbl</A>.
## 
## <Example><![CDATA[
## gap> tbls4:= CharacterTable( "Symmetric", 4 );;
## gap> tbla5:= CharacterTable( "A5" );;
## gap> ClassPositionsOfElementaryAbelianSeries( tbls4 );
## [ [ 1 .. 5 ], [ 1, 3, 4 ], [ 1, 3 ], [ 1 ] ]
## gap> ClassPositionsOfElementaryAbelianSeries( tbla5 );
## fail
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "ClassPositionsOfElementaryAbelianSeries",
 IsOrdinaryTable );

#############################################################################
##
#A ClassPositionsOfFittingSubgroup( <ordtbl> )
##
## <#GAPDoc Label="ClassPositionsOfFittingSubgroup">
## <ManSection>
## <Attr Name="ClassPositionsOfFittingSubgroup" Arg='ordtbl'/>
##
## <Description>
## corresponds to <Ref Attr="FittingSubgroup"/>
## for the group of the ordinary character table <A>ordtbl</A>.
## 
## <Example><![CDATA[
## gap> tbls4:= CharacterTable( "Symmetric", 4 );;
## gap> ClassPositionsOfFittingSubgroup( tbls4 );
## [ 1, 3 ]
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "ClassPositionsOfFittingSubgroup", IsOrdinaryTable );

#############################################################################
##
#A ClassPositionsOfSolvableRadical( <ordtbl> )
##
## <#GAPDoc Label="ClassPositionsOfSolvableRadical">
## <ManSection>
## <Attr Name="ClassPositionsOfSolvableRadical" Arg='ordtbl'/>
##
## <Description>
## corresponds to <Ref Attr="SolvableRadical"/>
## for the group of the ordinary character table <A>ordtbl</A>.
## 
## <Example><![CDATA[
## gap> ClassPositionsOfSolvableRadical( CharacterTable( "2.A5" ) );
## [ 1, 2 ]
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "ClassPositionsOfSolvableRadical",
 IsOrdinaryTable );

#############################################################################
##
#F CharacterTable_UpperCentralSeriesFactor( <tbl>, <N> )
##
## <ManSection>
## <Func Name="CharacterTable_UpperCentralSeriesFactor" Arg='tbl, N'/>
##
## <Description>
## Let <A>tbl</A> the character table of the group <M>G</M>, and <A>N</A>
## the list of classes contained in the normal subgroup <M>N</M> of
## <M>G</M>.
## The upper central series <M>[ Z_1, Z_2, \ldots, Z_n ]</M> of <M>G/N</M>
## is defined by <M>Z_1 = Z(G/N)</M>,
## and <M>Z_{i+1} / Z_i = Z( G / Z_i )</M>.
## <Ref Func="UpperCentralSeriesFactor"/> returns a list
## <M>[ C_1, C_2, \ldots, C_n ]</M> where <M>C_i</M> is the set of positions
## of <M>G</M>-conjugacy classes contained in <M>Z_i</M>.
## 
## A simpleminded version of the algorithm can be stated as follows.
## 
## <M>M_0:= Irr(G);</M>
## <M>Z_1:= Z(G);</M>
## <M>i:= 0;</M>
## repeat
## <M>i:= i+1;</M>
## <M>M_i:= { \chi\in M_{i-1} ; Z_i \leq \ker(\chi) };</M>
## <M>Z_{i+1}:= \bigcap_{\chi\in M_i}} Z(\chi);</M>
## until <M>Z_i = Z_{i+1};</M>
## </Description>
## </ManSection>
##
DeclareGlobalFunction( "CharacterTable_UpperCentralSeriesFactor" );

#############################################################################
##
#A ClassPositionsOfLowerCentralSeries( <tbl> )
##
## <#GAPDoc Label="ClassPositionsOfLowerCentralSeries">
## <ManSection>
## <Attr Name="ClassPositionsOfLowerCentralSeries" Arg='tbl'/>
##
## <Description>
## corresponds to <Ref Attr="LowerCentralSeriesOfGroup"/>
## for the group of the ordinary character table <A>ordtbl</A>.
## 
## <Example><![CDATA[
## gap> tbls4:= CharacterTable( "Symmetric", 4 );;
## gap> tbld8:= CharacterTable( "Dihedral", 8 );;
## gap> ClassPositionsOfLowerCentralSeries( tbls4 );
## [ [ 1 .. 5 ], [ 1, 3, 4 ] ]
## gap> ClassPositionsOfLowerCentralSeries( tbld8 );
## [ [ 1 .. 5 ], [ 1, 3 ], [ 1 ] ]
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "ClassPositionsOfLowerCentralSeries", IsOrdinaryTable );

#############################################################################
##
#A ClassPositionsOfUpperCentralSeries( <ordtbl> )
##
## <#GAPDoc Label="ClassPositionsOfUpperCentralSeries">
## <ManSection>
## <Attr Name="ClassPositionsOfUpperCentralSeries" Arg='ordtbl'/>
##
## <Description>
## corresponds to <Ref Attr="UpperCentralSeriesOfGroup"/>
## for the group of the ordinary character table <A>ordtbl</A>.
## 
## <Example><![CDATA[
## gap> tbls4:= CharacterTable( "Symmetric", 4 );;
## gap> tbld8:= CharacterTable( "Dihedral", 8 );;
## gap> ClassPositionsOfUpperCentralSeries( tbls4 );
## [ [ 1 ] ]
## gap> ClassPositionsOfUpperCentralSeries( tbld8 );
## [ [ 1, 3 ], [ 1, 2, 3, 4, 5 ] ]
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "ClassPositionsOfUpperCentralSeries", IsOrdinaryTable );

#############################################################################
##
#A ClassPositionsOfSolvableResiduum( <ordtbl> )
##
## <ManSection>
## <Attr Name="ClassPositionsOfSolvableResiduum" Arg='ordtbl'/>
## <Attr Name="ClassPositionsOfSolubleResiduum" Arg='ordtbl'/>
##
## <Description>
## corresponds to <Ref Attr="SolvableResiduum"/>
## for the group of the ordinary character table <A>ordtbl</A>.
## </Description>
## </ManSection>
##
DeclareAttribute( "ClassPositionsOfSolvableResiduum", IsOrdinaryTable );

DeclareSynonymAttr( "ClassPositionsOfSolubleResiduum",
 ClassPositionsOfSolvableResiduum );

#############################################################################
##
#A ClassPositionsOfSupersolvableResiduum( <ordtbl> )
##
## <#GAPDoc Label="ClassPositionsOfSupersolvableResiduum">
## <ManSection>
## <Attr Name="ClassPositionsOfSupersolvableResiduum" Arg='ordtbl'/>
##
## <Description>
## corresponds to <Ref Attr="SupersolvableResiduum"/>
## for the group of the ordinary character table <A>ordtbl</A>.
## 
## <Example><![CDATA[
## gap> tbls4:= CharacterTable( "Symmetric", 4 );;
## gap> ClassPositionsOfSupersolvableResiduum( tbls4 );
## [ 1, 3 ]
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "ClassPositionsOfSupersolvableResiduum", IsOrdinaryTable );

#############################################################################
##
#O ClassPositionsOfPCore( <ordtbl>, )
##
## <#GAPDoc Label="ClassPositionsOfPCore">
## <ManSection>
## <Oper Name="ClassPositionsOfPCore" Arg='ordtbl, p'/>
##
## <Description>
## corresponds to <Ref Oper="PCore"/>
## for the group of the ordinary character table <A>ordtbl</A>.
## 
## <Example><![CDATA[
## gap> tbls4:= CharacterTable( "Symmetric", 4 );;
## gap> ClassPositionsOfPCore( tbls4, 2 );
## [ 1, 3 ]
## gap> ClassPositionsOfPCore( tbls4, 3 );
## [ 1 ]
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareOperation( "ClassPositionsOfPCore", [ IsOrdinaryTable, IsPosInt ] );

#############################################################################
##
#O ClassPositionsOfNormalClosure( <ordtbl>, <classes> )
##
## <#GAPDoc Label="ClassPositionsOfNormalClosure">
## <ManSection>
## <Oper Name="ClassPositionsOfNormalClosure" Arg='ordtbl, classes'/>
##
## <Description>
## is the sorted list of the positions of all conjugacy classes of the
## ordinary character table <A>ordtbl</A> that form the normal closure
## (see <Ref Oper="NormalClosure"/>) of the conjugacy classes at
## positions in the list <A>classes</A>.
## 
## <Example><![CDATA[
## gap> tbls4:= CharacterTable( "Symmetric", 4 );;
## gap> ClassPositionsOfNormalClosure( tbls4, [ 1, 4 ] );
## [ 1, 3, 4 ]
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareOperation( "ClassPositionsOfNormalClosure",
 [ IsOrdinaryTable, IsHomogeneousList and IsCyclotomicCollection ] );

#############################################################################
##
## x. Operations Concerning Blocks
##

#############################################################################
##
#O PrimeBlocks( <ordtbl>, )
#O PrimeBlocksOp( <ordtbl>, )
#A ComputedPrimeBlockss( <tbl> )
##
## <#GAPDoc Label="PrimeBlocks">
## <ManSection>
## <Oper Name="PrimeBlocks" Arg='ordtbl, p'/>
## <Oper Name="PrimeBlocksOp" Arg='ordtbl, p'/>
## <Attr Name="ComputedPrimeBlockss" Arg='tbl'/>
##
## <Description>
## For an ordinary character table <A>ordtbl</A> and a prime integer
## <A>p</A>,
## <Ref Oper="PrimeBlocks"/> returns a record with the following components.
## <List>
## <C>block</C>
## <Item>
## a list, the value <M>j</M> at position <M>i</M> means that the
## <M>i</M>-th irreducible character of <A>ordtbl</A> lies in the
## <M>j</M>-th <A>p</A>-block of <A>ordtbl</A>,
## </Item>
## <C>defect</C>
## <Item>
## a list containing at position <M>i</M> the defect of the <M>i</M>-th
## block,
## </Item>
## <C>height</C>
## <Item>
## a list containing at position <M>i</M> the height of the <M>i</M>-th
## irreducible character of <A>ordtbl</A> in its block,
## </Item>
## <C>relevant</C>
## <Item>
## a list of class positions such that only the restriction to these
## classes need be checked for deciding whether two characters lie
## in the same block, and
## </Item>
## <C>centralcharacter</C>
## <Item>
## a list containing at position <M>i</M> a list whose values at the
## positions stored in the component <C>relevant</C> are the values of
## a central character in the <M>i</M>-th block.
## </Item>
## </List>
## 
## The components <C>relevant</C> and <C>centralcharacters</C> are
## used by <Ref Func="SameBlock"/>.
## 
## If <Ref InfoClass="InfoCharacterTable"/> has level at least 2,
## the defects of the blocks and the heights of the characters are printed.
## 
## The default method uses the attribute
## <Ref Attr="ComputedPrimeBlockss"/> for storing the computed value at
## position <A>p</A>, and calls the operation <Ref Oper="PrimeBlocksOp"/>
## for computing values that are not yet known.
## 
## Two ordinary irreducible characters <M>\chi, \psi</M> of a group <M>G</M>
## are said to lie in the same <M>p</M>-<E>block</E> if the images of their
## central characters <M>\omega_{\chi}, \omega_{\psi}</M>
## (see <Ref Attr="CentralCharacter"/>) under the
## natural ring epimorphism <M>R \rightarrow R / M</M> are equal,
## where <M>R</M> denotes the ring of algebraic integers in the complex
## number field, and <M>M</M> is a maximal ideal in <M>R</M> with
## <M>pR \subseteq M</M>.
## (The distribution to <M>p</M>-blocks is in fact independent of the choice
## of <M>M</M>, see <Cite Key="Isa76"/>.)
## 
## For <M>|G| = p^a m</M> where <M>p</M> does not divide <M>m</M>,
## the <E>defect</E> of a block is the integer <M>d</M> such that
## <M>p^{{a-d}}</M> is the largest power of <M>p</M> that divides the degrees
## of all characters in the block.
## 
## The <E>height</E> of a character <M>\chi</M> in the block is defined as
## the largest exponent <M>h</M> for which <M>p^h</M> divides
## <M>\chi(1) / p^{{a-d}}</M>.
## 
## <Example><![CDATA[
## gap> tbl:= CharacterTable( "L3(2)" );;
## gap> pbl:= PrimeBlocks( tbl, 2 );
## rec( block := [ 1, 1, 1, 1, 1, 2 ],
## centralcharacter := [ [ ,, 56,, 24 ], [ ,, -7,, 3 ] ],
## defect := [ 3, 0 ], height := [ 0, 0, 0, 1, 0, 0 ],
## relevant := [ 3, 5 ] )
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareOperation( "PrimeBlocks", [ IsOrdinaryTable, IsPosInt ] );

DeclareOperation( "PrimeBlocksOp", [ IsOrdinaryTable, IsPosInt ] );

DeclareAttributeSuppCT( "ComputedPrimeBlockss", IsOrdinaryTable, "mutable",
 [ "character" ] );

#T Admit a list of characters as optional argument,
#T and compute the distribution into blocks.
#T The question is how to determine the defects of the blocks;
#T this should be possible if defect classes can be computed without
#T problems (cf. Isaacs, Thm. 15.31).

#############################################################################
##
#F SameBlock( , <omega1>, <omega2>, <relevant> )
##
## <#GAPDoc Label="SameBlock">
## <ManSection>
## <Func Name="SameBlock" Arg='p, omega1, omega2, relevant'/>
##
## <Description>
## Let <A>p</A> be a prime integer, <A>omega1</A> and <A>omega2</A> be two
## central characters (or their values lists) of a character table,
## and <A>relevant</A> be a list of positions as is stored in the component
## <C>relevant</C> of a record returned by <Ref Oper="PrimeBlocks"/>.
## 
## <Ref Func="SameBlock"/> returns <K>true</K> if <A>omega1</A> and
## <A>omega2</A> are equal modulo any maximal ideal in the ring of complex
## algebraic integers containing the ideal spanned by <A>p</A>,
## and <K>false</K> otherwise.
## 
## <Example><![CDATA[
## gap> omega:= List( Irr( tbl ), CentralCharacter );;
## gap> SameBlock( 2, omega[1], omega[2], pbl.relevant );
## true
## gap> SameBlock( 2, omega[1], omega[6], pbl.relevant );
## false
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareGlobalFunction( "SameBlock" );

#############################################################################
##
#A BlocksInfo( <modtbl> )
##
## <#GAPDoc Label="BlocksInfo">
## <ManSection>
## <Attr Name="BlocksInfo" Arg='modtbl'/>
##
## <Description>
## For a Brauer character table <A>modtbl</A>, the value of
## <Ref Attr="BlocksInfo"/> is a list of (mutable) records,
## the <M>i</M>-th entry containing information about the <M>i</M>-th block.
## Each record has the following components.
## <List>
## <C>defect</C>
## <Item>
## the defect of the block,
## </Item>
## <C>ordchars</C>
## <Item>
## the list of positions of the ordinary characters that belong to the
## block, relative to
## <C>Irr( OrdinaryCharacterTable( <A>modtbl</A> ) )</C>,
## </Item>
## <C>modchars</C>
## <Item>
## the list of positions of the Brauer characters that belong to the
## block, relative to <C>IBr( <A>modtbl</A> )</C>.
## </Item>
## </List>
## Optional components are
## <List>
## <C>basicset</C>
## <Item>
## a list of positions of ordinary characters in the block whose
## restriction to <A>modtbl</A> is maximally linearly independent,
## relative to <C>Irr( OrdinaryCharacterTable( <A>modtbl</A> ) )</C>,
## </Item>
## <C>decmat</C>
## <Item>
## the decomposition matrix of the block,
## it is stored automatically when <Ref Oper="DecompositionMatrix"/>
## is called for the block,
## </Item>
## <C>decinv</C>
## <Item>
## inverse of the decomposition matrix of the block, restricted to the
## ordinary characters described by <C>basicset</C>,
## </Item>
## <C>brauertree</C>
## <Item>
## a list that describes the Brauer tree of the block,
## in the case that the block is of defect <M>1</M>.
## </Item>
## </List>
## 
## <Example><![CDATA[
## gap> BlocksInfo( CharacterTable( "L3(2)" ) mod 2 );
## [ rec( basicset := [ 1, 2, 3 ],
## decinv := [ [ 1, 0, 0 ], [ 0, 1, 0 ], [ 0, 0, 1 ] ],
## defect := 3, modchars := [ 1, 2, 3 ],
## ordchars := [ 1, 2, 3, 4, 5 ] ),
## rec( basicset := [ 6 ], decinv := [ [ 1 ] ], defect := 0,
## modchars := [ 4 ], ordchars := [ 6 ] ) ]
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttributeSuppCT( "BlocksInfo", IsNearlyCharacterTable, "mutable",
 [ "character" ] );

#############################################################################
##
#O DecompositionMatrix( <modtbl>[, <blocknr>] )
##
## <#GAPDoc Label="DecompositionMatrix">
## <ManSection>
## <Oper Name="DecompositionMatrix" Arg='modtbl[, blocknr]'/>
##
## <Description>
## Let <A>modtbl</A> be a Brauer character table.
## 
## Called with one argument, <Ref Oper="DecompositionMatrix"/> returns the
## decomposition matrix of <A>modtbl</A>, where the rows and columns are
## indexed by the irreducible characters of the ordinary character table of
## <A>modtbl</A> and the irreducible characters of <A>modtbl</A>,
## respectively,
## 
## Called with two arguments, <Ref Oper="DecompositionMatrix"/> returns the
## decomposition matrix of the block of <A>modtbl</A> with number
## <A>blocknr</A>;
## the matrix is stored as value of the <C>decmat</C> component of the
## <A>blocknr</A>-th entry of the <Ref Attr="BlocksInfo"/> list of
## <A>modtbl</A>.
## 
## An ordinary irreducible character is in block <M>i</M> if and only if all
## characters before the first character of the same block lie in <M>i-1</M>
## different blocks.
## An irreducible Brauer character is in block <M>i</M> if it has nonzero
## scalar product with an ordinary irreducible character in block <M>i</M>.
## 
## <Ref Oper="DecompositionMatrix"/> is based on the more general function
## <Ref Oper="Decomposition"/>.
## 
## <Example><![CDATA[
## gap> modtbl:= CharacterTable( "L3(2)" ) mod 2;
## BrauerTable( "L3(2)", 2 )
## gap> DecompositionMatrix( modtbl );
## [ [ 1, 0, 0, 0 ], [ 0, 1, 0, 0 ], [ 0, 0, 1, 0 ], [ 0, 1, 1, 0 ],
## [ 1, 1, 1, 0 ], [ 0, 0, 0, 1 ] ]
## gap> DecompositionMatrix( modtbl, 1 );
## [ [ 1, 0, 0 ], [ 0, 1, 0 ], [ 0, 0, 1 ], [ 0, 1, 1 ], [ 1, 1, 1 ] ]
## gap> DecompositionMatrix( modtbl, 2 );
## [ [ 1 ] ]
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "DecompositionMatrix", IsBrauerTable );
DeclareOperation( "DecompositionMatrix", [ IsBrauerTable, IsPosInt ] );

#############################################################################
##
#F LaTeXStringDecompositionMatrix( <modtbl>[, <blocknr>][, <options>] )
##
## <#GAPDoc Label="LaTeXStringDecompositionMatrix">
## <Index Subkey="for a decomposition matrix">LaTeX</Index>
## <ManSection>
## <Func Name="LaTeXStringDecompositionMatrix"
## Arg='modtbl[, blocknr][, options]'/>
##
## <Description>
## is a string that contains La&TeX; code to print a decomposition matrix
## (see <Ref Oper="DecompositionMatrix"/>) nicely.
## 
## The optional argument <A>options</A>, if present, must be a record with
## components
## <C>phi</C>, <C>chi</C> (strings used in each label for columns and rows),
## <C>collabels</C>, <C>rowlabels</C> (subscripts for the labels).
## The defaults for <C>phi</C> and <C>chi</C> are
## <C>"{\\tt Y}"</C> and <C>"{\\tt X}"</C>,
## the defaults for <C>collabels</C> and <C>rowlabels</C> are the lists of
## positions of the Brauer characters and ordinary characters in the
## respective lists of irreducibles in the character tables.
## 
## The optional components <C>nrows</C> and <C>ncols</C> denote the maximal
## number of rows and columns per array;
## if they are present then each portion of <C>nrows</C> rows and
## <C>ncols</C> columns forms an array of its own which is enclosed in
## <C>\[</C>, <C>\]</C>.
## 
## If the component <C>decmat</C> is bound in <A>options</A> then it must be
## the decomposition matrix in question, in this case the matrix is not
## computed from the information in <A>modtbl</A>.
## 
## For those character tables from the &GAP; table library that belong to
## the &ATLAS; of Finite Groups <Cite Key="CCN85"/>,
## <Ref Func="AtlasLabelsOfIrreducibles" BookName="ctbllib"/> constructs
## character labels that are compatible with those used in the &ATLAS;
## (see <Ref Sect="ATLAS Tables" BookName="ctbllib"/>
## in the manual of the &GAP; Character Table Library).
## 
## <Example><![CDATA[
## gap> modtbl:= CharacterTable( "L3(2)" ) mod 2;;
## gap> Print( LaTeXStringDecompositionMatrix( modtbl, 1 ) );
## \[
## \begin{array}{r|rrr} \hline
## & {\tt Y}_{1}
## & {\tt Y}_{2}
## & {\tt Y}_{3}
## \rule[-7pt]{0pt}{20pt} \\ \hline
## {\tt X}_{1} & 1 & . & . \rule[0pt]{0pt}{13pt} \\
## {\tt X}_{2} & . & 1 & . \\
## {\tt X}_{3} & . & . & 1 \\
## {\tt X}_{4} & . & 1 & 1 \\
## {\tt X}_{5} & 1 & 1 & 1 \rule[-7pt]{0pt}{5pt} \\
## \hline
## \end{array}
## \]
## gap> options:= rec( phi:= "\\varphi", chi:= "\\chi" );;
## gap> Print( LaTeXStringDecompositionMatrix( modtbl, 1, options ) );
## \[
## \begin{array}{r|rrr} \hline
## & \varphi_{1}
## & \varphi_{2}
## & \varphi_{3}
## \rule[-7pt]{0pt}{20pt} \\ \hline
## \chi_{1} & 1 & . & . \rule[0pt]{0pt}{13pt} \\
## \chi_{2} & . & 1 & . \\
## \chi_{3} & . & . & 1 \\
## \chi_{4} & . & 1 & 1 \\
## \chi_{5} & 1 & 1 & 1 \rule[-7pt]{0pt}{5pt} \\
## \hline
## \end{array}
## \]
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareGlobalFunction( "LaTeXStringDecompositionMatrix" );

#############################################################################
##
## 7. Other Operations for Character Tables
##
## <#GAPDoc Label="[9]{ctbl}">
## In the following, we list operations for character tables that are not
## attributes.
## <#/GAPDoc>
##

#############################################################################
##
#O Index( <tbl>, <subtbl> )
#O IndexOp( <tbl>, <subtbl> )
#O IndexNC( <tbl>, <subtbl> )
##
## <#GAPDoc Label="Index!for_character_tables">
## <ManSection>
## <Oper Name="Index" Arg='tbl, subtbl' Label="for two character tables"/>
##
## <Description>
## For two character tables <A>tbl</A> and <A>subtbl</A>,
## <Ref Oper="Index" Label="for two character tables"/> returns the
## quotient of the <Ref Attr="Size" Label="for a character table"/> values
## of <A>tbl</A> and <A>subtbl</A>.
## The containment of the underlying groups of <A>subtbl</A> and <A>tbl</A>
## is <E>not</E> checked;
## so the distinction between
## <Ref Oper="Index" Label="for a group and its subgroup"/>
## and <Ref Oper="IndexNC" Label="for a group and its subgroup"/>
## is not made for character tables.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareOperation( "Index",
 [ IsNearlyCharacterTable, IsNearlyCharacterTable ] );
DeclareOperation( "IndexOp",
 [ IsNearlyCharacterTable, IsNearlyCharacterTable ] );
DeclareOperation( "IndexNC",
 [ IsNearlyCharacterTable, IsNearlyCharacterTable ] );

#############################################################################
##
#O IsPSolvableCharacterTable( <tbl>, )
#O IsPSolvableCharacterTableOp( <tbl>, )
#A ComputedIsPSolvableCharacterTables( <tbl> )
##
## <#GAPDoc Label="IsPSolvableCharacterTable">
## <ManSection>
## <Oper Name="IsPSolvableCharacterTable" Arg='tbl, p'/>
## <Oper Name="IsPSolubleCharacterTable" Arg='tbl, p'/>
## <Oper Name="IsPSolvableCharacterTableOp" Arg='tbl, p'/>
## <Oper Name="IsPSolubleCharacterTableOp" Arg='tbl, p'/>
## <Attr Name="ComputedIsPSolvableCharacterTables" Arg='tbl'/>
## <Attr Name="ComputedIsPSolubleCharacterTables" Arg='tbl'/>
##
## <Description>
## <Ref Oper="IsPSolvableCharacterTable"/> for the ordinary character table
## <A>tbl</A> corresponds to <Ref Oper="IsPSolvable"/> for the group of
## <A>tbl</A>, <A>p</A> must be either a prime integer or <C>0</C>.
## 
## The default method uses the attribute
## <Ref Attr="ComputedIsPSolvableCharacterTables"/> for storing the computed
## value at position <A>p</A>, and calls the operation
## <Ref Oper="IsPSolvableCharacterTableOp"/>
## for computing values that are not yet known.
## 
## <Example><![CDATA[
## gap> tbl:= CharacterTable( "Sz(8)" );;
## gap> IsPSolvableCharacterTable( tbl, 2 );
## false
## gap> IsPSolvableCharacterTable( tbl, 3 );
## true
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareOperation( "IsPSolvableCharacterTable", [ IsOrdinaryTable, IsInt ] );
DeclareOperation( "IsPSolvableCharacterTableOp",
 [ IsOrdinaryTable, IsInt ] );
DeclareAttributeSuppCT( "ComputedIsPSolvableCharacterTables",
 IsOrdinaryTable, "mutable", [] );

DeclareSynonym( "IsPSolubleCharacterTable", IsPSolvableCharacterTable );
DeclareSynonym( "IsPSolubleCharacterTableOp", IsPSolvableCharacterTableOp );
DeclareSynonym( "ComputedIsPSolubleCharacterTables",
 ComputedIsPSolvableCharacterTables );

#############################################################################
##
#F IsClassFusionOfNormalSubgroup( <subtbl>, <fus>, <tbl> )
##
## <#GAPDoc Label="IsClassFusionOfNormalSubgroup">
## <ManSection>
## <Func Name="IsClassFusionOfNormalSubgroup" Arg='subtbl, fus, tbl'/>
##
## <Description>
## For two ordinary character tables <A>tbl</A> and <A>subtbl</A> of a group
## <M>G</M> and its subgroup <M>U</M>
## and a list <A>fus</A> of positive integers that describes the class
## fusion of <M>U</M> into <M>G</M>,
## <Ref Func="IsClassFusionOfNormalSubgroup"/> returns <K>true</K>
## if <M>U</M> is a normal subgroup of <M>G</M>, and <K>false</K> otherwise.
## 
## <Example><![CDATA[
## gap> tblc2:= CharacterTable( "Cyclic", 2 );;
## gap> tbld8:= CharacterTable( "Dihedral", 8 );;
## gap> fus:= PossibleClassFusions( tblc2, tbld8 );
## [ [ 1, 3 ], [ 1, 4 ], [ 1, 5 ] ]
## gap> List(fus, map -> IsClassFusionOfNormalSubgroup(tblc2, map, tbld8));
## [ true, false, false ]
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareGlobalFunction( "IsClassFusionOfNormalSubgroup" );

#############################################################################
##
#O Indicator( <tbl>[, <characters>], <n> )
#O IndicatorOp( <tbl>, <characters>, <n> )
#A ComputedIndicators( <tbl> )
##
## <#GAPDoc Label="Indicator">
## <ManSection>
## <Oper Name="Indicator" Arg='tbl[, characters], n'/>
## <Oper Name="IndicatorOp" Arg='tbl, characters, n'/>
## <Attr Name="ComputedIndicators" Arg='tbl'/>
##
## <Description>
## If <A>tbl</A> is an ordinary character table then <Ref Oper="Indicator"/>
## returns the list of <A>n</A>-th Frobenius-Schur indicators of the
## characters in the list <A>characters</A>;
## the default of <A>characters</A> is <C>Irr( <A>tbl</A> )</C>.
## 
## The <M>n</M>-th Frobenius-Schur indicator <M>\nu_n(\chi)</M> of an
## ordinary character <M>\chi</M> of the group <M>G</M> is given by
## <M>\nu_n(\chi) = ( \sum_{{g \in G}} \chi(g^n) ) / |G|</M>.
## 
## If <A>tbl</A> is a Brauer table in characteristic <M> \neq 2</M> and
## <M><A>n</A> = 2</M> then <Ref Oper="Indicator"/> returns the second
## indicator.
## 
## The default method uses the attribute
## <Ref Attr="ComputedIndicators"/> for storing the computed value at
## position <A>n</A>, and calls the operation <Ref Oper="IndicatorOp"/> for
## computing values that are not yet known.
## 
## <Example><![CDATA[
## gap> tbl:= CharacterTable( "L3(2)" );;
## gap> Indicator( tbl, 2 );
## [ 1, 0, 0, 1, 1, 1 ]
## ]]></Example>
## 
## In nonzero characteristic <M>p</M>, the Frobenius-Schur indicator is
## defined only for irreducible characters.
## For odd <M>p</M>, the indicator is computed using the Thompson-Willems
## Theorem <Cite Key="Tho86" Where="theorem on p. 227"/>.
## For <M>p = 2</M>, in general the indicator cannot be computed from the
## given character tables, here the following necessary conditions are used.
## 
## <List>
## <Item>
## The trivial character has indicator <M>1</M>.
## </Item>
## <Item>
## The indicator is <M>0</M> if and only if the character is not
## real-valued.
## </Item>
## <Item>
## Real characters outside the principal block (the <M>2</M>-block that
## contains the trivial character, see <Ref Oper="PrimeBlocks"/>)
## have indicator <M>1</M>.
## </Item>
## <Item>
## By <Cite Key="GW95" Where="Lemma 1.2"/>, any real constituent with odd
## multiplicity in the <M>2</M>-modular restriction of an ordinary
## irreducible character with indicator <M>1</M> has indicator <M>1</M>,
## provided that the trivial character is not a constituent of the
## restriction.
## </Item>
## </List>
## 
## For each <M>2</M>-modular Brauer characters where these conditions are
## not sufficient to determine the indicator, an unknown value
## (see <Ref Oper="Unknown"/>) is returned.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareOperation( "Indicator", [ IsNearlyCharacterTable, IsPosInt ] );
DeclareOperation( "Indicator",
 [ IsNearlyCharacterTable, IsList, IsPosInt ] );

DeclareOperation( "IndicatorOp",
 [ IsNearlyCharacterTable, IsList, IsPosInt ] );

DeclareAttributeSuppCT( "ComputedIndicators", IsCharacterTable, "mutable",
 [ "character" ] );

#############################################################################
##
#F NrPolyhedralSubgroups( <tbl>, <c1>, <c2>, <c3>) . # polyhedral subgroups
##
## <#GAPDoc Label="NrPolyhedralSubgroups">
## <ManSection>
## <Func Name="NrPolyhedralSubgroups" Arg='tbl, c1, c2, c3'/>
##
## <Description>
## <Index Subkey="polyhedral">subgroups</Index>
## returns the number and isomorphism type of polyhedral subgroups of the
## group with ordinary character table <A>tbl</A> which are generated by an
## element <M>g</M> of class <A>c1</A> and an element <M>h</M> of class
## <A>c2</A> with the property that the product <M>gh</M> lies in class
## <A>c3</A>.
## 
## According to <Cite Key="NPP84" Where="p. 233"/>, the number of
## polyhedral subgroups of isomorphism type <M>V_4</M>, <M>D_{2n}</M>,
## <M>A_4</M>, <M>S_4</M>, and <M>A_5</M> can be derived from the class
## multiplication coefficient
## (see <Ref Oper="ClassMultiplicationCoefficient"
## Label="for character tables"/>)
## and the number of Galois
## conjugates of a class (see <Ref Oper="ClassOrbit"/>).
## 
## The classes <A>c1</A>, <A>c2</A> and <A>c3</A> in the parameter list must
## be ordered according to the order of the elements in these classes.
## If elements in class <A>c1</A> and <A>c2</A> do not generate a
## polyhedral group then <K>fail</K> is returned.
## 
## <Example><![CDATA[
## gap> NrPolyhedralSubgroups( tbl, 2, 2, 4 );
## rec( number := 21, type := "D8" )
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareGlobalFunction( "NrPolyhedralSubgroups" );

#############################################################################
##
#O ClassMultiplicationCoefficient( <tbl>, , <j>, <k> )
##
## <#GAPDoc Label="ClassMultiplicationCoefficient:ctbl">
## <ManSection>
## <Oper Name="ClassMultiplicationCoefficient" Arg='tbl, i, j, k'
## Label="for character tables"/>
##
## <Description>
## <Index Subkey="for character tables" Key="ClassMultiplicationCoefficient">
## <C>ClassMultiplicationCoefficient</C></Index>
## <Index>class multiplication coefficient</Index>
## <Index>structure constant</Index>
## returns the class multiplication coefficient of the classes <A>i</A>,
## <A>j</A>, and <A>k</A> of the group <M>G</M> with ordinary character
## table <A>tbl</A>.
## 
## The class multiplication coefficient <M>c_{{i,j,k}}</M> of the classes
## <A>i</A>, <A>j</A>, <A>k</A> equals the number of pairs <M>(x,y)</M> of
## elements <M>x, y \in G</M> such that <M>x</M> lies in class <A>i</A>,
## <M>y</M> lies in class <A>j</A>,
## and their product <M>xy</M> is a fixed element of class <A>k</A>.
## 
## In the center of the group algebra of <M>G</M>, these numbers are found
## as coefficients of the decomposition of the product of two class sums
## <M>K_i</M> and <M>K_j</M> into class sums:
## <Display Mode="M">
## K_i K_j = \sum_k c_{ijk} K_k .
## </Display>
## Given the character table of a finite group <M>G</M>,
## whose classes are <M>C_1, \ldots, C_r</M> with representatives
## <M>g_i \in C_i</M>,
## the class multiplication coefficient <M>c_{ijk}</M> can be computed
## with the following formula:
## <Display Mode="M">
## c_{ijk} = |C_i| \cdot |C_j| / |G| \cdot
## \sum_{{\chi \in Irr(G)}}
## \chi(g_i) \chi(g_j) \chi(g_k^{{-1}}) / \chi(1).
## </Display>
## 
## On the other hand the knowledge of the class multiplication coefficients
## admits the computation of the irreducible characters of <M>G</M>,
## see <Ref Attr="IrrDixonSchneider"/>.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareOperation( "ClassMultiplicationCoefficient",
 [ IsOrdinaryTable, IsPosInt, IsPosInt, IsPosInt ] );

#############################################################################
##
#F MatClassMultCoeffsCharTable( <tbl>, )
##
## <#GAPDoc Label="MatClassMultCoeffsCharTable">
## <ManSection>
## <Func Name="MatClassMultCoeffsCharTable" Arg='tbl, i'/>
##
## <Description>
## <Index>structure constant</Index>
## <Index>class multiplication coefficient</Index>
## 
## For an ordinary character table <A>tbl</A> and a class position <A>i</A>,
## <C>MatClassMultCoeffsCharTable</C> returns the matrix
## <M>[ a_{ijk} ]_{{j,k}}</M> of structure constants
## (see <Ref Oper="ClassMultiplicationCoefficient"
## Label="for character tables"/>).
## 
## <Example><![CDATA[
## gap> tbl:= CharacterTable( "L3(2)" );;
## gap> ClassMultiplicationCoefficient( tbl, 2, 2, 4 );
## 4
## gap> ClassStructureCharTable( tbl, [ 2, 2, 4 ] );
## 168
## gap> ClassStructureCharTable( tbl, [ 2, 2, 2, 4 ] );
## 1848
## gap> MatClassMultCoeffsCharTable( tbl, 2 );
## [ [ 0, 1, 0, 0, 0, 0 ], [ 21, 4, 3, 4, 0, 0 ], [ 0, 8, 6, 8, 7, 7 ],
## [ 0, 8, 6, 1, 7, 7 ], [ 0, 0, 3, 4, 0, 7 ], [ 0, 0, 3, 4, 7, 0 ] ]
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareGlobalFunction( "MatClassMultCoeffsCharTable" );

#############################################################################
##
#F ClassStructureCharTable( <tbl>, <classes> ) . . gener. class mult. coeff.
##
## <#GAPDoc Label="ClassStructureCharTable">
## <ManSection>
## <Func Name="ClassStructureCharTable" Arg='tbl, classes'/>
##
## <Description>
## <Index>class multiplication coefficient</Index>
## <Index>structure constant</Index>
## 
## returns the so-called class structure of the classes in the list
## <A>classes</A>, for the character table <A>tbl</A> of the group <M>G</M>.
## The length of <A>classes</A> must be at least 2.
## 
## Let <M>C = (C_1, C_2, \ldots, C_n)</M> denote the <M>n</M>-tuple
## of conjugacy classes of <M>G</M> that are indexed by <A>classes</A>.
## The class structure <M>n(C)</M> equals
## the number of <M>n</M>-tuples <M>(g_1, g_2, \ldots, g_n)</M> of elements
## <M>g_i \in C_i</M> with <M>g_1 g_2 \cdots g_n = 1</M>.
## Note the difference to the definition of the class multiplication
## coefficients in
## <Ref Oper="ClassMultiplicationCoefficient"
## Label="for character tables"/>.
## 
## <M>n(C_1, C_2, \ldots, C_n)</M> is computed using the formula
## <Display Mode="M">
## n(C_1, C_2, \ldots, C_n) =
## |C_1| |C_2| \cdots |C_n| / |G| \cdot
## \sum_{{\chi \in Irr(G)}}
## \chi(g_1) \chi(g_2) \cdots \chi(g_n) / \chi(1)^{{n-2}} .
## </Display>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareGlobalFunction( "ClassStructureCharTable" );

#############################################################################
##
## 8. Creating Character Tables
##
## <#GAPDoc Label="[10]{ctbl}">
## <Index>tables</Index>
## <Index>character tables</Index>
## <Index>library tables</Index>
## <Index Subkey="access to">character tables</Index>
## <Index Subkey="calculate">character tables</Index>
## <Index Subkey="of groups">character tables</Index>
## There are in general five different ways to get a character table in
## &GAP;.
## You can
## 
## <Enum>
## <Item>
## compute the table from a group,
## </Item>
## <Item>
## read a file that contains the table data,
## </Item>
## <Item>
## construct the table using generic formulae,
## </Item>
## <Item>
## derive it from known character tables, or
## </Item>
## <Item>
## combine partial information about conjugacy classes, power maps
## of the group in question, and about (character tables of) some
## subgroups and supergroups.
## </Item>
## </Enum>
## 
## In 1., the computation of the irreducible characters is the hardest part;
## the different algorithms available for this are described
## in <Ref Sect="Computing the Irreducible Characters of a Group"/>.
## Possibility 2. is used for the character tables in the
## &GAP; Character Table Library, see the manual of this library.
## Generic character tables –as addressed by 3.– are described
## in <Ref Chap="Generic Character Tables" BookName="ctbllib"/>.
## Several occurrences of 4. are described
## in <Ref Sect="Constructing Character Tables from Others"/>.
## The last of the above possibilities
## <E>is currently not supported and will be described in a chapter of its
## own when it becomes available</E>.
## 
## The operation <Ref Oper="CharacterTable" Label="for a group"/>
## can be used for the cases 1. to 3.
## <#/GAPDoc>
##

#############################################################################
##
#O CharacterTable( <G> ) . . . . . . . . . . ordinary char. table of a group
#O CharacterTable( <G>, ) . . . . . characteristic table of a group
#O CharacterTable( <ordtbl>, )
#O CharacterTable( <name>[, <param>] ) . . . . library table with given name
##
## <#GAPDoc Label="CharacterTable">
## <ManSection>
## <Heading>CharacterTable</Heading>
## <Oper Name="CharacterTable" Arg='G[, p]' Label="for a group"/>
## <Oper Name="CharacterTable" Arg='ordtbl, p'
## Label="for an ordinary character table"/>
## <Oper Name="CharacterTable" Arg='name[, param]' Label="for a string"/>
##
## <Description>
## Called with a group <A>G</A>,
## <Ref Oper="CharacterTable" Label="for a group"/> calls the
## attribute <Ref Attr="OrdinaryCharacterTable" Label="for a group"/>.
## Called with first argument a group <A>G</A> or an ordinary character
## table <A>ordtbl</A>, and second argument a prime <A>p</A>,
## <Ref Oper="CharacterTable" Label="for a group"/> calls the operation
## <Ref Oper="BrauerTable" Label="for a group, and a prime integer"/>.
## 
## Called with a string <A>name</A> and perhaps optional parameters
## <A>param</A>, <Ref Oper="CharacterTable" Label="for a string"/>
## tries to access a character table from the &GAP; Character Table Library.
## See the manual of the &GAP; package <Package>CTblLib</Package> for an
## overview of admissible arguments.
## An error is signalled if this &GAP; package is not loaded in this case.
## 
## Probably the most interesting information about the character table is
## its list of irreducibles, which can be accessed as the value of the
## attribute <Ref Attr="Irr" Label="for a character table"/>.
## If the argument of <Ref Oper="CharacterTable" Label="for a string"/> is a
## string <A>name</A> then the irreducibles are just read from the library
## file, therefore the returned table stores them already.
## However, if <Ref Oper="CharacterTable" Label="for a group"/> is called
## with a group <A>G</A> or with an ordinary character table <A>ordtbl</A>,
## the irreducible characters are <E>not</E> computed by
## <Ref Oper="CharacterTable" Label="for a group"/>.
## They are only computed when the
## <Ref Attr="Irr" Label="for a character table"/> value is accessed for
## the first time, for example when <Ref Oper="Display"/> is called for the
## table (see <Ref Sect="Printing Character Tables"/>).
## This means for example that
## <Ref Oper="CharacterTable" Label="for a group"/> returns its
## result very quickly, and the first call of <Ref Oper="Display"/> for this
## table may take some time because the irreducible characters must be
## computed at that time before they can be displayed together with other
## information stored on the character table.
## The value of the filter <C>HasIrr</C> indicates whether the irreducible
## characters have been computed already.
## 
## The reason why <Ref Oper="CharacterTable" Label="for a group"/> does not
## compute the irreducible characters is that there are situations where one
## only needs the <Q>table head</Q>, that is, the information about
## class lengths, power maps etc., but not the irreducibles.
## For example, if one wants to inspect permutation characters of a group
## then all one has to do is to induce the trivial characters of subgroups
## one is interested in; for that, only class lengths and the class fusion
## are needed.
## Or if one wants to compute the Molien series
## (see <Ref Func="MolienSeries"/>) for a given complex matrix group,
## the irreducible characters of this group are in general of no interest.
## 
## For details about different algorithms to compute the irreducible
## characters,
## see <Ref Sect="Computing the Irreducible Characters of a Group"/>.
## 
## If the group <A>G</A> is given as an argument,
## <Ref Oper="CharacterTable" Label="for a group"/> accesses the conjugacy
## classes of <A>G</A> and therefore causes that these classes are
## computed if they were not yet stored
## (see <Ref Sect="The Interface between Character Tables and Groups"/>).
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareOperation( "CharacterTable", [ IsGroup ] );
DeclareOperation( "CharacterTable", [ IsGroup, IsInt ] );
DeclareOperation( "CharacterTable", [ IsOrdinaryTable, IsInt ] );
DeclareOperation( "CharacterTable", [ IsString ] );

#############################################################################
##
#O BrauerTable( <ordtbl>, )
#O BrauerTable( <G>, )
#O BrauerTableOp( <ordtbl>, )
#A ComputedBrauerTables( <ordtbl> ) . . . . . . . . . . known Brauer tables
##
## <#GAPDoc Label="BrauerTable">
## <ManSection>
## <Heading>BrauerTable</Heading>
## <Oper Name="BrauerTable" Arg='ordtbl, p'
## Label="for a character table, and a prime integer"/>
## <Oper Name="BrauerTable" Arg='G, p'
## Label="for a group, and a prime integer"/>
## <Oper Name="BrauerTableOp" Arg='ordtbl, p'/>
## <Attr Name="ComputedBrauerTables" Arg='ordtbl'/>
##
## <Description>
## Called with an ordinary character table <A>ordtbl</A> or a
## group <A>G</A>,
## <Ref Oper="BrauerTable" Label="for a group, and a prime integer"/>
## returns its <A>p</A>-modular
## character table if &GAP; can compute this table, and <K>fail</K>
## otherwise.
## 
## The <A>p</A>-modular table can be computed in the following cases.
## 
## <List>
## <Item>
## The group is <A>p</A>-solvable (see <Ref Oper="IsPSolvable"/>,
## apply the Fong-Swan Theorem);
## </Item>
## <Item>
## the Sylow <A>p</A>-subgroup of <A>G</A> is cyclic,
## and all <A>p</A>-modular Brauer characters of <A>G</A>
## lift to ordinary characters
## (note that this situation can be detected from the ordinary
## character table of <A>G</A>);
## </Item>
## <Item>
## the table <A>ordtbl</A> stores information how it was constructed from
## other tables (as a direct product or as an isoclinic variant,
## for example),
## and the Brauer tables of the source tables can be computed;
## </Item>
## <Item>
## <A>ordtbl</A> is a table from the &GAP; character table library
## for which also the <A>p</A>-modular table is contained in the table
## library.
## </Item>
## </List>
## 
## The default method for a group and a prime delegates to
## <Ref Oper="BrauerTable" Label="for a group, and a prime integer"/>
## for the ordinary character table of this group.
## The default method for <A>ordtbl</A> uses the attribute
## <Ref Attr="ComputedBrauerTables"/> for storing the computed Brauer table
## at position <A>p</A>, and calls the operation <Ref Oper="BrauerTableOp"/>
## for computing values that are not yet known.
## 
## So if one wants to install a new method for computing Brauer tables
## then it is sufficient to install it for <Ref Oper="BrauerTableOp"/>.
## 
## The <K>mod</K> operator for a character table and a prime
## (see <Ref Sect="Operators for Character Tables"/>) delegates to
## <Ref Oper="BrauerTable" Label="for a group, and a prime integer"/>.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareOperation( "BrauerTable", [ IsOrdinaryTable, IsPosInt ] );
DeclareOperation( "BrauerTable", [ IsGroup, IsPosInt ] );

DeclareOperation( "BrauerTableOp", [ IsOrdinaryTable, IsPosInt ] );

DeclareAttribute( "ComputedBrauerTables", IsOrdinaryTable, "mutable" );

#############################################################################
##
#F CharacterTableRegular( <tbl>, ) . table consist. of -reg. classes
##
## <#GAPDoc Label="CharacterTableRegular">
## <ManSection>
## <Func Name="CharacterTableRegular" Arg='tbl, p'/>
##
## <Description>
## For an ordinary character table <A>tbl</A> and a prime integer <A>p</A>,
## <Ref Func="CharacterTableRegular"/> returns the <Q>table head</Q> of the
## <A>p</A>-modular Brauer character table of <A>tbl</A>.
## This is the restriction of <A>tbl</A> to its <A>p</A>-regular classes,
## like the return value of <Ref Oper="BrauerTable"
## Label="for a character table, and a prime integer"/>,
## but without the irreducible Brauer characters.
## (In general, these characters are hard to compute,
## and <Ref Oper="BrauerTable"
## Label="for a character table, and a prime integer"/>
## may return <K>fail</K> for the given arguments,
## for example if <A>tbl</A> is a table from the &GAP; character table
## library.)
## 
## The returned table head can be used to create <A>p</A>-modular Brauer
## characters, by restricting ordinary characters, for example when one
## is interested in approximations of the (unknown) irreducible Brauer
## characters.
## 
## <Example><![CDATA[
## gap> g:= SymmetricGroup( 4 );
## Sym( [ 1 .. 4 ] )
## gap> tbl:= CharacterTable( g );; HasIrr( tbl );
## false
## gap> tblmod2:= CharacterTable( tbl, 2 );
## BrauerTable( Sym( [ 1 .. 4 ] ), 2 )
## gap> tblmod2 = CharacterTable( tbl, 2 );
## true
## gap> tblmod2 = BrauerTable( tbl, 2 );
## true
## gap> tblmod2 = BrauerTable( g, 2 );
## true
## gap> libtbl:= CharacterTable( "M" );
## CharacterTable( "M" )
## gap> CharacterTableRegular( libtbl, 2 );
## BrauerTable( "M", 2 )
## gap> BrauerTable( libtbl, 2 );
## fail
## gap> CharacterTable( "Symmetric", 4 );
## CharacterTable( "Sym(4)" )
## gap> ComputedBrauerTables( tbl );
## [ , BrauerTable( Sym( [ 1 .. 4 ] ), 2 ) ]
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareGlobalFunction( "CharacterTableRegular" );

#############################################################################
##
#F ConvertToCharacterTable( <record> ) . . . . create character table object
#F ConvertToCharacterTableNC( <record> ) . . . create character table object
##
## <#GAPDoc Label="ConvertToCharacterTable">
## <ManSection>
## <Func Name="ConvertToCharacterTable" Arg='record'/>
## <Func Name="ConvertToCharacterTableNC" Arg='record'/>
##
## <Description>
## Let <A>record</A> be a record.
## <Ref Func="ConvertToCharacterTable"/> converts <A>record</A> into a
## component object
## (see <Ref Sect="Component Objects"/>)
## representing a character table.
## The values of those components of <A>record</A> whose names occur in
## <Ref Var="SupportedCharacterTableInfo"/>
## correspond to attribute values of the returned character table.
## All other components of the record simply become components of the
## character table object.
## 
## If inconsistencies in <A>record</A> are detected,
## <K>fail</K> is returned.
## <A>record</A> must have the component <C>UnderlyingCharacteristic</C>
## bound
## (cf. <Ref Attr="UnderlyingCharacteristic" Label="for a character table"/>),
## since this decides about whether the returned character table lies in
## <Ref Filt="IsOrdinaryTable"/> or in <Ref Filt="IsBrauerTable"/>.
## 
## <Ref Func="ConvertToCharacterTableNC"/> does the same except that all
## checks of <A>record</A> are omitted.
## 
## An example of a conversion from a record to a character table object
## can be found in Section <Ref Func="PrintCharacterTable"/>.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareGlobalFunction( "ConvertToCharacterTable" );

DeclareGlobalFunction( "ConvertToCharacterTableNC" );

#############################################################################
##
#F ConvertToLibraryCharacterTableNC( <record> )
##
## <ManSection>
## <Func Name="ConvertToLibraryCharacterTableNC" Arg='record'/>
##
## <Description>
## For a record <A>record</A> that shall be converted into an ordinary or
## Brauer character table that knows to belong to the &GAP; character table
## library, <Ref Func="ConvertToLibraryCharacterTableNC"/> does the same as
## <Ref Func="ConvertToOrdinaryTableNC"/>, except that additionally the
## filter <Ref Filt="IsLibraryCharacterTableRep"/> is set
## (see the manual of the &GAP; Character Table Library).
## 
## But if <A>record</A> has the component <C>isGenericTable</C>,
## with value <K>true</K>, then no attribute values are set.
## 
## (The handling of generic character tables may change in the future.
## Currently they are used just for specialization,
## see <Ref Chap="Generic Character Tables" BookName="ctbllib"/>.)
## </Description>
## </ManSection>
##
DeclareGlobalFunction( "ConvertToLibraryCharacterTableNC" );

#############################################################################
##
## 9. Printing Character Tables
##
## <#GAPDoc Label="[11]{ctbl}">
## <ManSection>
## <Meth Name="ViewObj" Arg='tbl' Label="for a character table"/>
##
## <Description>
## The default <Ref Oper="ViewObj"/> method for ordinary character
## tables prints the string <C>"CharacterTable"</C>,
## followed by the identifier
## (see <Ref Attr="Identifier" Label="for character tables"/>) or,
## if known, the group of the character table enclosed in brackets.
## <Ref Oper="ViewObj"/> for Brauer tables does the same, except that the
## first string is replaced by <C>"BrauerTable"</C>,
## and that the characteristic is also shown.
## </Description>
## </ManSection>
##
## <ManSection>
## <Meth Name="PrintObj" Arg='tbl' Label="for a character table"/>
##
## <Description>
## The default <Ref Oper="PrintObj"/> method for character tables
## does the same as <Ref Oper="ViewObj"/>,
## except that <Ref Oper="PrintObj"/> is used for the group instead of
## <Ref Oper="ViewObj"/>.
## </Description>
## </ManSection>
##
## <ManSection>
## <Meth Name="Display" Arg='tbl' Label="for a character table"/>
##
## <Description>
## There are various ways to customize the <Ref Oper="Display"/> output
## for character tables.
## First we describe the default behaviour,
## alternatives are then described below.
## 
## The default <Ref Oper="Display"/> method prepares the data in <A>tbl</A>
## for a columnwise output.
## The number of columns printed at one time depends on the actual
## line length, which can be accessed and changed by the function
## <Ref Func="SizeScreen"/>.
## 
## An interesting variant of <Ref Oper="Display"/> is the function
## <Ref Func="PageDisplay" BookName="gapdoc"/>.
## Convenient ways to print the <Ref Oper="Display"/> format to a file
## are given by the function <Ref Func="PrintTo1" BookName="gapdoc"/>
## or by using <Ref Func="PageDisplay" BookName="gapdoc"/> and the
## facilities of the pager used, cf. <Ref Func="Pager"/>.
## 
## An interactive variant of <Ref Oper="Display"/> is the
## <Ref Oper="Browse" BookName="browse"/> method for character tables
## that is provided by the &GAP; package <Package>Browse</Package>,
## see <Ref Meth="Browse" Label="for character tables"
## BookName="browse"/>.
## 
## <Ref Oper="Display"/> shows certain characters (by default all
## irreducible characters) of <A>tbl</A>, together with the orders of the
## centralizers in factorized form and the available power maps
## (see <Ref Attr="ComputedPowerMaps"/>).
## The <A>n</A>-th displayed character is given the name <C>X.<A>n</A></C>.
## 
## The first lines of the output describe the order of the centralizer
## of an element of the class factorized into its prime divisors.
## 
## The next line gives the name of each class.
## If no class names are stored on <A>tbl</A>,
## <Ref Attr="ClassNames"/> is called.
## 
## Preceded by a name <C>P<A>n</A></C>, the next lines show the <A>n</A>th
## power maps of <A>tbl</A> in terms of the former shown class names.
## 
## Every ambiguous or unknown (see Chapter <Ref Chap="Unknowns"/>)
## value of the table is displayed as a question mark <C>?</C>.
## 
## Irrational character values are not printed explicitly because the
## lengths of their printed representation might disturb the layout.
## Instead of that every irrational value is indicated by a name,
## which is a string of at least one capital letter.
## 
## Once a name for an irrational value is found, it is used all over the
## printed table.
## Moreover the complex conjugate (see <Ref Attr="ComplexConjugate"/>,
## <Ref Oper="GaloisCyc" Label="for a cyclotomic"/>)
## and the star of an irrationality (see <Ref Func="StarCyc"/>) are
## represented by that very name preceded by a <C>/</C> and a <C>*</C>,
## respectively.
## 
## The printed character table is then followed by a legend,
## a list identifying the occurring symbols with their actual values.
## Occasionally this identification is supplemented by a quadratic
## representation of the irrationality (see <Ref Func="Quadratic"/>)
## together with the corresponding &ATLAS; notation
## (see <Cite Key="CCN85"/>).
## 
## This default style can be changed by prescribing a record <A>arec</A> of
## options, which can be given
## 
## <Enum>
## <Item>
## as an optional argument in the call to <Ref Oper="Display"/>,
## </Item>
## <Item>
## as the value of the attribute <Ref Attr="DisplayOptions"/>
## if this value is stored in the table,
## </Item>
## <Item>
## as the value of the global variable
## <C>CharacterTableDisplayDefaults.User</C>, or
## </Item>
## <Item>
## as the value of the global variable
## <C>CharacterTableDisplayDefaults.Global</C>
## </Item>
## </Enum>
## 
## (in this order of precedence).
## 
## The following components of <A>arec</A> are supported.
## 
## <List>
## <C>centralizers</C>
## <Item>
## <K>false</K> to suppress the printing of the orders of the centralizers,
## or the string <C>"ATLAS"</C> to force the printing of non-factorized
## centralizer orders in a style similar to that used in the
## &ATLAS; of Finite Groups <Cite Key="CCN85"/>,
## </Item>
## <C>characterField</C>
## <Item>
## <K>true</K> to show the degrees of the character fields over the prime
## field, in a column with header <C>d</C>,
## </Item>
## <C>chars</C>
## <Item>
## an integer or a list of integers to select a sublist of the
## irreducible characters of <A>tbl</A>,
## or a list of characters of <A>tbl</A>
## (in the latter case, the default letter <C>"X"</C> in the character
## names is replaced by <C>"Y"</C>),
## </Item>
## <C>charnames</C>
## <Item>
## a list of strings of length equal to the number of characters
## that shall be shown; they are used as labels for the characters,
## </Item>
## <C>classes</C>
## <Item>
## an integer or a list of integers to select a sublist of the
## classes of <A>tbl</A>,
## </Item>
## <C>classnames</C>
## <Item>
## a list of strings of length equal to the number of classes
## that shall be shown; they are used as labels for the classes,
## </Item>
## <C>indicator</C>
## <Item>
## <K>true</K> enables the printing of the second Frobenius Schur
## indicator, a list of integers enables the printing of the corresponding
## indicators (see <Ref Oper="Indicator"/>),
## </Item>
## <C>letter</C>
## <Item>
## a single capital letter (e. g. <C>"P"</C> for permutation
## characters) to replace the default <C>"X"</C> in character names,
## </Item>
## <C>powermap</C>
## <Item>
## an integer or a list of integers to select a subset of the
## available power maps,
## <K>false</K> to suppress the printing of power maps,
## or the string <C>"ATLAS"</C> to force a printing of class names and
## power maps in a style similar to that used in the
## &ATLAS; of Finite Groups <Cite Key="CCN85"/>
## (the <C>"ATLAS"</C> variant works only if the function
## <Ref Func="CambridgeMaps" BookName="ctbllib"/> is available,
## which belongs to the <Package>CTblLib</Package> package),
## </Item>
## <C>Display</C>
## <Item>
## the function that is actually called in order to display the table;
## the arguments are the table and the optional record, whose components
## can be used inside the <C>Display</C> function,
## </Item>
## <C>StringEntry</C>
## <Item>
## a function that takes either a character value or a character value
## and the return value of <C>StringEntryData</C> (see below),
## and returns the string that is actually displayed;
## it is called for all character values to be displayed,
## and also for the displayed indicator values (see above),
## </Item>
## <C>StringEntryData</C>
## <Item>
## a unary function that is called once with argument <A>tbl</A> before
## the character values are displayed;
## it returns an object that is used as second argument of the function
## <C>StringEntry</C>,
## </Item>
## <C>Legend</C>
## <Item>
## a function that takes the result of the <C>StringEntryData</C> call as
## its only argument, after the character table has been displayed;
## the return value is a string that describes the symbols used in the
## displayed table in a formatted way,
## it is printed below the displayed table.
## </Item>
## </List>
## </Description>
## </ManSection>
## <#/GAPDoc>
##

#############################################################################
##
#A DisplayOptions( <tbl> )
##
## <#GAPDoc Label="DisplayOptions">
## <ManSection>
## <Attr Name="DisplayOptions" Arg='tbl'/>
##
## <Description>
## 
## There is no default method to compute a value,
## one can set a value with <C>SetDisplayOptions</C>.
## 
## <Example><![CDATA[
## gap> tbl:= CharacterTable( "A5" );;
## gap> Display( tbl );
## A5
##
## 2 2 2 . . .
## 3 1 . 1 . .
## 5 1 . . 1 1
##
## 1a 2a 3a 5a 5b
## 2P 1a 1a 3a 5b 5a
## 3P 1a 2a 1a 5b 5a
## 5P 1a 2a 3a 1a 1a
##
## X.1 1 1 1 1 1
## X.2 3 -1 . A *A
## X.3 3 -1 . *A A
## X.4 4 . 1 -1 -1
## X.5 5 1 -1 . .
##
## A = -E(5)-E(5)^4
## = (1-Sqrt(5))/2 = -b5
## gap> CharacterTableDisplayDefaults.User:= rec(
## > powermap:= "ATLAS", centralizers:= "ATLAS", chars:= false );;
## gap> Display( CharacterTable( "A5" ) );
## A5
##
## 60 4 3 5 5
##
## p A A A A
## p' A A A A
## 1A 2A 3A 5A B*
##
## gap> options:= rec( chars:= 4, classes:= [ tbl.3a .. tbl.5a ],
## > centralizers:= false, indicator:= true,
## > powermap:= [ 2 ] );;
## gap> Display( tbl, options );
## A5
##
## 3a 5a
## 2P 3a 5b
## 2
## X.4 + 1 -1
## gap> SetDisplayOptions( tbl, options ); Display( tbl );
## A5
##
## 3a 5a
## 2P 3a 5b
## 2
## X.4 + 1 -1
## gap> Unbind( CharacterTableDisplayDefaults.User );
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "DisplayOptions", IsNearlyCharacterTable );

#############################################################################
##
#V CharacterTableDisplayDefaults
##
## <ManSection>
## <Var Name="CharacterTableDisplayDefaults"/>
##
## <Description>
## This is a record with at least the component <C>Global</C>, which is used
## as the default value for the second argument of <Ref Oper="Display"/> for
## character tables.
## 
## If also the component <C>User</C> is bound then this value is taken
## instead.
## So one can customize the default behaviour of <Ref Oper="Display"/> by
## adding this component, and return to the previous behaviour by unbinding
## it.
## </Description>
## </ManSection>
##
DeclareGlobalName( "CharacterTableDisplayDefaults" );

#############################################################################
##
#F PrintCharacterTable( <tbl>, <varname> )
##
## <#GAPDoc Label="PrintCharacterTable">
## <ManSection>
## <Func Name="PrintCharacterTable" Arg='tbl, varname'/>
##
## <Description>
## Let <A>tbl</A> be a nearly character table, and <A>varname</A> a string.
## <Ref Func="PrintCharacterTable"/> prints those values of the supported
## attributes (see <Ref Var="SupportedCharacterTableInfo"/>) that are
## known for <A>tbl</A>.
## 
## 
## The output of <Ref Func="PrintCharacterTable"/> is &GAP; readable;
## actually reading it into &GAP; will bind the variable with name
## <A>varname</A> to a character table that coincides with <A>tbl</A> for
## all printed components.
## 
## This is used mainly for saving character tables to files.
## A more human readable form is produced by <Ref Oper="Display"/>.
## 
## 
## 
## <Example><![CDATA[
## gap> PrintCharacterTable( CharacterTable( "Cyclic", 2 ), "tbl" );
## tbl:= function()
## local tbl, i;
## tbl:=rec();
## tbl.Irr:=
## [ [ 1, 1 ], [ 1, -1 ] ];
## tbl.IsFinite:=
## true;
## tbl.NrConjugacyClasses:=
## 2;
## tbl.Size:=
## 2;
## tbl.OrdersClassRepresentatives:=
## [ 1, 2 ];
## tbl.SizesCentralizers:=
## [ 2, 2 ];
## tbl.UnderlyingCharacteristic:=
## 0;
## tbl.ClassParameters:=
## [ [ 1, 0 ], [ 1, 1 ] ];
## tbl.CharacterParameters:=
## [ [ 1, 0 ], [ 1, 1 ] ];
## tbl.Identifier:=
## "C2";
## tbl.InfoText:=
## "computed using generic character table for cyclic groups";
## tbl.ComputedPowerMaps:=
## [ , [ 1, 1 ] ];
## ConvertToLibraryCharacterTableNC(tbl);
## return tbl;
## end;
## tbl:= tbl();
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareGlobalFunction( "PrintCharacterTable" );

#############################################################################
##
## 10. Constructing Character Tables from Others
##
## <#GAPDoc Label="[12]{ctbl}">
## The following operations take one or more character table arguments,
## and return a character table.
## This holds also for <Ref Oper="BrauerTable"
## Label="for a character table, and a prime integer"/>.
## Note that the return value of <Ref Oper="BrauerTable"
## Label="for a character table, and a prime integer"/>
## will in general not know the irreducible Brauer characters,
## and &GAP; might be unable to compute these characters.
## 
## <E>Note</E> that whenever fusions between input and output tables occur
## in these operations,
## they are stored on the concerned tables,
## and the <Ref Attr="NamesOfFusionSources"/> values are updated.
## 
## (The interactive construction of character tables using character
## theoretic methods and incomplete tables is not described here.)
## <E>Currently it is not supported and will be described in a chapter of its
## own when it becomes available</E>.
## <#/GAPDoc>
##

#############################################################################
##
#O CharacterTableDirectProduct( <tbl1>, <tbl2> )
##
## <#GAPDoc Label="CharacterTableDirectProduct">
## <ManSection>
## <Oper Name="CharacterTableDirectProduct" Arg='tbl1, tbl2'/>
##
## <Description>
## is the table of the direct product of the character tables <A>tbl1</A>
## and <A>tbl2</A>.
## 
## The matrix of irreducibles of this table is the Kronecker product
## (see <Ref Oper="KroneckerProduct"/>) of the irreducibles of
## <A>tbl1</A> and <A>tbl2</A>.
## 
## Products of ordinary and Brauer character tables are supported.
## 
## In general, the result will not know an underlying group,
## so missing power maps (for prime divisors of the result)
## and irreducibles of the input tables may be computed in order to
## construct the table of the direct product.
## 
## The embeddings of the input tables into the direct product are stored,
## they can be fetched with <Ref Func="GetFusionMap"/>;
## if <A>tbl1</A> is equal to <A>tbl2</A> then the two embeddings are
## distinguished by their <C>specification</C> components <C>"1"</C> and
## <C>"2"</C>, respectively.
## 
## Analogously, the projections from the direct product onto the input
## tables are stored, and can be distinguished by the <C>specification</C>
## components.
## 
## 
## The attribute <Ref Attr="FactorsOfDirectProduct"/>
## is set to the lists of arguments.
## 
## The <C>*</C> operator for two character tables
## (see <Ref Sect="Operators for Character Tables"/>) delegates to
## <Ref Oper="CharacterTableDirectProduct"/>.
## <Example><![CDATA[
## gap> c2:= CharacterTable( "Cyclic", 2 );;
## gap> s3:= CharacterTable( "Symmetric", 3 );;
## gap> Display( CharacterTableDirectProduct( c2, s3 ) );
## C2xSym(3)
##
## 2 2 2 1 2 2 1
## 3 1 . 1 1 . 1
##
## 1a 2a 3a 2b 2c 6a
## 2P 1a 1a 3a 1a 1a 3a
## 3P 1a 2a 1a 2b 2c 2b
##
## X.1 1 -1 1 1 -1 1
## X.2 2 . -1 2 . -1
## X.3 1 1 1 1 1 1
## X.4 1 -1 1 -1 1 -1
## X.5 2 . -1 -2 . 1
## X.6 1 1 1 -1 -1 -1
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareOperation( "CharacterTableDirectProduct",
 [ IsNearlyCharacterTable, IsNearlyCharacterTable ] );

#############################################################################
##
#A FactorsOfDirectProduct( <tbl> )
##
## <#GAPDoc Label="FactorsOfDirectProduct">
## <ManSection>
## <Attr Name="FactorsOfDirectProduct" Arg='tbl'/>
##
## <Description>
## For an ordinary character table that has been constructed via
## <Ref Oper="CharacterTableDirectProduct"/>,
## the value of <Ref Attr="FactorsOfDirectProduct"/> is the list of
## arguments in the <Ref Oper="CharacterTableDirectProduct"/> call.
## 
## Note that there is no default method for <E>computing</E> the value of
## <Ref Attr="FactorsOfDirectProduct"/>.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttributeSuppCT( "FactorsOfDirectProduct", IsNearlyCharacterTable,
 [] );

#############################################################################
##
#F CharacterTableHeadOfFactorGroupByFusion( <tbl>, <factorfusion> )
##
## <ManSection>
## <Func Name="CharacterTableHeadOfFactorGroupByFusion"
## Arg='tbl, factorfusion'/>
##
## <Description>
## is the character table of the factor group of the ordinary character
## table <A>tbl</A> defined by the list <A>factorfusion</A> that describes
## the factor fusion.
## The irreducible characters of the factor group are <E>not</E> computed.
## </Description>
## </ManSection>
##
DeclareGlobalFunction( "CharacterTableHeadOfFactorGroupByFusion" );

#############################################################################
##
#O CharacterTableFactorGroup( <tbl>, <classes> )
##
## <#GAPDoc Label="CharacterTableFactorGroup">
## <ManSection>
## <Oper Name="CharacterTableFactorGroup" Arg='tbl, classes'/>
##
## <Description>
## is the character table of the factor group of the ordinary character
## table <A>tbl</A> by the normal closure of the classes whose positions are
## contained in the list <A>classes</A>.
## 
## The <C>/</C> operator for a character table and a list of class positions
## (see <Ref Sect="Operators for Character Tables"/>) delegates to
## <Ref Oper="CharacterTableFactorGroup"/>.
## 
## <Example><![CDATA[
## gap> s4:= CharacterTable( "Symmetric", 4 );;
## gap> ClassPositionsOfNormalSubgroups( s4 );
## [ [ 1 ], [ 1, 3 ], [ 1, 3, 4 ], [ 1 .. 5 ] ]
## gap> f:= CharacterTableFactorGroup( s4, [ 3 ] );
## CharacterTable( "Sym(4)/[ 1, 3 ]" )
## gap> Display( f );
## Sym(4)/[ 1, 3 ]
##
## 2 1 1 .
## 3 1 . 1
##
## 1a 2a 3a
## 2P 1a 1a 3a
## 3P 1a 2a 1a
##
## X.1 1 -1 1
## X.2 2 . -1
## X.3 1 1 1
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareOperation( "CharacterTableFactorGroup",
 [ IsNearlyCharacterTable, IsHomogeneousList ] );

#############################################################################
##
#A CharacterTableIsoclinic( <tbl> )
#O CharacterTableIsoclinic( <tbl>, <arec> )
#O CharacterTableIsoclinic( <modtbl>, <ordiso> )
#O CharacterTableIsoclinic( <tbl>[, <classes>][, <centre>] )
#A SourceOfIsoclinicTable( <tbl> )
##
## <#GAPDoc Label="CharacterTableIsoclinic">
## <ManSection>
## <Oper Name="CharacterTableIsoclinic" Arg='tbl[, arec]'/>
## <Oper Name="CharacterTableIsoclinic" Arg='tbl[, classes][, centre]'
## Label="for a character table and one or two lists"/>
## <Oper Name="CharacterTableIsoclinic" Arg='modtbl, ordiso'
## Label="for a Brauer table and an ordinary table"/>
## <Attr Name="SourceOfIsoclinicTable" Arg='tbl'/>
##
## <Description>
## Let <A>tbl</A> be the (ordinary or modular) character table of a group
## <M>H</M> with the structure <M>p.G.p</M> for some prime <M>p</M>,
## that is, <M>H/Z</M> has a normal subgroup <M>N</M> of index <M>p</M>
## and a central subgroup <M>Z</M> of order <M>p</M> contained in <M>N</M>.
## 
## Then <Ref Oper="CharacterTableIsoclinic"/> returns
## the table of an isoclinic group in the sense of the
## &ATLAS; of Finite Groups
## <Cite Key="CCN85" Where="Chapter 6, Section 7"/>.
## 
## If <M>p = 2</M> then also the case <M>H = 4.G.2</M> is supported,
## that is, <M>Z</M> has order four and <M>N</M> has index two in <M>H</M>.
## 
## The optional arguments are needed if <A>tbl</A> does not determine
## the class positions of <M>N</M> or <M>Z</M> uniquely,
## and in the case <M>p > 2</M> if one wants to specify a
## <Q>variant number</Q> for the result.
## 
## <List>
## <Item>
## In general, the values can be specified via a record <A>arec</A>.
## If <M>N</M> is not uniquely determined then the positions of the
## classes forming <M>N</M> must be entered as the value of the component
## <C>normalSubgroup</C>.
## If <M>Z</M> is not unique inside <M>N</M> then the class position of
## a generator of <M>Z</M> must be entered as the value of the
## component <C>centralElement</C>.
## </Item>
## <Item>
## If <M>p = 2</M> then one may specify the positions of the classes
## forming <M>N</M> via a list <A>classes</A>,
## and the positions of the classes in <M>Z</M> as a list <A>centre</A>;
## if <M>Z</M> has order <M>2</M> then <A>centre</A> can be also the
## position of the involution in <M>Z</M>.
## </Item>
## </List>
## 
## Note that also if <A>tbl</A> is a Brauer table then <C>normalSubgroup</C>
## and <C>centralElement</C>, resp. <A>classes</A> and <A>centre</A>,
## denote class numbers w.r.t. the <E>ordinary</E> character table.
## 
## If <M>p</M> is odd then the &ATLAS; construction describes <M>p</M>
## isoclinic variants that arise from <M>p.G.p</M>.
## (These groups need not be pairwise nonisomorphic.)
## Entering an integer <M>k \in \{ 1, 2, \ldots, p-1 \}</M> as the value of
## the component <C>k</C> of <A>arec</A> yields the <M>k</M>-th of the
## corresponding character tables; the default for <C>k</C> is <M>1</M>.
## 
## <Example><![CDATA[
## gap> d8:= CharacterTable( "Dihedral", 8 );
## CharacterTable( "Dihedral(8)" )
## gap> nsg:= ClassPositionsOfNormalSubgroups( d8 );
## [ [ 1 ], [ 1, 3 ], [ 1 .. 3 ], [ 1, 3, 4 ], [ 1, 3 .. 5 ], [ 1 .. 5 ]
## ]
## gap> isod8:= CharacterTableIsoclinic( d8, nsg[3] );;
## gap> Display( isod8 );
## Isoclinic(Dihedral(8))
##
## 2 3 2 3 2 2
##
## 1a 4a 2a 4b 4c
## 2P 1a 2a 1a 2a 2a
##
## X.1 1 1 1 1 1
## X.2 1 1 1 -1 -1
## X.3 1 -1 1 1 -1
## X.4 1 -1 1 -1 1
## X.5 2 . -2 . .
## gap> t1:= CharacterTable( SmallGroup( 27, 3 ) );;
## gap> t2:= CharacterTable( SmallGroup( 27, 4 ) );;
## gap> nsg:= ClassPositionsOfNormalSubgroups( t1 );
## [ [ 1 ], [ 1, 4, 8 ], [ 1, 2, 4, 5, 8 ], [ 1, 3, 4, 7, 8 ],
## [ 1, 4, 6, 8, 11 ], [ 1, 4, 8, 9, 10 ], [ 1 .. 11 ] ]
## gap> iso1:= CharacterTableIsoclinic( t1, rec( k:= 1,
## > normalSubgroup:= nsg[3] ) );;
## gap> iso2:= CharacterTableIsoclinic( t1, rec( k:= 2,
## > normalSubgroup:= nsg[3] ) );;
## gap> TransformingPermutationsCharacterTables( iso1, t1 ) <> fail;
## false
## gap> TransformingPermutationsCharacterTables( iso1, t2 ) <> fail;
## true
## gap> TransformingPermutationsCharacterTables( iso2, t2 ) <> fail;
## true
## ]]></Example>
## 
## For an ordinary character table that has been constructed via
## <Ref Oper="CharacterTableIsoclinic"/>,
## the value of <Ref Attr="SourceOfIsoclinicTable"/> encodes this
## construction, and is defined as follows.
## If <M>p = 2</M> then the value is the list with entries <A>tbl</A>,
## <A>classes</A>, the list of class positions of the nonidentity
## elements in <M>Z</M>, and the class position of a generator of <M>Z</M>.
## If <M>p</M> is an odd prime then the value is a record with the
## following components.
## 
## <List>
## <C>table</C>
## <Item>
## the character table <A>tbl</A>,
## </Item>
## <C>p</C>
## <Item>
## the prime <M>p</M>,
## </Item>
## <C>k</C>
## <Item>
## the variant number <M>k</M>,
## </Item>
## <C>outerClasses</C>
## <Item>
## the list of length <M>p-1</M> that contains at position <M>i</M>
## the sorted list of class positions of the <M>i</M>-th coset of the
## normal subgroup <M>N</M>
## </Item>
## <C>centralElement</C>
## <Item>
## the class position of a generator of the central subgroup <M>Z</M>.
## </Item>
## </List>
## 
## There is no default method for <E>computing</E> the value of
## <Ref Attr="SourceOfIsoclinicTable"/>.
## 
## <Example><![CDATA[
## gap> SourceOfIsoclinicTable( isod8 );
## [ CharacterTable( "Dihedral(8)" ), [ 1 .. 3 ], [ 3 ], 3 ]
## gap> SourceOfIsoclinicTable( iso1 );
## rec( centralElement := 4, k := 1,
## outerClasses := [ [ 3, 6, 9 ], [ 7, 10, 11 ] ], p := 3,
## table := CharacterTable( <pc group of size 27 with 3 generators> ) )
## ]]></Example>
## 
## If the arguments of <Ref Oper="CharacterTableIsoclinic"/> are
## a Brauer table <A>modtbl</A> and an ordinary table <A>ordiso</A>
## then the <Ref Attr="SourceOfIsoclinicTable"/> value of <A>ordiso</A>
## is assumed to be identical with the
## <Ref Attr="OrdinaryCharacterTable" Label="for a character table"/>
## value of <A>modtbl</A>,
## and the specified isoclinic table of <A>modtbl</A> is returned.
## This variant is useful if one has already constructed <A>ordiso</A>
## in advance.
## 
## <Example><![CDATA[
## gap> g:= GL(2,3);;
## gap> t:= CharacterTable( g );;
## gap> iso:= CharacterTableIsoclinic( t );;
## gap> t3:= t mod 3;;
## gap> iso3:= CharacterTableIsoclinic( t3, iso );;
## gap> TransformingPermutationsCharacterTables( iso3,
## > CharacterTableIsoclinic( t3 ) ) <> fail;
## true
## ]]></Example>
## 
## <E>Theoretical background:</E>
## Consider the central product <M>K</M> of <M>H</M> with a cyclic group
## <M>C</M> of order <M>p^2</M>.
## That is, <M>K = H C</M>, <M>C \leq Z(K)</M>, and the central subgroup
## <M>Z</M> of order <M>p</M> in <M>H</M> lies in <M>C</M>.
## There are <M>p+1</M> subgroups of <M>K</M> that contain
## the normal subgroup <M>N</M> of index <M>p</M> in <M>H</M>.
## One of them is the central product of <M>C</M> with <M>N</M>,
## the others are <M>H_0 = H</M> and its isoclinic variants
## <M>H_1, H_2, \ldots, H_{{p-1}}</M>.
## We fix <M>g \in H \setminus N</M> and a generator <M>z</M> of <M>C</M>,
## and get <M>H = N \cup N g \cup N g^2 \cup \cdots \cup N g^{{p-1}}</M>.
## Then <M>H_k</M>, <M>0 \leq k \leq p-1</M>, is given by
## <M>N \cup N gz^k \cup N (gz^k)^2 \cup \cdots \cup N (gz^k)^{{p-1}}</M>.
## The conjugacy classes of all <M>H_k</M> are in bijection via multiplying
## the elements with suitable powers of <M>z</M>,
## and the irreducible characters of all <M>H_k</M> extend to <M>K</M> and
## are in bijection via multiplying the character values with suitable
## <M>p^2</M>-th roots of unity.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttributeSuppCT( "SourceOfIsoclinicTable", IsNearlyCharacterTable,
 [] );

DeclareAttribute( "CharacterTableIsoclinic", IsNearlyCharacterTable );

DeclareOperation( "CharacterTableIsoclinic",
 [ IsNearlyCharacterTable, IsRecord ] );
DeclareOperation( "CharacterTableIsoclinic",
 [ IsNearlyCharacterTable, IsList and IsCyclotomicCollection ] );
DeclareOperation( "CharacterTableIsoclinic",
 [ IsBrauerTable, IsOrdinaryTable and HasSourceOfIsoclinicTable ] );

DeclareOperation( "CharacterTableIsoclinic",
 [ IsNearlyCharacterTable, IsPosInt ] );
DeclareOperation( "CharacterTableIsoclinic",
 [ IsNearlyCharacterTable, IsList and IsCyclotomicCollection, IsPosInt ]);
DeclareOperation( "CharacterTableIsoclinic",
 [ IsNearlyCharacterTable, IsList and IsCyclotomicCollection,
 IsList and IsCyclotomicCollection ] );

#############################################################################
##
#F CharacterTableOfNormalSubgroup( <ordtbl>, <classes> )
##
## <#GAPDoc Label="CharacterTableOfNormalSubgroup">
## <ManSection>
## <Func Name="CharacterTableOfNormalSubgroup" Arg='ordtbl, classes'/>
##
## <Description>
## Let <A>ordtbl</A> be the ordinary character table of a group <M>G</M>,
## say, and <A>classes</A> be a list of class positions for this table.
## If the classes given by <A>classes</A> form a normal subgroup <M>N</M>,
## say, of <M>G</M> and if these classes are conjugacy classes of <M>N</M>
## then this function returns the character table of <M>N</M>.
## In all other cases, the function returns <K>fail</K>.
## 
## <Example><![CDATA[
## gap> t:= CharacterTable( "Symmetric", 4 );
## CharacterTable( "Sym(4)" )
## gap> nsg:= ClassPositionsOfNormalSubgroups( t );
## [ [ 1 ], [ 1, 3 ], [ 1, 3, 4 ], [ 1 .. 5 ] ]
## gap> rest:= List( nsg, c -> CharacterTableOfNormalSubgroup( t, c ) );
## [ CharacterTable( "Rest(Sym(4),[ 1 ])" ), fail, fail,
## CharacterTable( "Rest(Sym(4),[ 1 .. 5 ])" ) ]
## ]]></Example>
## 
## Here is a nontrivial example.
## We use <Ref Func="CharacterTableOfNormalSubgroup"/> for computing the
## two isoclinic variants of <M>2.A_5.2</M>.
## 
## <Example><![CDATA[
## gap> g:= SchurCoverOfSymmetricGroup( 5, 3, 1 );;
## gap> c:= CyclicGroup( 4 );;
## gap> dp:= DirectProduct( g, c );;
## gap> diag:= First( Elements( Centre( dp ) ),
## > x -> Order( x ) = 2 and
## > not x in Image( Embedding( dp, 1 ) ) and
## > not x in Image( Embedding( dp, 2 ) ) );;
## gap> fact:= Image( NaturalHomomorphismByNormalSubgroup( dp,
## > Subgroup( dp, [ diag ] ) ));;
## gap> t:= CharacterTable( fact );;
## gap> Size( t );
## 480
## gap> nsg:= ClassPositionsOfNormalSubgroups( t );;
## gap> rest:= List( nsg, c -> CharacterTableOfNormalSubgroup( t, c ) );;
## gap> index2:= Filtered( rest, x -> x <> fail and Size( x ) = 240 );;
## gap> Length( index2 );
## 2
## gap> tg:= CharacterTable( g );;
## gap> SortedList(List(index2,x->IsRecord(
## > TransformingPermutationsCharacterTables(x,tg))));
## [ true, false ]
## ]]></Example>
## 
## Alternatively, we could construct the character table of the central
## product with character theoretic methods.
## Or we could use <Ref Oper="CharacterTableIsoclinic"/>.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareGlobalFunction( "CharacterTableOfNormalSubgroup" );

#############################################################################
##
## 11. Sorted Character Tables
##

#############################################################################
##
#F PermutationToSortCharacters( <tbl>, <chars>, <degree>, <norm>, <galois> )
##
## <ManSection>
## <Func Name="PermutationToSortCharacters"
## Arg='tbl, chars, degree, norm, galois'/>
##
## <Description>
## returns a permutation <M>\pi</M> that can be applied to the list
## <A>chars</A> of characters of the character table <A>tbl</A> in order to
## sort this list w.r.t. increasing degree, norm, or both.
## The arguments <A>degree</A>, <A>norm</A>, and <A>galois</A> must be
## Booleans.
## If <A>norm</A> is <K>true</K> then characters of smaller norm precede
## characters of larger norm after permuting with <M>\pi</M>.
## If both <A>degree</A> and <A>norm</A> are <K>true</K> then additionally
## characters of same norm are sorted w.r.t. increasing degree after
## permuting with <M>\pi</M>.
## If only <A>degree</A> is <K>true</K> then characters of smaller degree
## precede characters of larger degree after permuting with <M>\pi</M>.
## If <A>galois</A> is <K>true</K> then each family of algebraic conjugate
## characters in <A>chars</A> is consecutive after permuting with
## <M>\pi</M>.
## 
## Rational characters in the permuted list precede characters with
## irrationalities of same norm and/or degree, and the trivial character
## will be sorted to position <M>1</M> if it occurs in <A>chars</A>.
## </Description>
## </ManSection>
##
DeclareGlobalFunction( "PermutationToSortCharacters" );

#############################################################################
##
#O CharacterTableWithSortedCharacters( <tbl>[, <perm>] )
##
## <#GAPDoc Label="CharacterTableWithSortedCharacters">
## <ManSection>
## <Oper Name="CharacterTableWithSortedCharacters" Arg='tbl[, perm]'/>
##
## <Description>
## is a character table that differs from <A>tbl</A> only by the succession
## of its irreducible characters.
## This affects the values of the attributes
## <Ref Attr="Irr" Label="for a character table"/> and
## <Ref Attr="CharacterParameters"/>.
## Namely, these lists are permuted by the permutation <A>perm</A>.
## 
## If no second argument is given then a permutation is used that yields
## irreducible characters of increasing degree for the result.
## For the succession of characters in the result,
## see <Ref Oper="SortedCharacters"/>.
## 
## The result has all those attributes and properties of <A>tbl</A> that are
## stored in <Ref Var="SupportedCharacterTableInfo"/> and do not depend
## on the ordering of characters.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareOperation( "CharacterTableWithSortedCharacters",
 [ IsNearlyCharacterTable ] );
DeclareOperation( "CharacterTableWithSortedCharacters",
 [ IsNearlyCharacterTable, IsPerm ] );

#############################################################################
##
#O SortedCharacters( <tbl>, <chars> )
#O SortedCharacters( <tbl>, <chars>, "norm" )
#O SortedCharacters( <tbl>, <chars>, "degree" )
##
## <#GAPDoc Label="SortedCharacters">
## <ManSection>
## <Oper Name="SortedCharacters" Arg='tbl, chars[, flag]'/>
##
## <Description>
## is a list containing the characters <A>chars</A>, ordered as specified
## by the other arguments.
## 
## There are three possibilities to sort characters:
## They can be sorted according to ascending norms
## (<A>flag</A> is the string <C>"norm"</C>),
## to ascending degree (<A>flag</A> is the string <C>"degree"</C>),
## or both (no third argument is given),
## i.e., characters with same norm are sorted according to ascending degree,
## and characters with smaller norm precede those with bigger norm.
## 
## Rational characters in the result precede other ones with same norm
## and/or same degree.
## 
## The trivial character, if contained in <A>chars</A>, will always be
## sorted to the first position.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareOperation( "SortedCharacters",
 [ IsNearlyCharacterTable, IsHomogeneousList ] );
DeclareOperation( "SortedCharacters",
 [ IsNearlyCharacterTable, IsHomogeneousList, IsString ] );

#############################################################################
##
#F PermutationToSortClasses( <tbl>, <classes>, <orders>, <galois> )
##
## <ManSection>
## <Func Name="PermutationToSortClasses"
## Arg='tbl, classes, orders, galois'/>
##
## <Description>
## returns a permutation <M>\pi</M> that can be applied to the columns
## in the character table <A>tbl</A> in order to sort this table
## w.r.t. increasing class length, element order, or both.
## <A>classes</A> and <A>orders</A> must be Booleans.
## If <A>orders</A> is <K>true</K> then classes of element of smaller order
## precede classes of elements of larger order after peruting with
## <M>\pi</M>.
## If both <A>classes</A> and <A>orders</A> are <K>true</K> then
## additionally classes of elements of the same order are sorted
## w.r.t. increasing length after permuting with <M>\pi</M>.
## If <A>classes</A> is <K>true</K> but <A>orders</A> is <K>false</K> then
## smaller classes precede larger ones after permuting with <M>\pi</M>.
## If <A>galois</A> is <K>true</K> then each family of algebraic conjugate
## classes in <A>tbl</A> is consecutive after permuting with <M>\pi</M>.
## </Description>
## </ManSection>
##
DeclareGlobalFunction( "PermutationToSortClasses" );

#############################################################################
##
#O CharacterTableWithSortedClasses( <tbl> )
#O CharacterTableWithSortedClasses( <tbl>, "centralizers" )
#O CharacterTableWithSortedClasses( <tbl>, "representatives" )
#O CharacterTableWithSortedClasses( <tbl>, <permutation> )
##
## <#GAPDoc Label="CharacterTableWithSortedClasses">
## <ManSection>
## <Oper Name="CharacterTableWithSortedClasses" Arg='tbl[, flag]'/>
##
## <Description>
## is a character table obtained by permutation of the classes of
## <A>tbl</A>.
## If the second argument <A>flag</A> is the string <C>"centralizers"</C>
## then the classes of the result are sorted according to descending
## centralizer orders.
## If the second argument is the string <C>"representatives"</C> then the
## classes of the result are sorted according to ascending representative
## orders.
## If no second argument is given then the classes of the result are sorted
## according to ascending representative orders,
## and classes with equal representative orders are sorted according to
## descending centralizer orders.
## 
## If the second argument is a permutation then the classes of the
## result are sorted by application of this permutation.
## 
## The result has all those attributes and properties of <A>tbl</A> that are
## stored in <Ref Var="SupportedCharacterTableInfo"/> and do not depend
## on the ordering of classes.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareOperation( "CharacterTableWithSortedClasses",
 [ IsNearlyCharacterTable ] );
DeclareOperation( "CharacterTableWithSortedClasses",
 [ IsNearlyCharacterTable, IsString ] );
DeclareOperation( "CharacterTableWithSortedClasses",
 [ IsNearlyCharacterTable, IsPerm ] );

#############################################################################
##
#F SortedCharacterTable( <tbl>, <kernel> )
#F SortedCharacterTable( <tbl>, <normalseries> )
#F SortedCharacterTable( <tbl>, <facttbl>, <kernel> )
##
## <#GAPDoc Label="SortedCharacterTable">
## <ManSection>
## <Func Name="SortedCharacterTable" Arg='tbl, kernel'
## Label="w.r.t. a normal subgroup"/>
## <Func Name="SortedCharacterTable" Arg='tbl, normalseries'
## Label="w.r.t. a series of normal subgroups"/>
## <Func Name="SortedCharacterTable" Arg='tbl, facttbl, kernel'
## Label="relative to the table of a factor group"/>
##
## <Description>
## is a character table obtained on permutation of the classes and the
## irreducibles characters of <A>tbl</A>.
## 
## The first form sorts the classes at positions contained in the list
## <A>kernel</A> to the beginning, and sorts all characters in
## <C>Irr( <A>tbl</A> )</C> such that the first characters are those that
## contain <A>kernel</A> in their kernel.
## 
## The second form does the same successively for all kernels <M>k_i</M> in
## the list <M><A>normalseries</A> = [ k_1, k_2, \ldots, k_n ]</M> where
## <M>k_i</M> must be a sublist of <M>k_{{i+1}}</M> for
## <M>1 \leq i \leq n-1</M>.
## 
## The third form computes the table <M>F</M> of the factor group of
## <A>tbl</A> modulo the normal subgroup formed by the classes whose
## positions are contained in the list <A>kernel</A>;
## <M>F</M> must be permutation equivalent to the table <A>facttbl</A>,
## in the sense of <Ref Oper="TransformingPermutationsCharacterTables"/>,
## otherwise <K>fail</K> is returned.
## The classes of <A>tbl</A> are sorted such that the preimages
## of a class of <M>F</M> are consecutive,
## and that the succession of preimages is that of <A>facttbl</A>.
## The <Ref Attr="Irr" Label="for a character table"/> value of <A>tbl</A>
## is sorted as with <C>SortedCharacterTable( <A>tbl</A>, <A>kernel</A> )</C>.
## 
## (<E>Note</E> that the transformation is only unique up to table
## automorphisms of <M>F</M>, and this need not be unique up to table
## automorphisms of <A>tbl</A>.)
## 
## All rearrangements of classes and characters are stable,
## i.e., the relative positions of classes and characters that are not
## distinguished by any relevant property is not changed.
## 
## The result has all those attributes and properties of <A>tbl</A> that are
## stored in <Ref Var="SupportedCharacterTableInfo"/> and do not depend on
## the ordering of classes and characters.
## 
## The <Ref Attr="ClassPermutation"/> value of <A>tbl</A> is changed if
## necessary, see <Ref Sect="Conventions for Character Tables"/>.
## 
## <Ref Func="SortedCharacterTable" Label="w.r.t. a normal subgroup"/>
## uses <Ref Oper="CharacterTableWithSortedClasses"/> and
## <Ref Oper="CharacterTableWithSortedCharacters"/>.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareGlobalFunction( "SortedCharacterTable" );

#############################################################################
##
#A ClassPermutation( <tbl> )
##
## <#GAPDoc Label="ClassPermutation">
## <ManSection>
## <Attr Name="ClassPermutation" Arg='tbl'/>
##
## <Description>
## is a permutation <M>\pi</M> of classes of the character table <A>tbl</A>.
## If it is stored then class fusions into <A>tbl</A> that are stored on
## other tables must be followed by <M>\pi</M> in order to describe the
## correct fusion.
## 
## This attribute value is bound only if <A>tbl</A> was obtained from another
## table by permuting the classes,
## using <Ref Oper="CharacterTableWithSortedClasses"/>
## or <Ref Func="SortedCharacterTable" Label="w.r.t. a normal subgroup"/>.
## 
## It is necessary because the original table and the sorted table have the
## same identifier (and the same group if known),
## and hence the same fusions are valid for the two tables.
## 
## <Example><![CDATA[
## gap> tbl:= CharacterTable( "Symmetric", 4 );
## CharacterTable( "Sym(4)" )
## gap> Display( tbl );
## Sym(4)
##
## 2 3 2 3 . 2
## 3 1 . . 1 .
##
## 1a 2a 2b 3a 4a
## 2P 1a 1a 1a 3a 2b
## 3P 1a 2a 2b 1a 4a
##
## X.1 1 -1 1 1 -1
## X.2 3 -1 -1 . 1
## X.3 2 . 2 -1 .
## X.4 3 1 -1 . -1
## X.5 1 1 1 1 1
## gap> srt1:= CharacterTableWithSortedCharacters( tbl );
## CharacterTable( "Sym(4)" )
## gap> List( Irr( srt1 ), Degree );
## [ 1, 1, 2, 3, 3 ]
## gap> srt2:= CharacterTableWithSortedClasses( tbl );
## CharacterTable( "Sym(4)" )
## gap> SizesCentralizers( tbl );
## [ 24, 4, 8, 3, 4 ]
## gap> SizesCentralizers( srt2 );
## [ 24, 8, 4, 3, 4 ]
## gap> nsg:= ClassPositionsOfNormalSubgroups( tbl );
## [ [ 1 ], [ 1, 3 ], [ 1, 3, 4 ], [ 1 .. 5 ] ]
## gap> srt3:= SortedCharacterTable( tbl, nsg );
## CharacterTable( "Sym(4)" )
## gap> nsg:= ClassPositionsOfNormalSubgroups( srt3 );
## [ [ 1 ], [ 1, 2 ], [ 1 .. 3 ], [ 1 .. 5 ] ]
## gap> Display( srt3 );
## Sym(4)
##
## 2 3 3 . 2 2
## 3 1 . 1 . .
##
## 1a 2a 3a 2b 4a
## 2P 1a 1a 3a 1a 2a
## 3P 1a 2a 1a 2b 4a
##
## X.1 1 1 1 1 1
## X.2 1 1 1 -1 -1
## X.3 2 2 -1 . .
## X.4 3 -1 . -1 1
## X.5 3 -1 . 1 -1
## gap> ClassPermutation( srt3 );
## (2,4,3)
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttributeSuppCT( "ClassPermutation", IsNearlyCharacterTable,
 [ "class" ] );

#############################################################################
##
## 12. Storing Normal Subgroup Information
##

##############################################################################
##
#A NormalSubgroupClassesInfo( <tbl> )
##
## <#GAPDoc Label="NormalSubgroupClassesInfo">
## <ManSection>
## <Attr Name="NormalSubgroupClassesInfo" Arg='tbl'/>
##
## <Description>
## Let <A>tbl</A> be the ordinary character table of the group <M>G</M>.
## Many computations for group characters of <M>G</M> involve computations
## in normal subgroups or factor groups of <M>G</M>.
## 
## In some cases the character table <A>tbl</A> is sufficient;
## for example questions about a normal subgroup <M>N</M> of <M>G</M> can be
## answered if one knows the conjugacy classes that form <M>N</M>,
## e.g., the question whether a character of <M>G</M> restricts
## irreducibly to <M>N</M>.
## But other questions require the computation of <M>N</M> or
## even more information, like the character table of <M>N</M>.
## 
## In order to do these computations only once, one stores in the group a
## record with components to store normal subgroups, the corresponding lists
## of conjugacy classes, and (if necessary) the factor groups, namely
## 
## <List>
## <C>nsg</C>
## <Item>
## list of normal subgroups of <M>G</M>, may be incomplete,
## </Item>
## <C>nsgclasses</C>
## <Item>
## at position <M>i</M>, the list of positions of conjugacy
## classes of <A>tbl</A> forming the <M>i</M>-th entry of the <C>nsg</C>
## component,
## </Item>
## <C>nsgfactors</C>
## <Item>
## at position <M>i</M>, if bound, the factor group
## modulo the <M>i</M>-th entry of the <C>nsg</C> component.
## </Item>
## </List>
## 
## <Ref Func="NormalSubgroupClasses"/>,
## <Ref Func="FactorGroupNormalSubgroupClasses"/>, and
## <Ref Func="ClassPositionsOfNormalSubgroup"/>
## each use these components, and they are the only functions to do so.
## 
## So if you need information about a normal subgroup for that you know the
## conjugacy classes, you should get it using
## <Ref Func="NormalSubgroupClasses"/>.
## If the normal subgroup was already used it is just returned, with all the
## knowledge it contains. Otherwise the normal subgroup is added to the
## lists, and will be available for the next call.
## 
## For example, if you are dealing with kernels of characters using the
## <Ref Attr="KernelOfCharacter"/> function you make use of this feature
## because <Ref Attr="KernelOfCharacter"/> calls
## <Ref Func="NormalSubgroupClasses"/>.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareAttribute( "NormalSubgroupClassesInfo", IsOrdinaryTable, "mutable" );

##############################################################################
##
#F ClassPositionsOfNormalSubgroup( <tbl>, <N> )
##
## <#GAPDoc Label="ClassPositionsOfNormalSubgroup">
## <ManSection>
## <Func Name="ClassPositionsOfNormalSubgroup" Arg='tbl, N'/>
##
## <Description>
## is the list of positions of conjugacy classes of the character table
## <A>tbl</A> that are contained in the normal subgroup <A>N</A>
## of the underlying group of <A>tbl</A>.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareGlobalFunction( "ClassPositionsOfNormalSubgroup" );

##############################################################################
##
#F NormalSubgroupClasses( <tbl>, <classes> )
##
## <#GAPDoc Label="NormalSubgroupClasses">
## <ManSection>
## <Func Name="NormalSubgroupClasses" Arg='tbl, classes'/>
##
## <Description>
## returns the normal subgroup of the underlying group <M>G</M> of the
## ordinary character table <A>tbl</A>
## that consists of those conjugacy classes of <A>tbl</A> whose positions
## are in the list <A>classes</A>.
## 
## If <C>NormalSubgroupClassesInfo( <A>tbl</A> ).nsg</C> does not yet
## contain the required normal subgroup,
## and if <C>NormalSubgroupClassesInfo( <A>tbl</A> ).normalSubgroups</C> is
## bound then the result will be identical to the group in
## <C>NormalSubgroupClassesInfo( <A>tbl</A> ).normalSubgroups</C>.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareGlobalFunction( "NormalSubgroupClasses" );

##############################################################################
##
#F FactorGroupNormalSubgroupClasses( <tbl>, <classes> )
##
## <#GAPDoc Label="FactorGroupNormalSubgroupClasses">
## <ManSection>
## <Func Name="FactorGroupNormalSubgroupClasses" Arg='tbl, classes'/>
##
## <Description>
## is the factor group of the underlying group <M>G</M> of the ordinary
## character table <A>tbl</A> modulo the normal subgroup of <M>G</M> that
## consists of those conjugacy classes of <A>tbl</A> whose positions are in
## the list <A>classes</A>.
## 
## <Example><![CDATA[
## gap> g:= SymmetricGroup( 4 );
## Sym( [ 1 .. 4 ] )
## gap> SetName( g, "S4" );
## gap> tbl:= CharacterTable( g );
## CharacterTable( S4 )
## gap> irr:= Irr( g );
## [ Character( CharacterTable( S4 ), [ 1, -1, 1, 1, -1 ] ),
## Character( CharacterTable( S4 ), [ 3, -1, -1, 0, 1 ] ),
## Character( CharacterTable( S4 ), [ 2, 0, 2, -1, 0 ] ),
## Character( CharacterTable( S4 ), [ 3, 1, -1, 0, -1 ] ),
## Character( CharacterTable( S4 ), [ 1, 1, 1, 1, 1 ] ) ]
## gap> kernel:= KernelOfCharacter( irr[3] );;
## gap> AsSet(kernel);
## [ (), (1,2)(3,4), (1,3)(2,4), (1,4)(2,3) ]
## gap> SetName(kernel,"V4");
## gap> HasNormalSubgroupClassesInfo( tbl );
## true
## gap> NormalSubgroupClassesInfo( tbl );
## rec( nsg := [ V4 ], nsgclasses := [ [ 1, 3 ] ], nsgfactors := [ ] )
## gap> ClassPositionsOfNormalSubgroup( tbl, kernel );
## [ 1, 3 ]
## gap> G := FactorGroupNormalSubgroupClasses( tbl, [ 1, 3 ] );;
## gap> NormalSubgroupClassesInfo( tbl ).nsgfactors[1] = G;
## true
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareGlobalFunction( "FactorGroupNormalSubgroupClasses" );

#############################################################################
##
## 13. Auxiliary Stuff
##

#############################################################################
##
## The following representation is used for the character table library.
## As the library refers to it, it has to be declared in a library file
## not to enforce installing the character tables library.
##

#############################################################################
##
#V SupportedLibraryTableComponents
#R IsLibraryCharacterTableRep( <tbl> )
##
## <ManSection>
## <Var Name="SupportedLibraryTableComponents"/>
## <Filt Name="IsLibraryCharacterTableRep" Arg='tbl' Type='Representation'/>
##
## <Description>
## Modular library tables may have some components that are meaningless for
## character tables that know their underlying group.
## These components do not justify the introduction of operations to fetch
## them.
## 
## Library tables are always complete character tables.
## Note that in spite of the name, <C>IsLibraryCharacterTableRep</C> is used
## <E>not</E> only for library tables; for example, the direct product of
## two tables with underlying groups or a factor table of a character table
## with underlying group may be in <C>IsLibraryCharacterTableRep</C>.
## </Description>
## </ManSection>
##
BindGlobal( "SupportedLibraryTableComponents", [
 # These are used only for Brauer tables, they are set only by `MBT'.
 "basicset",
 "brauertree",
 "decinv",
 "defect",
 "factorblocks",
 "indicator",
 ] );

DeclareRepresentation( "IsLibraryCharacterTableRep", IsAttributeStoringRep,
 SupportedLibraryTableComponents );

#############################################################################
##
#R IsGenericCharacterTableRep( <tbl> )
##
## <ManSection>
## <Filt Name="IsGenericCharacterTableRep" Arg='tbl' Type='Representation'/>
##
## <Description>
## generic character tables are a special representation of objects since
## they provide just some record components.
## It might be useful to treat them similar to character table like objects,
## for example to display them.
## So they belong to the category of nearly character tables.
## </Description>
## </ManSection>
##
DeclareRepresentation( "IsGenericCharacterTableRep",
 IsNearlyCharacterTable and IsComponentObjectRep,
 [
 "domain",
 "wholetable",
 "classparam",
 "charparam",
 "specializedname",
 "size",
 "centralizers",
 "orders",
 "powermap",
 "classtext",
 "matrix",
 "irreducibles",
 "text",
 ] );

#############################################################################
##
#F CharacterTableFromLibrary( <name>, <param1>, ... )
##
## The `CharacterTable' methods for a string and optional parameters call
## `CharacterTableFromLibrary'.
## We bind this to a dummy function that signals an error.
##
## (If the package CTblLib is already loaded, for example because the
## current file is reread, we do not replace the working function.)
##
if not IsBound( CharacterTableFromLibrary ) then
 BindGlobal( "CharacterTableFromLibrary", function( arg )
 Error( "sorry, the GAP Character Table Library is not loaded,\n",
 "call `LoadPackage( \"CTblLib\" )' if you want to use it" );
 end );
fi;