# 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`

— Type`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.

`character_table`

— Function`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
```

`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
```

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

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`

— Method`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.

`all_character_table_names`

— Function`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
```

## Attributes of group characters

`character_field`

— Function`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)`

.

`conj`

— Method`conj(chi::GAPGroupClassFunction)`

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

.

`degree`

— Method```
degree(::Type{T} = QQFieldElem, chi::GAPGroupClassFunction)
where T <: Union{IntegerUnion, ZZRingElem, QQFieldElem, QQAbElem}
```

Return `chi[1]`

, as an instance of `T`

.

`indicator`

— Function`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$.

`is_faithful`

— Method`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> show(map(is_faithful, character_table(symmetric_group(3))))
Bool[0, 1, 0]
```

`is_rational`

— Method`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
```

`is_irreducible`

— Method`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.

`schur_index`

— Function`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`

.

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`

— Method`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
```

`order`

— Method```
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]
```

## Attributes of character tables

`character_parameters`

— Function`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"))
```

`class_parameters`

— Function`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"))
```

`decomposition_matrix`

— Function`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]
```

`identifier`

— Function`identifier(tbl::GAPGroupCharacterTable)`

Return a string that identifies `tbl`

. It is used mainly for library tables.

**Examples**

```
julia> identifier(character_table("A5"))
"A5"
```

`induced_cyclic`

— Method`induced_cyclic(tbl::GAPGroupCharacterTable)`

Return the array of permutation characters of `tbl`

that are induced from cyclic subgroups.

`is_duplicate_table`

— Function`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.

`maxes`

— Function`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
```

`names_of_fusion_sources`

— Function`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`

.

`class_lengths`

— Function`class_lengths(tbl::GAPGroupCharacterTable)`

**Examples**

```
julia> println(class_lengths(character_table("A5")))
ZZRingElem[1, 15, 20, 12, 12]
```

`orders_centralizers`

— Function`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")))
ZZRingElem[60, 4, 3, 5, 5]
```

`orders_class_representatives`

— Function`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]
```

`trivial_character`

— Method`trivial_character(tbl::GAPGroupCharacterTable)`

Return the character of `tbl`

that has the value `QQAbElem(1)`

in each position.

## Construct group characters from groups

`natural_character`

— Method`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.

`natural_character`

— Method`natural_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`

— Method`trivial_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 + 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_product`

— Function```
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.

`coordinates`

— Method```
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( [ 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
1
```

`multiplicities_eigenvalues`

— Function`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{nf_elem}[4, 0, 1, -1, -1]
julia> println(multiplicities_eigenvalues(chi, 5))
[1, 1, 1, 1, 0]
```

`induce`

— Method`induce(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))
2
```

`restrict`

— Method`restrict(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))
2
```

## Symmetrizations of group characters

`symmetrizations`

— Method`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`

.

`symmetric_parts`

— Method`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`

.

`anti_symmetric_parts`

— Method`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`

.

`exterior_power`

— Method`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`

.

`symmetric_power`

— Method`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`

.

`orthogonal_components`

— Method`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`

.

`symplectic_components`

— Method`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`

.

## Operations for character tables

`class_multiplication_coefficient`

— Function`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
```

`known_class_fusion`

— Function`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`

.

`order`

— Method`order(::Type{T} = ZZRingElem, 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
```

`possible_class_fusions`

— Function`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]
```

## 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`

— Method`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
```

`class_positions_of_center`

— Function`class_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`

— Method`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
```

`class_positions_of_kernel`

— Function`class_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`

— Method`pcore(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])
4
```

`class_positions_of_pcore`

— Function`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(G::GAPGroup, p::IntegerUnion)`

.

**Examples**

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