Group characters

Let $G$ be a finite group, and let $\rho: G \rightarrow GL(n, R)$ be a group homomorphism, for some ring $R$. We call $\chi: G \rightarrow 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 Atlas of Finite Groups J. H. Conway, R. T. Curtis, S. P. Norton, R. A. Parker, R. A. Wilson (1985) and from the Atlas of Brauer Characters C. Jansen, K. Lux, R. Parker, R. Wilson (1995) are available in OSCAR. Such character tables can be fetched with character_table from the database, via their names.

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 the field characteristic; its value is 0 for ordinary tables and $p$ otherwise.

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

An object of type GAPGroup can (but need not) be stored in the field GAPGroup.

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

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_tableFunction
character_table(G::GAPGroup, p::Int = 0)

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(character_table(symmetric_group(3)))
       end;
Sym( [ 1 .. 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(character_table(symmetric_group(3), 2))
       end;
Sym( [ 1 .. 3 ] ) mod 2

 2  1  .
 3  1  1
        
   1a 3a
2P 1a 3a
3P 1a 1a
        
χ₁  1  1
χ₂  2 -1
source
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("A5")

julia> println(character_table("A5", 2))
character_table("A5mod2")

julia> println(character_table("J5"))
nothing
source
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("Sym(5)")

julia> println(character_table(:WeylB, 3))
character_table("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")array [p, q] with prime p and q dividing p-1
:ExtraspecialPlusOddodd power of odd prime
source
modMethod
mod(tbl::GAPGroupCharacterTable, p::Int)

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

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

source
all_character_table_namesFunction
all_character_table_names(L...; ordered_by = nothing)

Return an array of strings that contains all those names of character tables in the character table library that satisfy the conditions in the array 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_conjugacy_classes => 1))
1
source

Attributes of group characters

character_fieldFunction
character_field(chi::GAPGroupClassFunction)

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

source
conjMethod
conj(chi::GAPGroupClassFunction)

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

source
degreeMethod
degree(::Type{T} = fmpq, chi::GAPGroupClassFunction)
       where T <: Union{IntegerUnion, fmpz, mpq, 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$.

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.

source
schur_indexFunction

schur_index(A::AlgAss{fmpq}, p::Union{IntegerUnion, PosInf}) -> Int

Determine the Schur index of $A$ at $p$, where $p$ is either a prime or inf.

schur_index(chi::GAPGroupClassFunction)

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.

source

Attributes of character tables

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_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
decomposition_matrixFunction
decomposition_matrix(modtbl::GAPGroupCharacterTable)

Return the decomposition matrix (of type fmpz_mat) 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)

Return the array of permutation characters of tbl that are induced from cyclic subgroups.

source
is_duplicate_tableFunction
is_duplicate_table(tbl::GAPGroupCharacterTable)

Return whether tbl is a 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.

source
maxesFunction
maxes(tbl::GAPGroupCharacterTable)

Return either nothing (if the value is not known) or an array 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 array of strings that are identifiers of those character tables which store a class fusion to tbl.

source
class_lengthsFunction
class_lengths(tbl::GAPGroupCharacterTable)

Examples

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

Return the array 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")))
fmpz[60, 4, 3, 5, 5]
source
orders_class_representativesFunction
orders_class_representatives(tbl::GAPGroupCharacterTable)

Return the array 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
trivial_characterMethod
trivial_character(tbl::GAPGroupCharacterTable)

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

source

Construct group characters from groups

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.

source
natural_characterMethod
natural_character(G::Union{MatrixGroup{fmpq}, MatrixGroup{nf_elem}})

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 fmpq or contained in a cyclotomic field.

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.

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} = fmpq, chi::GAPGroupClassFunction, psi::GAPGroupClassFunction)
               where T <: Union{IntegerUnion, fmpz, fmpq, QQAbElem}

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

source
induced_class_functionFunction
induced_class_function(chi::GAPGroupClassFunction, tbl::GAPGroupCharacterTable[, fusion::Vector{Int}])

Return the class function of tbl that is induced from chi, which is a class function of a subgroup of 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.

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 = [induced_class_function(chi, t, x) for x in maps];  length(ind)
4
julia> length(Set(ind))
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} = fmpz, 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.

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

Return the order of the group for which tbl is the character table.

Examples

julia> order(character_table(symmetric_group(4)))
24
source
possible_class_fusionsFunction
possible_class_fusions(subtbl::GAPGroupCharacterTable, tbl::GAPGroupCharacterTable)

Return the array of possible class fusions from subtbl to tbl. Each entry is an array 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.

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

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

class_positions_of_kernelFunction
class_positions_of_kernel(chi::GAPGroupClassFunction)

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

source
class_positions_of_pcoreFunction
class_positions_of_pcore(tbl::GAPGroupCharacterTable, p::IntegerUnion)

Return the array 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.

Examples

julia> println(Oscar.class_positions_of_pcore(character_table("2.A5"), 2))
[1, 2]
source