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 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.
GAPGroupCharacterTable — TypeGAPGroupCharacterTable <: GroupCharacterTableThis 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.
character_table — Functioncharacter_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 -1character_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"))
nothingcharacter_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.
| Series | Parameter |
|---|---|
:Cyclic | pos. integer |
:Dihedral | even pos. integer |
:Symmetric | pos. integer |
:Alternating | integer > 1 |
:WeylB | pos. integer |
:WeylD | integer > 1 |
:DoubleCoverSymmetric | pos. integer |
:DoubleCoverAlternating | pos. integer |
:GL2 | prime power |
:SL2odd | odd prime power |
:SL2even | even prime power |
:PSL2odd | odd prime power q s. t. (q-1)/2 is odd |
:PSL2even | odd prime power q s. t. (q-1)/2 is even |
:Suzuki | odd power of 2 |
:GU3 | prime power |
:SU3 | prime power |
Symbol("P:Q") | array [p, q] with prime p and q dividing p-1 |
:ExtraspecialPlusOdd | odd power of odd prime |
mod — Methodmod(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.
all_character_table_names — Functionall_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))
1Attributes of group characters
character_field — Functioncharacter_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).
conj — Methodconj(chi::GAPGroupClassFunction)Return the class function whose values are the complex conjugates of the values of chi.
degree — Methoddegree(::Type{T} = QQFieldElem, chi::GAPGroupClassFunction)
where T <: Union{IntegerUnion, ZZRingElem, QQFieldElem, QQAbElem}Return chi[1], as an instance of T.
indicator — Functionindicator(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$.
is_faithful — Methodis_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> show(map(is_faithful, character_table(symmetric_group(3))))
Bool[0, 1, 0]is_rational — Methodis_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)))
falseis_irreducible — Methodis_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.
schur_index — Functionschur_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.
schur_index(A::AlgAss{QQFieldElem}, p::Union{IntegerUnion, PosInf}) -> Int
Determine the Schur index of $A$ at $p$, where $p$ is either a prime or inf.
det — Methoddet(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)
trueorder — Methodorder(::Type{T} = ZZRingElem, chi::GAPGroupClassFunction)
where T <: IntegerUnionReturn 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]Attributes of character tables
character_parameters — Functioncharacter_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"))class_parameters — Functionclass_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"))decomposition_matrix — Functiondecomposition_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]identifier — Functionidentifier(tbl::GAPGroupCharacterTable)Return a string that identifies tbl. It is used mainly for library tables.
Examples
julia> identifier(character_table("A5"))
"A5"induced_cyclic — Methodinduced_cyclic(tbl::GAPGroupCharacterTable)Return the array of permutation characters of tbl that are induced from cyclic subgroups.
is_duplicate_table — Functionis_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.
maxes — Functionmaxes(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
truenames_of_fusion_sources — Functionnames_of_fusion_sources(tbl::GAPGroupCharacterTable)Return the array of strings that are identifiers of those character tables which store a class fusion to tbl.
class_lengths — Functionclass_lengths(tbl::GAPGroupCharacterTable)Examples
julia> println(class_lengths(character_table("A5")))
ZZRingElem[1, 15, 20, 12, 12]orders_centralizers — Functionorders_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")))
ZZRingElem[60, 4, 3, 5, 5]orders_class_representatives — Functionorders_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]trivial_character — Methodtrivial_character(tbl::GAPGroupCharacterTable)Return the character of tbl that has the value QQAbElem(1) in each position.
Construct group characters from groups
natural_character — Methodnatural_character(G::PermGroup)Return the permutation character of degree degree(G) that maps each element of G to the number of its fixed points.
natural_character — Methodnatural_character(G::Union{MatrixGroup{QQFieldElem}, 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 QQFieldElem or contained in a cyclotomic field.
trivial_character — Methodtrivial_character(G::GAPGroup)Return the character of (the ordinary character table of) G that has the value QQAbElem(1) in each position.
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 + psiandchi - psiare the pointwise sum and difference, respectively, of the two class functionschi,psi,n*chiis the pointwisen-fold sum ofchi, for an integern,chi*psiis the pointwise (tensor) product ofchiandpsi,zero(chi)is the class function that is zero on all classes,one(chi)is the trivial character of the character table ofchi,chi^nis then-th tensor power ofchi, for positive integersn,chi(g)is the value ofchiat the elementgof the group ofchi,chi^gis the conjugate character ofchiunder the action of a group elementgthat normalizes the group $G$ ofchi; we havechi^g(x) == chi(g*x*g^-1)for allxin $G$,chi^galautis the Galois conjugate character ofchiunder the pointwise action of the field automorphismgalaut(Ifgalautwas created asQQAbAutomorphism(k)then the action raises each root of unity to itsk-th power; this action defines a field automorphism of then-th cyclotomic field whenevernandkare coprime.)chi^tblis the character of the character tabletblthat is induced fromchi, where the group ofchiis a subgroup of the group oftbl.
scalar_product — Functionscalar_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.
coordinates — Methodcoordinates(::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( [ 1 .. 4 ] )
julia> chi = natural_character(g);
julia> coordinates(Int, chi)
5-element Vector{Int64}:
0
0
0
1
1
julia> t = chi.table; t3 = mod(t, 3); chi3 = restrict(chi, t3);
julia> coordinates(Int, chi3)
4-element Vector{Int64}:
0
1
0
1multiplicities_eigenvalues — Functionmultiplicities_eigenvalues(::Type{T} = Int, chi::GAPGroupClassFunction, i::Int) where T <: IntegerUnionLet $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{nf_elem}[4, 0, 1, -1, -1]
julia> println(multiplicities_eigenvalues(chi, 5))
[1, 1, 1, 1, 0]induce — Methodinduce(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 = [induce(chi, t, x) for x in maps];
julia> length(Set(ind))
2restrict — Methodrestrict(chi::GAPGroupClassFunction, subtbl::GAPGroupCharacterTable[, fusion::Vector{Int}])Return the class function of subtbl that is the restriction of chi, which is a class function of a supergroup of 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))
2Symmetrizations of group characters
symmetrizations — Methodsymmetrizations(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.
symmetric_parts — Methodsymmetric_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.
anti_symmetric_parts — Methodanti_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.
exterior_power — Methodexterior_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.
symmetric_power — Methodsymmetric_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.
orthogonal_components — Methodorthogonal_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.
symplectic_components — Methodsymplectic_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.
Operations for character tables
class_multiplication_coefficient — Functionclass_multiplication_coefficient(::Type{T} = ZZRingElem, tbl::GAPGroupCharacterTable, i::Int, j::Int, k::Int) where T <: IntegerUnionReturn 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)
0known_class_fusion — Functionknown_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.
order — Methodorder(::Type{T} = ZZRingElem, tbl::GAPGroupCharacterTable) where T <: IntegerUnionReturn the order of the group for which tbl is the character table.
Examples
julia> order(character_table(symmetric_group(4)))
24possible_class_fusions — Functionpossible_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]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$.
center — Methodcenter(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)
4class_positions_of_center — Functionclass_positions_of_center(chi::GAPGroupClassFunction)Return the array 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]kernel — Methodkernel(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)
4class_positions_of_kernel — Functionclass_positions_of_kernel(chi::GAPGroupClassFunction)Return the array 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]pcore — Methodpcore(tbl::GAPGroupCharacterTable, p::IntegerUnion)Return the p-core of the group of tbl, see pcore(G::GAPGroup, p::IntegerUnion), but computed character-theoretically (see class_positions_of_pcore).
Examples
julia> order(pcore(character_table(symmetric_group(4)), 2)[1])
4class_positions_of_pcore — Functionclass_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(G::GAPGroup, p::IntegerUnion).
Examples
julia> println(class_positions_of_pcore(character_table("2.A5"), 2))
[1, 2]