Group characters

Let $G$ be a finite group, and let $\rho: G \to GL(n, R)$ be a group homomorphism, for some ring $R$. We call $\chi: G \to R$, defined by $\chi(g) = Trace(\rho(g))$, the character afforded by $\rho$.

Since $\chi$ is constant on conjugacy classes of $G$, it can be represented by an array $l$ of values such that the value on the $i$-th conjugacy class of $G$ (see conjugacy_classes) is stored at $l[i]$. Note that this makes sense only if we assume that the ordering of conjugacy classes of $G$ is fixed once the classes have been computed.

We deal only with the cases that either $R$ can be embedded into some number field, or that $R$ is a finite field.

In the former case, the eigenvalues of the matrix $\rho(g)$, for $g \in G$, are $k$-th roots of unity, where $k$ is the order of $g$, thus all values of $\chi$ can be represented by elements in the abelian closure of the field of rational numbers, see abelian_closure. The characters obtained this way are called ordinary characters.

In the latter case, the list of traces of $\rho(g)$ (the so-called Frobenius character of $\rho$) is often not so interesting; instead, one considers the Brauer character of $\rho$, which is defined on (conjugacy classes of) elements $g$ whose order is coprime to the characteristic of $R$ (the so-called $p$-regular elements resp. classes), by first lifting the eigenvalues of $\rho(g)$ to complex roots of unity and then summing up these roots; this way, one gets again a list of values in the abelian closure of the field of rationals.

The pointwise sum and product of two characters are again characters, they are afforded by the direct sum and the tensor product of the underlying representations. A character that is not the sum of two characters is called absolutely irreducible.

Character tables

Putting the values of the absolutely irreducible ordinary characters of a group $G$ into an array such that the rows correspond to the characters and the columns correspond to the conjugacy classes yields the ordinary character table of $G$, which is in fact a square matrix. Analogously, the absolutely irreducible Brauer characters of $G$, for a given characteristic $p$, yield a square matrix, the $p$-modular Brauer character table.

Ordinary character tables can be computed with character_table from a given group. The computation of $p$-modular Brauer tables is currently restricted to the case of $p$-solvable groups.

Character tables contain a lot of information about their groups, many questions about a finite group can be answered by computations only with its characters. Thus it makes sense to deal also with character tables without an explicit labeling of the columns of the table by conjugacy classes of a group. For example, the character tables shown in the Atlas of Finite Groups [CCNPW85] and from the Atlas of Brauer Characters [JLPW95] are available in OSCAR. Such character tables can be fetched with character_table(id::String, p::Int = 0) from the database, via their names. Moreover, the library of character tables can be used similar to group libraries (see Group libraries) in the sense that all_character_table_names returns descriptions of all those available character tables that have certain properties.

In OSCAR, a character table t is identified with the array of absolutely irreducible characters of $G$, in the sense that t[i] yields the i-th irreducible character of $G$, and t[i, j] is the value of this character on the j-th conjugacy class of $G$ (or the j-th conjugacy class of $p$-regular elements in the case of Brauer tables).

Ordinary and $p$-modular Brauer tables in OSCAR are distinguished by their characteristic(tbl::GAPGroupCharacterTable); its value is 0 for ordinary tables and $p$ otherwise.

The character table to which a character chi belongs can be fetched as parent(chi).

GAPGroupCharacterTableType
GAPGroupCharacterTable <: GroupCharacterTable

This is the type of (ordinary or Brauer) character tables that can delegate tasks to an underlying character table object in the GAP system (field GAPTable).

The value of the field characteristic determines whether the table is an ordinary one (value 0) or a p-modular one (value p).

A group can (but need not) be stored in the field group. If it is available then also the field isomorphism is available, its value is a bijective map from the group value to a group in GAP.

Objects of type GAPGroupCharacterTable support get_attribute, for example in order to store the already computed p-modular tables in an ordinary table, and to store the corresponding ordinary table in a p-modular table.

source
character_tableMethod
character_table(G::GAPGroup, p::T = 0) where T <: IntegerUnion

Return the ordinary (if p == 0) or p-modular character table of the finite group G. If the p-modular character table of G cannot be computed by GAP then nothing is returned.

Examples

julia> Oscar.with_unicode() do
         show(stdout, MIME("text/plain"), character_table(symmetric_group(3)))
       end;
Character table of Sym(3)

 2  1  1  .
 3  1  .  1

   1a 2a 3a
2P 1a 1a 3a
3P 1a 2a 1a

χ₁  1 -1  1
χ₂  2  . -1
χ₃  1  1  1

julia> Oscar.with_unicode() do
         show(stdout, MIME("text/plain"), character_table(symmetric_group(3), 2))
       end;
2-modular Brauer table of Sym(3)

 2  1  .
 3  1  1

   1a 3a
2P 1a 3a
3P 1a 1a

χ₁  1  1
χ₂  2 -1
source
character_tableFunction
character_table(id::String, p::Int = 0)

Return the ordinary (if p == 0) or p-modular character table for which id is an admissible name in GAP's library of character tables. If no such table is available then nothing is returned.

Examples

julia> println(character_table("A5"))
character table of A5

julia> println(character_table("A5", 2))
2-modular Brauer table of A5

julia> println(character_table("J5"))
nothing
source
character_tableMethod
character_table(series::Symbol, parameter::Any)

Return the ordinary character table of the group described by the series series and the parameter parameter.

Examples

julia> println(character_table(:Symmetric, 5))
character table of Sym(5)

julia> println(character_table(:WeylB, 3))
character table of W(B3)

Currently the following series are supported.

SeriesParameter
:Cyclicpos. integer
:Dihedraleven pos. integer
:Symmetricpos. integer
:Alternatinginteger > 1
:WeylBpos. integer
:WeylDinteger > 1
:DoubleCoverSymmetricpos. integer
:DoubleCoverAlternatingpos. integer
:GL2prime power
:SL2oddodd prime power
:SL2eveneven prime power
:PSL2oddodd prime power q s. t. (q-1)/2 is odd
:PSL2evenodd prime power q s. t. (q-1)/2 is even
:Suzukiodd power of 2
:GU3prime power
:SU3prime power
Symbol("P:Q")vector [p, q] with prime p and q dividing p-1
:ExtraspecialPlusOddodd power of odd prime
source
showMethod
Base.show(io::IO, ::MIME"text/plain", tbl::GAPGroupCharacterTable)

