# Characters and Representations

A set of functions are provided for computing with the characters and representations of a group. A full account of the character functions may be found in Chapter [Characters of Finite Groups](../../RepresentationTheory/CharactersOfFiniteGroups/index-characters-of-finite-groups.md#chapchtr). Full details of the functions for constructing and analyzing representations may be found in Chapter [Modules over an Algebra and Group Representations](../../RepresentationTheory/ModulesOverAnAlgebraAndGroupRepresentations/index-modules-over-an-algebra-and-group-representations.md#chapmodalg). For the reader’s convenience we include here a description of the basic functions for creating characters and representations.

Some functions described in this section may be missing or may have slightly different calling sequences for some categories of groups. For a complete description of the features available for a special category of groups, we refer to the chapter devoted to that category.

## Character Theory

### `CharacterDegrees(G): GrpPC -> [ Tup ]`

Given a finite pc-group $G$, return the sequence $[\langle d_1,c_1\rangle, \langle d_2,c_2\rangle, \ldots]$, where $c_i$ is the number of irreducible characters of $G$ having degree $d_i$. For details of the algorithm see Conlon [[Conlon, 1990](../../references.md#cite-conlon-degrees)].

### `CharacterTable(G): GrpFin -> TabChtr`

Construct the table of irreducible characters for the group $G$.

### `PermutationCharacter(G): GrpPerm -> AlgChtrElt`

Given a group $G$ represented as a permutation group, construct the character of $G$ afforded by the defining permutation representation of $G$.

### `PermutationCharacter(G, H): GrpFin, GrpFin -> AlgChtrElt`

Given a group $G$ and some subgroup $H$ of $G$, construct the ordinary character of $G$ afforded by the permutation representation of $G$ given by the action of $G$ on the coset space of the subgroup $H$ in $G$.

### `BurnsideCokernel(G): Grp -> GrpAb, UserProgram, SeqEnum[AlgChtrElt]`

For a finite group $G$ computes the Burnside cokernel $C(G)$, the quotient of the rational representation ring $R_{\mathbb{Q}}(G)$ by the image of the Burnside ring (virtual permutation representations). Returns $C(G)$ as a finite abelian group, map $R_{\mathbb{Q}}(G)\to C(G)$, and a list of irreducible rational characters with non-trivial class in $C(G)$. (The implementation follows [[A. and Dokchitser, 2014](../../references.md#cite-bardok)], and does not compute the subgroup lattice.)

### `Example: Grp Burnsidecokernel (ex-79dcca)`

The first example of a finite group with $C(G)\ne 1$ is due to Serre, $G=C_3\times{\mathbb{Q}}_8$. In fact, there are two groups of order 24 with $C(G)\ne 1$ and no smaller examples:

```magma
> [GroupName(G): G in SmallGroups(n), n in [1..24] | #BurnsideCokernel(G) ne 1];
[ C3:C8, C3*Q8 ]

```

## Representation Theory

We describe the main functions for creating $K[G]$-modules for finite groups. The machinery for working with these modules is described in Chapter [Modules over an Algebra and Group Representations](../../RepresentationTheory/ModulesOverAnAlgebraAndGroupRepresentations/index-modules-over-an-algebra-and-group-representations.md#chapmodalg).

### `GModule(G, S): GrpFin, AlgMat -> ModGrpFin`

Let $G$ be a group defined on $r$ generators and let $S$ be a subalgebra of the matrix algebra $M_n(R)$, also defined by $r$ non-singular matrices. It is assumed that the mapping from $G$ to $S$ defined by $\phi : G.i \mapsto S.i$, for $i = 1, \ldots, r$, extends to a group homomorphism. Let $M$ be the natural module for the matrix algebra $S$. The function `GModule` gives $M$ the structure of an $S[G]$-module, where the action of the $i$-th generator of $G$ on $M$ is given by the $i$-th generator of $S$.

### `GModule(G, A, B): GrpFin, GrpFin, GrpFin -> ModGrpFin, Map`

Given a finite group $G$, a normal subgroup $A$ of G and a normal subgroup $B$ of $A$ such that the section $A/B$ is elementary abelian of order $p^n,$ create the $K[G]$-module $M$ corresponding to the action of $G$ on $A/B$, where $K$ is the field ${\bf F}_{p}$. If $B$ is trivial, it may be omitted. The function returns:

**(a)**
the module $M$; and,

**(b)**
the homomorphism $\phi : A/B \rightarrow M$.

### `PermutationModule(G, H, R): GrpFin, GrpFin, Rng -> ModGrpFin`

Given a finite group $G$ and a ring $R$, create the $R[G]$-module for $G$ corresponding to the permutation action of $G$ on the cosets of $H$.

### `PermutationModule(G, R): GrpPerm, Rng -> ModGrpFin`

Given a finite permutation group $G$ and a ring $R$, create the natural permutation module for $G$ over $R$.

### `Example: Modules (ex-652230)`

The permutation module for the group $M_{10}$ over $GF(2)$ may be created as follows:

```magma
> m10 := PermutationGroup< 10 |  (1, 3, 9, 10, 2, 8, 7, 6, 4, 5),
>                                (1, 7)(2, 4, 3, 6, 8, 10, 9, 5) >;
> p := PermutationModule(m10, GF(2));
> p : Maximal;

GModule p of dimension 10 over GF(2)
Generators of acting algebra:

[0 0 1 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 1 0 0]
[0 0 0 0 0 0 0 0 1 0]
[0 0 0 0 1 0 0 0 0 0]
[1 0 0 0 0 0 0 0 0 0]
[0 0 0 1 0 0 0 0 0 0]
[0 0 0 0 0 1 0 0 0 0]
[0 0 0 0 0 0 1 0 0 0]
[0 0 0 0 0 0 0 0 0 1]
[0 1 0 0 0 0 0 0 0 0]

[0 0 0 0 0 0 1 0 0 0]
[0 0 0 1 0 0 0 0 0 0]
[0 0 0 0 0 1 0 0 0 0]
[0 0 1 0 0 0 0 0 0 0]
[0 1 0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 1 0 0]
[1 0 0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 1]
[0 0 0 0 1 0 0 0 0 0]
[0 0 0 0 0 0 0 0 1 0]

```

### `Example: Modules 2 (ex-36abf4)`

The group $G$ defined below is the split extension of an elementary abelian group $E$ of order $16$ by $Alt(6)$. After setting up the group, we construct the module $M$ for $G$ corresponding to its action on $E$.

```magma
> G := PermutationGroup< 16 |
>         (1, 15, 7, 5, 12)(2, 9, 13, 14, 8)(3, 6, 10, 11, 4),
>         (1, 4, 5)(2, 8, 10)(3, 12, 15)(6, 13, 11)(7, 9, 14),
>         (1, 16)(2, 3)(4, 5)(6, 7)(8, 9)(10, 11)(12, 13)(14, 15) >;
> CS := ChiefSeries(G);
> [ Order(H) : H in CS ];
[ 5760, 16, 1 ]
> M := GModule(G, CS[2]);
> M:Maximal;

GModule M of dimension 4 over GF(2)
Generators of acting algebra:

[0 1 0 0]
[0 1 1 0]
[0 0 1 1]
[1 0 0 1]

[0 0 1 0]
[0 0 0 1]
[1 0 1 0]
[0 1 0 1]

[1 0 0 0]
[0 1 0 0]
[0 0 1 0]
[0 0 0 1]

```