#############################################################################
##
## 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 ⪆ 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.
## <P/>
## 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>.
## <P/>
## 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;).
## <P/>
## 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.
## <P/>
## 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.
## <P/>
## 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.
## <P/>
## 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;.
## <P/>
## &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.
## <P/>
## 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"/>.
## <P/>
## 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"/>.
## <P/>
## 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.
## <P/>
## 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"/>.
## <P/>
## 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"/>).
## <P/>
## 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.
## <P/>
## 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.
## <P/>
## 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.
## <P/>
## <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.
## <P/>
## 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.
## <P/>
## 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).
## <P/>
## 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.
## <P/>
## 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"/>).
## <P/>
## 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"/>.
## <P/>
## 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.
## <P/>
## 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.)
## <P/>
## The class of the identity element must be the first class
## (see <Ref Sect="Conventions for Character Tables"/>).
## <P/>
## 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.
## <P/>
## 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>.
## <P/>
## <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>.
## <P/>
## 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.
## <P/>
## 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.
## <P/>
## 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"/>.
## <P/>
## 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.
## <P/>
## 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.
## <P/>
## 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.
## <P/>
## 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>
## <P/>
## 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>
## <Mark><C>natchar</C> </Mark>
## <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>
## <Mark><C>bijection</C> </Mark>
## <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>
## <P/>
## <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>
## <Mark><C><A>tbl1</A> * <A>tbl2</A></C></Mark>
## <Item>
## the direct product of two character tables
## (see <Ref Oper="CharacterTableDirectProduct"/>),
## </Item>
## <Mark><C><A>tbl</A> / <A>list</A></C></Mark>
## <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>
## <Mark><C><A>tbl</A> mod <A>p</A></C></Mark>
## <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>
## <Mark><C><A>tbl</A>.<A>name</A></C></Mark>
## <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.
## <P/>
## 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"/>.
## <P/>
## 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>[, <p>] )
#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>.
## <P/>
## (The default method for the call with only argument a group is to call
## the operation with second argument <C>0</C>.)
## <P/>
## For solvable groups,
## the default method is based on <Cite Key="Con90b"/>.
## <P/>
## <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>[, <p>] )
#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>.
## <P/>
## 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.
## <P/>
## (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.)
## <P/>
## 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>.
## <P/>
## 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.
## <P/>
## <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>[, <p>] )
#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>.
## <P/>
## 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.
## <P/>
## 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"/>).
## <P/>
## <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>, <p> )
##
## <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"/>.
## <!-- This may become interesting as soon as blocks are GAP objects of
## their own, and one can ask for the ordinary and modular irreducibles
## in a block.-->
## </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.
## <P/>
## 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"/>).
## <P/>
## <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.
## <P/>
## <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.
## <P/>
## 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>.
## <P/>
## <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>.
## <P/>
## <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>.
## <P/>
## <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.
## <P/>
## The underlying characteristic must be stored when the table is
## constructed, there is no method to compute it.
## <P/>
## 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"/>).
## <P/>
## <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.
## <P/>
## 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.
## <P/>
## 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>.
## <P/>
## 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>.
## <P/>
## 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"/>.
## <P/>
## <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>.
## <P/>
## It depends on <A>tbl</A> what these parameters are,
## so there is no default to compute class and character parameters.
## <P/>
## 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.
## <P/>
## 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.
## <!--
## <P/>
## A kind of partial character parameters for finite groups of Lie type
## is given by the Deligne-Lusztig names of unipotent characters,
## see <Ref Sect="sec:unipot" BookName="ctbllib"/>.
## -->
## </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.
## <P/>
## 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
--> --------------------
--> maximum size reached
--> --------------------