Display the irreducible characters of tbl and context information as a two-dimensional array.

  • First a header is shown. If tbl stores a group then the header describes this group, otherwise it is equal to the identifier(tbl::GAPGroupCharacterTable) value of tbl.

  • Then the irreducible characters of tbl are shown in column portions that fit on the screen, together with column labels above each portion and row labels on the left of each portion.

    The column labels consist of the factored centralizer orders (see orders_centralizers, one row for each prime divisor of the group order), followed by one row showing the class names (see class_names), followed by the power maps (one row for each stored power map).

    The row labels are X_1, X_2, ... (or χ with subscripts 1, 2, ... if unicode output is allowed). If io is an IOContext with key :indicator set to true then a second column of row labels shows the 2nd Frobenius-Schur indicator of the irreducibles (see indicator); analogously, setting the key :character_field to true yields a column showing the degrees of the character fields (see character_field), and setting the key :OD to true yields a column showing the known orthogonal discriminants of those irreducibles that have indicator + and even degree.

  • Depending on the way how irrational character values are shown, a footer may be shown in the end. By default, irrationalities are shown as sums of roots of unity, where z_n (or ζ with subscript n if unicode output is allowed) denotes the primitive n-th root $\exp(2 \pi i/n)$. If io is an IOContext with key :with_legend set to true then irrationalities are abbreviated as A, B, ..., and these names together with the corresponding expression as sums of roots of unity appear in the footer.

Output in $\LaTeX$ syntax can be created by calling show with second argument MIME("text/latex").

Examples

julia> tbl = character_table(:Cyclic, 3);

julia> Oscar.with_unicode() do
         show(stdout, MIME("text/plain"), tbl)
       end;
C3

 3  1       1       1
                     
   1a      3a      3b
3P 1a      1a      1a
                     
χ₁  1       1       1
χ₂  1      ζ₃ -ζ₃ - 1
χ₃  1 -ζ₃ - 1      ζ₃

julia> Oscar.with_unicode() do
         show(IOContext(stdout, :with_legend => true), MIME("text/plain"), tbl)
       end;
C3

 3  1  1  1
           
   1a 3a 3b
3P 1a 1a 1a
           
χ₁  1  1  1
χ₂  1  A  A̅
χ₃  1  A̅  A

A = ζ₃
A̅ = -ζ₃ - 1

julia> Oscar.with_unicode() do
         show(IOContext(stdout, :indicator => true), MIME("text/plain"), tbl)
       end;
C3

    3  1       1       1
                        
      1a      3a      3b
   3P 1a      1a      1a
    2                   
χ₁  +  1       1       1
χ₂  o  1      ζ₃ -ζ₃ - 1
χ₃  o  1 -ζ₃ - 1      ζ₃

julia> Oscar.with_unicode() do
         show(IOContext(stdout, :character_field => true), MIME("text/plain"), tbl)
       end;
C3

    3  1       1       1
                        
      1a      3a      3b
   2P 1a      3b      3a
   3P 1a      1a      1a
    d                   
χ₁  1  1       1       1
χ₂  2  1      ζ₃ -ζ₃ - 1
χ₃  2  1 -ζ₃ - 1      ζ₃

julia> Oscar.with_unicode() do
         show(IOContext(stdout, :with_legend => true), MIME("text/latex"), tbl)
       end;
C3

$\begin{array}{rrrr}
3 & 1 & 1 & 1 \\
 &  &  &  \\
 & 1a & 3a & 3b \\
2P & 1a & 3b & 3a \\
3P & 1a & 1a & 1a \\
 &  &  &  \\
\chi_{1} & 1 & 1 & 1 \\
\chi_{2} & 1 & A & \overline{A} \\
\chi_{3} & 1 & \overline{A} & A \\
\end{array}

\begin{array}{l}
A = \zeta_{3} \\
\overline{A} = -\zeta_{3} - 1 \\
\end{array}
$
source
characteristicMethod
characteristic(::Type{T} = Int, tbl::GAPGroupCharacterTable) where T <: IntegerUnion

Return T(0) if tbl is an ordinary character table, and T(p) if tbl is a p-modular character table.

Examples

julia> tbl = character_table("A5");

julia> characteristic(tbl)
0

julia> characteristic(tbl % 2)
2
source
modMethod
mod(tbl::GAPGroupCharacterTable, p::T) where T <: IntegerUnion
rem(tbl::GAPGroupCharacterTable, p::T) where T <: IntegerUnion

Return the p-modular character table of tbl, or nothing if this table cannot be computed.

The syntax tbl % p is also supported.

An exception is thrown if tbl is not an ordinary character table.

Examples

julia> show(character_table("A5") % 2)
2-modular Brauer table of A5
source
quoMethod
quo(tbl::GAPGroupCharacterTable, nclasses::Vector{Int})

Return the pair (fact, proj) where fact is the character table of the factor of tbl modulo the normal subgroup that is the normal closure of the conjugacy classes whose positions are listed in nclasses, and proj is the class fusion from tbl to fact.

Examples

julia> t = character_table("2.A5");

julia> n = class_positions_of_center(t);  println(n)
[1, 2]

julia> fact, proj = quo(t, n);

julia> order(fact)
60

julia> println(proj)
[1, 1, 2, 3, 3, 4, 4, 5, 5]
source
all_character_table_namesFunction
all_character_table_names(L...; ordered_by = nothing)

Return an vector of strings that contains all those names of character tables in the character table library that satisfy the conditions in the vector L.

Examples

julia> spor_names = all_character_table_names(is_sporadic_simple => true,
         is_duplicate_table => false);

julia> println(spor_names[1:5])
["B", "Co1", "Co2", "Co3", "F3+"]

julia> spor_names = all_character_table_names(is_sporadic_simple,
         !is_duplicate_table; ordered_by = order);

julia> println(spor_names[1:5])
["M11", "M12", "J1", "M22", "J2"]

julia> length(all_character_table_names(number_of_conjugacy_classes => 1))
1
source

Attributes of group characters

character_fieldFunction
character_field(chi::GAPGroupClassFunction)

If chi is an ordinary character then return the pair (F, phi) where F is a number field that is generated by the character values of chi, and phi is the embedding of F into abelian_closure(QQ).

If chi is a Brauer character in characteristic p then return the pair (F, phi) where F is the finite field that is generated by the p-modular reductions of the values of chi, and phi is the identity map on F.

Examples

julia> t = character_table("A5");

julia> character_field(t[2])[1]
Number field with defining polynomial x^2 + x - 1
  over rational field

julia> flds_2 = map(character_field, mod(t, 2));

julia> println([degree(x[1]) for x in flds_2])
[1, 2, 2, 1]
source
conductorMethod
conductor(::Type{T} = ZZRingElem, chi::GAPGroupClassFunction)
          where T <: IntegerUnion

Return the minimal integer n, as an instance of T, such that all values of chi lie in the n-th cyclotomic field.

Examples

julia> tbl = character_table("A5");

julia> println([conductor(chi) for chi in tbl])
ZZRingElem[1, 5, 5, 1, 1]
source
conjMethod
conj(chi::GAPGroupClassFunction)

Return the class function whose values are the complex conjugates of the values of chi.

Examples

julia> tbl = character_table(alternating_group(4));

julia> println([findfirst(y -> y == conj(x), tbl) for x in tbl])
[1, 3, 2, 4]
source
degreeMethod
degree(::Type{T} = QQFieldElem, chi::GAPGroupClassFunction)
       where T <: Union{IntegerUnion, QQFieldElem, QQAbElem}

Return chi[1], as an instance of T.

source
indicatorFunction
indicator(chi::GAPGroupClassFunction, n::Int = 2)

Return the n-th Frobenius-Schur indicator of chi, that is, the value $(∑_{g ∈ G} chi(g^n))/|G|$, where $G$ is the group of chi.

If chi is irreducible then indicator(chi) is 0 if chi is not real-valued, 1 if chi is afforded by a real representation of $G$, and -1 if chi is real-valued but not afforded by a real representation of $G$.

Examples

julia> tbl = character_table("U3(3)");

julia> println([indicator(chi) for chi in tbl])
[1, -1, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0]
source
is_faithfulMethod
is_faithful(chi::GAPGroupClassFunction)

Return true if the value of chi at the identity element does not occur as value of chi at any other element, and false otherwise.

If chi is an ordinary character then true is returned if and only if the representations affording chi have trivial kernel.

Examples

julia> println(map(is_faithful, character_table(symmetric_group(3))))
Bool[0, 1, 0]
source
is_rationalMethod
is_rational(chi::GAPGroupClassFunction)

Return true if all values of chi are rational, i.e., in QQ, and false otherwise.

Examples

julia> all(is_rational, character_table(symmetric_group(4)))
true

julia> all(is_rational, character_table(alternating_group(4)))
false
source
is_irreducibleMethod
is_irreducible(chi::GAPGroupClassFunction)

Return true if chi is an irreducible character, and false otherwise.

A character is irreducible if it cannot be written as the sum of two characters. For ordinary characters this can be checked using the scalar product of class functions (see scalar_product. For Brauer characters there is no generic method for checking irreducibility.

Examples

julia> g = symmetric_group(4);

julia> all(is_irreducible, character_table(g))
true

julia> is_irreducible(natural_character(g))
false
source
schur_indexFunction
schur_index(chi::GAPGroupClassFunction) -> Int

For an ordinary irreducible character chi, return the minimal integer m such that the character m * chi is afforded by a representation over the character field of chi, or throw an exception if the currently used character theoretic criteria do not suffice for computing m.

Examples

julia> t = character_table(quaternion_group(8));

julia> println(map(schur_index, t))
[1, 1, 1, 1, 2]
source
detMethod
det(chi::GAPGroupClassFunction)

Return the determinant character of the character chi. This is defined to be the character obtained by taking the determinant of representing matrices of any representation affording chi.

Examples

julia> t = character_table(symmetric_group(4));

julia> all(chi -> det(chi) == exterior_power(chi, Int(degree(chi))), t)
true
source
orderMethod
order(::Type{T} = ZZRingElem, chi::GAPGroupClassFunction)
      where T <: IntegerUnion

Return the determinantal order of the character chi. This is defined to be the multiplicative order of det(chi).

Examples

julia> println([order(chi) for chi in character_table(symmetric_group(4))])
ZZRingElem[2, 1, 2, 2, 1]
source
order_field_of_definitionMethod
order_field_of_definition(::Type{T} = ZZRingElem, chi::GAPGroupClassFunction) where T <: IntegerUnion

Return $p^n$, as an instance of T, if chi is a $p$-modular Brauer character such that the $p$-modular reductions of the values of chi span the field with $p^n$ elements.

Note that one need not compute the character_field value of chi in order to compute order_field_of_definition(chi).

Examples

julia> tbl = character_table("A5", 2);

julia> println([order_field_of_definition(chi) for chi in tbl])
ZZRingElem[2, 4, 4, 2]
source

Attributes of character tables

block_distributionFunction
block_distribution(tbl::GAPGroupCharacterTable, p::IntegerUnion)

Return a dictionary with the keys :defect (the vector containing at position i the defect of the i-th p-block of tbl) and :block (the vector containing at position i the number j such that tbl[i] belongs to the j-th p-block).

An exception is thrown if tbl is not an ordinary character table.

Examples

julia> block_distribution(character_table("A5"), 2)
Dict{Symbol, Vector{Int64}} with 2 entries:
  :block  => [1, 1, 1, 2, 1]
  :defect => [2, 0]
source
character_parametersFunction
character_parameters(tbl::GAPGroupCharacterTable)

Return a vector of character parameters for the rows of tbl if such parameters are stored, and nothing otherwise.

Examples

julia> character_parameters(character_table("S5"))
7-element Vector{Vector{Int64}}:
 [5]
 [1, 1, 1, 1, 1]
 [3, 1, 1]
 [4, 1]
 [2, 1, 1, 1]
 [3, 2]
 [2, 2, 1]

julia> character_parameters(character_table("M11"))
source
class_namesMethod
class_names(tbl::GAPGroupCharacterTable)

Return a vector of strings corresponding to the columns of tbl. The $i$-th entry consists of the element order for the $i$-th column, followed by at least one distinguishing letter. For example, the classes of elements of order two have class names `"2a", "2b", and so on.

Examples

julia> println(class_names(character_table("S5")))
["1a", "2a", "3a", "5a", "2b", "4a", "6a"]
source
class_parametersFunction
class_parameters(tbl::GAPGroupCharacterTable)

Return a vector of class parameters for the columns of tbl if such parameters are stored, and nothing otherwise.

Examples

julia> class_parameters(character_table("S5"))
7-element Vector{Vector{Int64}}:
 [1, 1, 1, 1, 1]
 [2, 2, 1]
 [3, 1, 1]
 [5]
 [2, 1, 1, 1]
 [4, 1]
 [3, 2]

julia> class_parameters(character_table("M11"))
source
conjugacy_classesMethod
conjugacy_classes(tbl::GAPGroupCharacterTable)

Return the vector of conjugacy classes of group(tbl), ordered such that they correspond to the columns of tbl.

Note that the vectors conjugacy_classes(group(tbl)) and conjugacy_classes(tbl) are independent. They will usually have the same ordering, but it may happen that they are ordered differently.

An error is thrown if tbl does not store a group.

Examples

julia> g = symmetric_group(4);  tbl = character_table(g);

julia> [length(c) for c in conjugacy_classes(tbl)] == class_lengths(tbl)
true
source
decomposition_matrixFunction
decomposition_matrix(modtbl::GAPGroupCharacterTable)

Return the decomposition matrix (of type ZZMatrix) of the Brauer character table modtbl. The rows and columns are indexed by the irreducible characters of the ordinary character table of modtbl and the irreducible characters of modtbl, respectively,

Examples

julia> t = character_table("A5"); t2 = mod(t, 2);

julia> decomposition_matrix(t2)
[1   0   0   0]
[1   0   1   0]
[1   1   0   0]
[0   0   0   1]
[1   1   1   0]
source
identifierFunction
identifier(tbl::GAPGroupCharacterTable)

Return a string that identifies tbl. It is used mainly for library tables.

Examples

julia> identifier(character_table("A5"))
"A5"
source
induced_cyclicMethod
induced_cyclic(tbl::GAPGroupCharacterTable, classes::AbstractVector{Int} = 1:nrows(tbl))

Return the vector of permutation characters of tbl that are induced from cyclic subgroups. If classes is given then only the cyclic subgroups generated by elements in the classes at positions in this vector are returned.

Examples

julia> t = character_table("A5");

julia> ind = induced_cyclic(t);

julia> all(x -> scalar_product(x, t[1]) == 1, ind)
true
source
is_duplicate_tableFunction
is_duplicate_table(tbl::GAPGroupCharacterTable)

Return whether tbl is an ordinary table from the character table library that was constructed from another library character table by permuting rows and columns.

One application of this function is to restrict the search with all_character_table_names to only one library character table for each class of permutation equivalent tables.

Examples

julia> is_duplicate_table(character_table("A5"))
false

julia> is_duplicate_table(character_table("A6M2"))
true
source
maxesFunction
maxes(tbl::GAPGroupCharacterTable)

Return either nothing (if the value is not known) or a vector of identifiers of the ordinary character tables of all maximal subgroups of tbl. There is no default method to compute this value from tbl.

If the maxes value of tbl is stored then it lists exactly one representative for each conjugacy class of maximal subgroups of the group of tbl, and the character tables of these maximal subgroups are available in the character table library, and compatible class fusions to tbl are stored on these tables.

Examples

julia> println(maxes(character_table("M11")))
["A6.2_3", "L2(11)", "3^2:Q8.2", "A5.2", "2.S4"]

julia> maxes(character_table("M")) === nothing  # not (yet) known
true
source
names_of_fusion_sourcesFunction
names_of_fusion_sources(tbl::GAPGroupCharacterTable)

Return the vector of strings that are identifiers of those character tables which store a class fusion to tbl, which must be an ordinary character table.

Examples

julia> tbl = character_table("A5");

julia> println(maxes(tbl))
["a4", "D10", "S3"]

julia> all(x -> x in names_of_fusion_sources(tbl), maxes(tbl))
true
source
class_lengthsFunction
class_lengths(tbl::GAPGroupCharacterTable)

Examples

julia> println(class_lengths(character_table("A5")))
ZZRingElem[1, 15, 20, 12, 12]
source
orders_centralizersFunction
orders_centralizers(tbl::GAPGroupCharacterTable)

Return the vector of the orders of centralizers of conjugacy class representatives for tbl in the group of tbl, ordered according to the columns of tbl.

Examples

julia> println(orders_centralizers(character_table("A5")))
ZZRingElem[60, 4, 3, 5, 5]
source
orders_class_representativesFunction
orders_class_representatives(tbl::GAPGroupCharacterTable)

Return the vector of the orders of conjugacy class representatives for tbl, ordered according to the columns of tbl.

Examples

julia> println(orders_class_representatives(character_table("A5")))
[1, 2, 3, 5, 5]
source
ordinary_tableMethod
ordinary_table(tbl::GAPGroupCharacterTable)

Return the ordinary character table of tbl, provided that tbl is a Brauer character table.

Examples

julia> tbl = character_table("A5");

julia> ordinary_table(tbl % 2) === tbl
true
source
trivial_characterMethod
trivial_character(tbl::GAPGroupCharacterTable)

Return the character of tbl that has the value QQAbElem(1) in each position.

Examples

julia> t = character_table(symmetric_group(4));

julia> all(x -> x == 1, trivial_character(t))
true
source
regular_characterMethod
regular_character(tbl::GAPGroupCharacterTable)

Return the regular character of tbl.

Examples

julia> tbl = character_table(symmetric_group(3));

julia> values(regular_character(tbl))
3-element Vector{QQAbElem{AbsSimpleNumFieldElem}}:
 6
 0
 0
source
linear_charactersMethod
linear_characters(tbl::GAPGroupCharacterTable)

Return the array of linear characters of tbl, that is, the characters of degree 1.

Examples

julia> tbl = character_table(symmetric_group(3));

julia> length(linear_characters(tbl))
2
source

The following properties of a group can be read off from its character table. Therefore it is supported to call these functions with a character table.

is_abelianMethod
is_abelian(tbl::GAPGroupCharacterTable)

Return whether tbl is the ordinary character table of an abelian group, see is_abelian(G::GAPGroup).

Examples

julia> is_abelian(character_table("A5"))
false

julia> is_abelian(character_table("C2"))
true
source
is_almost_simpleMethod
is_almost_simple(tbl::GAPGroupCharacterTable)

Return whether tbl is the ordinary character table of an almost simple group, see is_almost_simple(G::GAPGroup).

Examples

julia> is_almost_simple(character_table("S5"))
true

julia> is_almost_simple(character_table("S4"))
false
source
is_cyclicMethod
is_cyclic(tbl::GAPGroupCharacterTable)

Return whether tbl is the ordinary character table of a cyclic group, see is_cyclic(G::GAPGroup).

Examples

julia> is_cyclic(character_table("C2"))
true

julia> is_cyclic(character_table("S4"))
false
source
is_elementary_abelianMethod
is_elementary_abelian(tbl::GAPGroupCharacterTable)

Return whether tbl is the ordinary character table of an elementary abelian group, see is_elementary_abelian(G::GAPGroup).

Examples

julia> is_elementary_abelian(character_table("C2"))
true

julia> is_elementary_abelian(character_table("S4"))
false
source
is_nilpotentMethod
is_nilpotent(tbl::GAPGroupCharacterTable)

Return whether tbl is the ordinary character table of a nilpotent group, see is_nilpotent(G::GAPGroup).

Examples

julia> is_nilpotent(character_table("C2"))
true

julia> is_nilpotent(character_table("S4"))
false
source
is_perfectMethod
is_perfect(tbl::GAPGroupCharacterTable)

Return whether tbl is the ordinary character table of a perfect group, see is_perfect(G::GAPGroup).

Examples

julia> is_perfect(character_table("A5"))
true

julia> is_perfect(character_table("S4"))
false
source
is_quasisimpleMethod
is_quasisimple(tbl::GAPGroupCharacterTable)

Return whether tbl is the ordinary character table of a quasisimple group, see is_quasisimple(G::GAPGroup).

Examples

julia> is_quasisimple(character_table("A5"))
true

julia> is_quasisimple(character_table("S4"))
false
source
is_simpleMethod
is_simple(tbl::GAPGroupCharacterTable)

Return whether tbl is the ordinary character table of a simple group, see is_simple(G::GAPGroup).

Examples

julia> is_simple(character_table("A5"))
true

julia> is_simple(character_table("S4"))
false
source
is_solvableMethod
is_solvable(tbl::GAPGroupCharacterTable)

Return whether tbl is the ordinary character table of a solvable group, see is_solvable(G::GAPGroup).

Examples

julia> is_solvable(character_table("A5"))
false

julia> is_solvable(character_table("S4"))
true
source
is_sporadic_simpleMethod
is_sporadic_simple(tbl::GAPGroupCharacterTable)

Return whether tbl is the ordinary character table of a sporadic simple group, see is_sporadic_simple(G::GAPGroup).

Examples

julia> is_sporadic_simple(character_table("A5"))
false

julia> is_sporadic_simple(character_table("M11"))
true
source
is_supersolvableMethod
is_supersolvable(tbl::GAPGroupCharacterTable)

Return whether tbl is the ordinary character table of a supersolvable group, see is_supersolvable(G::GAPGroup).

Examples

julia> is_supersolvable(character_table("A5"))
false

julia> is_supersolvable(character_table("S3"))
true
source

Construct group characters from groups

linear_charactersMethod
linear_characters(G::Union{GAPGroup, FinGenAbGroup})

Return the array of linear characters of G, that is, the characters of degree 1.

Examples

julia> G = symmetric_group(3);

julia> length(linear_characters(G))
2
source
natural_characterMethod
natural_character(G::PermGroup)

Return the permutation character of degree degree(G) that maps each element of G to the number of its fixed points.

Examples

julia> g = symmetric_group(4);

julia> degree(natural_character(g))
4

julia> degree(natural_character(stabilizer(g, 4)[1]))
4
source
natural_characterMethod
natural_character(G::Union{MatrixGroup{QQFieldElem}, MatrixGroup{AbsSimpleNumFieldElem}})

Return the character that maps each element of G to its trace. We assume that the entries of the elements of G are either of type QQFieldElem or contained in a cyclotomic field.

Examples

julia> g = matrix_group(matrix(ZZ, [0 1; 1 0]));

julia> println(values(natural_character(g)))
QQAbElem{AbsSimpleNumFieldElem}[2, 0]
source
natural_character(G::MatrixGroup{FinFieldElem})

Return the character that maps each $p$-regular element of G, where $p$ is the characteristic of the base field of G, to its Brauer character value.

Examples

julia> g = general_linear_group(2, 2);

julia> println(values(natural_character(g)))
QQAbElem{AbsSimpleNumFieldElem}[2, -1]
source
natural_characterMethod
natural_character(G::MatrixGroup{FinFieldElem})

Return the character that maps each $p$-regular element of G, where $p$ is the characteristic of the base field of G, to its Brauer character value.

Examples

julia> g = general_linear_group(2, 2);

julia> println(values(natural_character(g)))
QQAbElem{AbsSimpleNumFieldElem}[2, -1]
source
natural_characterMethod
natural_character(rho::GAPGroupHomomorphism)

Return the character of domain(rho) that is afforded by the representation rho, where codomain(rho) must be a permutation group or a matrix group. In the latter case, an ordinary character is returned if the characteristic of the base field is zero, and a $p$-modular Brauer character is returned if the characteristic is $p > 0$.

Examples

julia> g = symmetric_group(3);  h = general_linear_group(2, 2);

julia> mp = hom(g, h, [g([2,1]), g([1, 3, 2])], gens(h));

julia> println(values(natural_character(mp)))
QQAbElem{AbsSimpleNumFieldElem}[2, -1]
source
trivial_characterMethod
trivial_character(G::GAPGroup)

Return the character of (the ordinary character table of) G that has the value QQAbElem(1) in each position.

Examples

julia> g = symmetric_group(4);

julia> all(x -> x == 1, trivial_character(g))
true
source
regular_characterMethod
regular_character(G::GAPGroup)

Return the regular character of G.

Examples

julia> G = symmetric_group(3);

julia> values(regular_character(G))
3-element Vector{QQAbElem{AbsSimpleNumFieldElem}}:
 6
 0
 0
source

Operations for group characters

length and iteration:

The length of a class function is the number of conjugacy classes of its group, iteration is defined w.r.t. the ordering of conjugacy classes.

arithmetic operations:

  • chi == psi: two class functions are equal if and only if they belong to the same character table and have the same values,
  • chi + psi and chi - psi are the pointwise sum and difference, respectively, of the two class functions chi, psi,
  • n*chi is the pointwise n-fold sum of chi, for an integer n,
  • chi*psi is the pointwise (tensor) product of chi and psi,
  • zero(chi) is the class function that is zero on all classes,
  • one(chi) is the trivial character of the character table of chi,
  • chi^n is the n-th tensor power of chi, for positive integers n,
  • chi(g) is the value of chi at the element g of the group of chi,
  • chi^g is the conjugate character of chi under the action of a group element g that normalizes the group $G$ of chi; we have chi^g(x) == chi(g*x*g^-1) for all x in $G$,
  • chi^galaut is the Galois conjugate character of chi under the pointwise action of the field automorphism galaut (If galaut was created as QQAbAutomorphism(k) then the action raises each root of unity to its k-th power; this action defines a field automorphism of the n-th cyclotomic field whenever n and k are coprime.)
  • chi^tbl is the character of the character table tbl that is induced from chi, where the group of chi is a subgroup of the group of tbl.
scalar_productFunction
scalar_product(::Type{T} = QQFieldElem, chi::GAPGroupClassFunction, psi::GAPGroupClassFunction)
               where T <: Union{IntegerUnion, ZZRingElem, QQFieldElem, QQAbElem}

Return $\sum_{g \in G}$ chi($g$) conj(psi)($g$) / $|G|$, where $G$ is the group of both chi and psi. The result is an instance of T.

Note that we do not support dot(chi, psi) and its infix notation because the documentation of dot states that the result is equal to the sum of dot results of corresponding entries, which does not hold for the scalar product of characters.

source
coordinatesMethod
coordinates(::Type{T} = QQFieldElem, chi::GAPGroupClassFunction)
               where T <: Union{IntegerUnion, ZZRingElem, QQFieldElem, QQAbElem}

Return the vector $[a_1, a_2, \ldots, a_n]$ of scalar products (see scalar_product) of chi with the irreducible characters $[t[1], t[2], \ldots, t[n]]$ of the character table $t$ of chi, that is, chi is equal to $\sum_{i==1}^n a_i t[i]$. The result is an instance of Vector{T}.

Examples

julia> g = symmetric_group(4)
Sym(4)

julia> chi = natural_character(g);

julia> coordinates(Int, chi)
5-element Vector{Int64}:
 0
 0
 0
 1
 1

julia> t = parent(chi);  t3 = mod(t, 3);  chi3 = restrict(chi, t3);

julia> coordinates(Int, chi3)
4-element Vector{Int64}:
 0
 1
 0
 1
source
multiplicities_eigenvaluesFunction
multiplicities_eigenvalues(::Type{T} = Int, chi::GAPGroupClassFunction, i::Int) where T <: IntegerUnion

Let $M$ be a representing matrix of an element in the i-th conjugacy class of the character table of chi, in a representation affording the character chi, and let $n$ be the order of the elements in this conjugacy class.

Return the vector $(m_1, m_2, \ldots, m_n)$ of integers of type T such that $m_j$ is the multiplicity of $\zeta_n^j$ as an eigenvalue of $M$.

Examples

julia> t = character_table("A5");  chi = t[4];

julia> println(values(chi))
QQAbElem{AbsSimpleNumFieldElem}[4, 0, 1, -1, -1]

julia> println(multiplicities_eigenvalues(chi, 5))
[1, 1, 1, 1, 0]
source
induceMethod
induce(chi::GAPGroupClassFunction, G::Union{GAPGroup, FinGenAbGroup})
induce(chi::GAPGroupClassFunction, tbl::GAPGroupCharacterTable[, fusion::Vector{Int}])

Return the class function of G or tbl that is induced from chi, which is a class function of a subgroup of G or the group of tbl. The default for the class fusion fus is given either by the fusion of the conjugacy classes of the two character tables (if groups are stored in the tables) or by the class fusion given by known_class_fusion for the two tables.

The syntax chi^tbl and chi^G is also supported.

Examples

julia> s = character_table("A5");  t = character_table("A6");

julia> maps = possible_class_fusions(s, t);  length(maps)
4

julia> chi = trivial_character(s);

julia> ind = [induce(chi, t, x) for x in maps];

julia> length(Set(ind))
2
source
restrictMethod
restrict(chi::GAPGroupClassFunction, H::Union{GAPGroup, FinGenAbGroup})
restrict(chi::GAPGroupClassFunction, subtbl::GAPGroupCharacterTable[, fusion::Vector{Int}])

Return the class function of H or subtbl that is the restriction of chi, which is a class function of a supergroup of H or the group of subtbl. The default for the class fusion fus is given either by the fusion of the conjugacy classes of the two character tables (if groups are stored in the tables) or by the class fusion given by known_class_fusion for the two tables.

Examples

julia> s = character_table("A5");  t = character_table("A6");

julia> maps = possible_class_fusions(s, t);  length(maps)
4

julia> chi = t[2];  rest = [restrict(chi, s, x) for x in maps];

julia> length(Set(rest))
2
source

Symmetrizations of group characters

symmetrizationsMethod
symmetrizations(characters::Vector{GAPGroupClassFunction}, n::Int)

Return the vector of symmetrizations of characters with the ordinary irreducible characters of the symmetric group of degree n.

The symmetrization $\chi^{[\lambda]}$ of the character $\chi$ with the character $\lambda$ of the symmetric group $S_n$ of degree n is defined by

\[\chi^{[\lambda]}(g) = (\sum_{\rho\in S_n} \lambda(\rho) \prod_{k=1}^n \chi(g^k)^{a_k(\rho)} ) / n!,\]

where $a_k(\rho)$ is the number of cycles of length $k$ in $\rho$.

Note that the returned list may contain zero class functions, and duplicates are not deleted.

For special kinds of symmetrizations, see symmetric_parts, anti_symmetric_parts, orthogonal_components, symplectic_components, exterior_power, symmetric_power.

source
symmetric_partsMethod
symmetric_parts(characters::Vector{GAPGroupClassFunction}, n::Int)

Return the vector of symmetrizations of characters with the trivial character of the symmetric group of degree n, see symmetrizations.

source
anti_symmetric_partsMethod
anti_symmetric_parts(characters::Vector{GAPGroupClassFunction}, n::Int)

Return the vector of symmetrizations of characters with the sign character of the symmetric group of degree n, see symmetrizations.

source
exterior_powerMethod
exterior_power(chi::GAPGroupClassFunction, n::Int)

Return the class function of the n-th exterior power of the module that is afforded by chi.

This exterior power is the symmetrization of chi with the sign character of the symmetric group of degree n, see also symmetrizations and anti_symmetric_parts.

source
symmetric_powerMethod
symmetric_power(chi::GAPGroupClassFunction, n::Int)

Return the class function of the n-th symmetric power of the module that is afforded by chi.

This symmetric power is the symmetrization of chi with the trivial character of the symmetric group of degree n, see also symmetrizations and symmetric_parts.

source
orthogonal_componentsMethod
orthogonal_components(characters::Vector{GAPGroupClassFunction}, n::Int)

Return the vector of the so-called Murnaghan components of the $m$-th tensor powers of the entries of characters, for $m$ up to n, where n must be at least 2 and at most 6 and where we assume that the entries of characters are irreducible characters with Frobenius-Schur indicator +1, see indicator.

source
symplectic_componentsMethod
symplectic_components(characters::Vector{GAPGroupClassFunction}, n::Int)

Return the vector of the Murnaghan components of the $m$-th tensor powers of the entries of characters, for $m$ up to n, where n must be at least 2 and at most 6 and where we assume that the entries of characters are irreducible characters with Frobenius-Schur indicator -1, see indicator.

source

Operations for character tables

class_multiplication_coefficientFunction
class_multiplication_coefficient(::Type{T} = ZZRingElem, tbl::GAPGroupCharacterTable, i::Int, j::Int, k::Int) where T <: IntegerUnion

Return the class multiplication coefficient of the classes i, j, and k of the group $G$ with ordinary character table tbl, as an instance of T.

The class multiplication coefficient $c_{i,j,k}$ of the classes $i, j, k$ equals the number of pairs $(x, y)$ of elements $x, y \in G$ such that $x$ lies in class $i$, $y$ lies in class $j$, and their product $xy$ is a fixed element of class $k$.

In the center of the group algebra of $G$, these numbers are found as coefficients of the decomposition of the product of two class sums $K_i$ and $K_j$ into class sums:

\[K_i K_j = \sum_k c_{ijk} K_k.\]

Given the character table of a finite group $G$, whose classes are $C_1, \ldots, C_r$ with representatives $g_i \in C_i$, the class multiplication coefficient $c_{ijk}$ can be computed with the following formula:

\[ c_{ijk} = |C_i| |C_j| / |G| \sum_{\chi \in Irr(G)} \chi(g_i) \chi(g_j) \chi(g_k^{-1}) / \chi(1).\]

On the other hand the knowledge of the class multiplication coefficients admits the computation of the irreducible characters of $G$.

Examples

julia> class_multiplication_coefficient(character_table("A5"), 2, 3, 4)
5

julia> class_multiplication_coefficient(character_table("A5"), 2, 4, 4)
0
source
known_class_fusionFunction
known_class_fusion(tbl1::GAPGroupCharacterTable, tbl2::GAPGroupCharacterTable)

Return (flag, fus) where flag == true if a class fusion to tbl2 is stored on tbl1, and flag == false otherwise.

In the former case, fus is the vector of integers, of length ncols(tbl1), such that the $i$-th conjugacy class of tbl1 corresponds to the fus[$i$]-th conjugacy class of tbl2, in the following sense.

If the group of tbl1 is a subgroup of the group of tbl2 then the $i$-th conjugacy class of tbl1 is contained in the fus[$i$]-th conjugacy class of tbl2. If the group of tbl2 is a factor group of the group of tbl1 then the image of the $i$-th conjugacy class tbl1 under the relevant epimorphism is the fus[$i$]-th conjugacy class of tbl2.

Examples

julia> t1 = character_table("A5");  t2 = character_table("A6");

julia> known_class_fusion(t1, t2)
(true, [1, 2, 3, 6, 7])

julia> known_class_fusion(t2, t1)
(false, Int64[])
source
known_class_fusionsFunction
known_class_fusions(tbl::GAPGroupCharacterTable)

Return the vector of pairs (name, fus) where name is the identifier of a character table and fus is the stored class fusion from tbl to this table, see known_class_fusion.

source
orderMethod
order(::Type{T} = ZZRingElem, tbl::GAPGroupCharacterTable) where T <: IntegerUnion

Return the order of the group for which tbl is the character table, as an instance of T.

Examples

julia> order(character_table(symmetric_group(4)))
24
source
possible_class_fusionsFunction
possible_class_fusions(subtbl::GAPGroupCharacterTable,
                       tbl::GAPGroupCharacterTable;
                       decompose::Bool = true,
                       fusionmap::Vector = [])

Return the vector of possible class fusions from subtbl to tbl. Each entry is an vector of positive integers, where the value at position i is the position of the conjugacy class in tbl that contains the i-th class of subtbl.

If decompose is set to true then the strategy is changed: The decomposability of restricted characters of tbl as integral linear combinations of characters of subtbl (with perhaps negative coefficients) is not checked; this does not change the result, but in certain situations it is faster to omit this step.

If fusionmap is set to a vector of integers and integer vectors then only those maps are returned that are compatible with the prescribed value.

Examples

julia> possible_class_fusions(character_table("A5"), character_table("A6"))
4-element Vector{Vector{Int64}}:
 [1, 2, 3, 6, 7]
 [1, 2, 3, 7, 6]
 [1, 2, 4, 6, 7]
 [1, 2, 4, 7, 6]
source
approximate_class_fusionFunction
approximate_class_fusion(subtbl::GAPGroupCharacterTable,
                         tbl::GAPGroupCharacterTable)

Compute for each class of subtbl all those classes in tbl to which it can fuse under an embedding of the group of subtbl into the group of tbl, according to element orders and centralizer orders in the two tables.

If no embedding is possible then return an empty vector. Otherwise return a vector of length equal to the number of classes of subtbl, such that the entry at position $i$ either an integer (if there is a unique possible image class) or the vector of the positions of possible image classes.

Examples

julia> subtbl = character_table("A5"); tbl = character_table("A6");

julia> println(approximate_class_fusion(subtbl, tbl))
Union{Int64, Vector{Int64}}[1, 2, [3, 4], [6, 7], [6, 7]]
source

Character tables and normal subgroups

Normal subgroups of a group $G$ are unions of conjugacy classes of elements of $G$. Thus one can often turn questions about a normal subgroup $N$ of $G$ into questions about the array of those positions in the list of conjugacy classes of $G$ that contain the elements of $N$.

centerMethod
center(chi::GAPGroupClassFunction)

Return C, f where C is the center of chi (i.e. the largest normal subgroup of the underlying group G of chi such that chi maps each element of C to chi[1] times a root of unity) and f is the embedding morphism of C into G.

Examples

julia> t = character_table(symmetric_group(4));

julia> chi = t[3];  chi[1]
2

julia> C, f = center(chi);  order(C)
4
source
class_positions_of_centerMethod
class_positions_of_center(tbl::GAPGroupCharacterTable)

Return the vector of integers $i$ such that the $i$-th conjugacy class of tbl is contained in the center of the group $G$ of tbl, i.e., the $i$-th class has length 1.

Examples

julia> tbl = character_table(dihedral_group(8));

julia> println(class_positions_of_center(tbl))
[1, 4]
source
class_positions_of_centerMethod
class_positions_of_center(chi::GAPGroupClassFunction)

Return the vector of those integers i such that chi[i] is chi[1] times a root of unity.

Examples

julia> println(class_positions_of_center(character_table("2.A5")[2]))
[1, 2]
source
class_positions_of_derived_subgroupFunction
class_positions_of_derived_subgroup(tbl::GAPGroupCharacterTable)

Return the vector of integers $i$ such that the $i$-th conjugacy class of tbl is contained in the derived subgroup of the group $G$ of tbl.

Examples

julia> tbl = character_table(dihedral_group(8));

julia> println(class_positions_of_derived_subgroup(tbl))
[1, 4]
source
kernelMethod
kernel(chi::GAPGroupClassFunction)

Return C, f where C is the kernel of chi (i.e. the largest normal subgroup of the underlying group G of chi such that chi maps each element of C to chi[1]) and f is the embedding morphism of C into G.

Examples

julia> t = character_table(symmetric_group(4));

julia> chi = t[3];  chi[1]
2

julia> C, f = kernel(chi);  order(C)
4
source
class_positions_of_kernelFunction
class_positions_of_kernel(chi::GAPGroupClassFunction)

Return the vector of those integers i such that chi[i] == chi[1] holds.

Examples

julia> println(class_positions_of_kernel(character_table("2.A5")[2]))
[1, 2]
source
class_positions_of_normal_subgroupsFunction
class_positions_of_normal_subgroups(tbl::GAPGroupCharacterTable)

Return a vector whose entries describe all normal subgroups of the group of tbl. Each entry is a vector of those class positions such that the union of these classes forms a normal subgroup.

Examples

julia> t = character_table("2.A5");

julia> class_positions_of_normal_subgroups(t)
3-element Vector{Vector{Int64}}:
 [1]
 [1, 2]
 [1, 2, 3, 4, 5, 6, 7, 8, 9]
source
class_positions_of_pcoreFunction
class_positions_of_pcore(tbl::GAPGroupCharacterTable, p::IntegerUnion)

Return the vector of integers $i$ such that the $i$-th conjugacy class of tbl is contained in the p-core of the group of tbl, see pcore(G::GAPGroup, p::IntegerUnion).

Examples

julia> println(class_positions_of_pcore(character_table("2.A5"), 2))
[1, 2]
source
class_positions_of_solvable_residuumFunction
class_positions_of_solvable_residuum(tbl::GAPGroupCharacterTable)

Return the vector of integers $i$ such that the $i$-th conjugacy class of tbl is contained in the solvable residuum of the group $G$ of tbl, i.e., the smallest normal subgroup $N$ of $G$ such that the factor group $G/N$ is solvable. This normal subgroup is equal to the last term of the derived series of $G$, see derived_series.

Examples

julia> tbl = character_table(symmetric_group(4));

julia> println(class_positions_of_solvable_residuum(tbl))
[1]
source