# Tables of Marks

The concept of a *Table of Marks* was introduced by W. Burnside in his book Theory of Groups of Finite Order [Bur55]. Therefore a table of marks is sometimes called a *Burnside matrix*. The table of marks of a finite group $G$ is a matrix whose rows and columns are labelled by the conjugacy classes of subgroups of $G$ and where for two subgroups $H$ and $K$ the $(H, K)$-entry is the number of fixed points of $K$ in the transitive action of $G$ on the cosets of $H$ in $G$. So the table of marks characterizes the set of all permutation representations of $G$. Moreover, the table of marks gives a compact description of the subgroup lattice of $G$, since from the numbers of fixed points the numbers of conjugates of a subgroup $K$ contained in a subgroup $H$ can be derived.

For small groups the table of marks of $G$ can be constructed directly by first computing the entire subgroup lattice of $G$, see `table_of_marks(G::Union{GAPGroup, FinGenAbGroup})`

. Besides that, the Table of Marks library [MNP24] provides access to several hundred tables of marks of simple groups and maximal subgroups of simple groups. These tables of marks can be fetched via the names of these groups, which coincide with the names of the character tables of these groups in the Character Table Library, see `table_of_marks(id::String)`

.

Like the library of character tables, the library of tables of marks can be used similar to group libraries (see Group libraries) in the sense that `all_table_of_marks_names`

returns descriptions of all those available tables of marks that have certain properties.

## Construct tables of marks

`GAPGroupTableOfMarks`

— Type`GAPGroupTableOfMarks <: GroupTableOfMarks`

This is the type of tables of marks that can delegate tasks to an underlying table of marks object in the GAP system (field `GAPTable`

).

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

support `get_attribute`

.

`table_of_marks`

— Method`table_of_marks(G::GAPGroup)`

Return the table of marks of the finite group `G`

.

**Examples**

```
julia> show(stdout, MIME("text/plain"), table_of_marks(symmetric_group(3)))
Table of marks of Sym(3)
1: 6
2: 3 1
3: 2 . 2
4: 1 1 1 1
```

`table_of_marks`

— Method`table_of_marks(id::String)`

Return the table of marks for which `id`

is an admissible name in GAP's library of tables of marks. If no such table is available then `nothing`

is returned.

**Examples**

```
julia> println(table_of_marks("A5"))
table of marks of A5
julia> println(table_of_marks("J5"))
nothing
```

`show`

— Method`Base.show(io::IO, ::MIME"text/plain", tom::GAPGroupTableOfMarks)`

Display the marks of `tom`

and context information as a two-dimensional array.

First a

*header*is shown. If`tom`

stores a group then the header describes this group, otherwise it is equal to the`identifier(tom::GAPGroupTableOfMarks)`

value of`tom`

.Then the matrix of marks of

`tom`

is shown in column portions that fit on the screen, together with*row labels*(the number`i`

for the`i`

-th row) on the left of each portion.

Output in $\LaTeX$ syntax can be created by calling `show`

with second argument `MIME("text/latex")`

.

**Examples**

```
julia> tom = table_of_marks("A5");
julia> show(stdout, MIME("text/plain"), tom)
A5
1: 60
2: 30 2
3: 20 . 2
4: 15 3 . 3
5: 12 . . . 2
6: 10 2 1 . . 1
7: 6 2 . . 1 . 1
8: 5 1 2 1 . . . 1
9: 1 1 1 1 1 1 1 1 1
```

`all_table_of_marks_names`

— Function`all_table_of_marks_names(L...; ordered_by = nothing)`

Return a vector of strings that contains an admissible name of each table of marks in the library of tables of marks that satisfies the conditions in the vector `L`

.

The supported conditions in `L`

are the same as for `all_character_table_names`

, and the returned vector contains the subset of those names returned by `all_character_table_names`

with the same input for which a table of marks is available in the library.

**Examples**

```
julia> spor_names = all_table_of_marks_names(is_sporadic_simple => true);
julia> println(spor_names[1:5])
["Co3", "HS", "He", "J1", "J2"]
julia> spor_names = all_table_of_marks_names(is_sporadic_simple;
ordered_by = order);
julia> println(spor_names[1:5])
["M11", "M12", "J1", "M22", "J2"]
julia> length(all_table_of_marks_names(number_of_conjugacy_classes => 5))
4
```

`is_table_of_marks_name`

— Function`is_table_of_marks_name(name::String)`

Return `true`

if `table_of_marks(name)`

returns a table of marks, and `false`

otherwise

**Examples**

```
julia> is_table_of_marks_name("J1")
true
julia> is_table_of_marks_name("J4")
false
```

## Attributes and operations for tables of marks

`class_lengths`

— Method`class_lengths(tom::GAPGroupTableOfMarks)`

Return the vector of the lengths of the conjugacy classes of subgroups for `tom`

.

**Examples**

```
julia> println(class_lengths(table_of_marks("A5")))
ZZRingElem[1, 15, 10, 5, 6, 10, 6, 5, 1]
```

`identifier`

— Method`identifier(tom::GAPGroupTableOfMarks)`

Return a string that identifies `tom`

if `tom`

belongs to the library of tables of marks, and an empty string otherwise.

**Examples**

```
julia> identifier(table_of_marks("A5"))
"A5"
julia> identifier(table_of_marks(symmetric_group(3)))
""
```

The `identifier`

of a table of marks from the library is equal to the `identifier`

of the corresponding library character table. In a few cases, this value differs from the `GAP.Globals.Identifier`

value of the underlying `GapObj`

of the table of marks.

`order`

— Method`order(::Type{T} = ZZRingElem, tom::GAPGroupTableOfMarks) where T <: IntegerUnion`

Return the order of the group for which `tom`

is the table of marks, as an instance of `T`

.

**Examples**

```
julia> order(table_of_marks(symmetric_group(4)))
24
```

`orders_class_representatives`

— Method`orders_class_representatives(tom::GAPGroupTableOfMarks)`

Return the vector of the orders of conjugacy class representatives for `tom`

, ordered according to the rows and columns of `tom`

.

**Examples**

```
julia> println(orders_class_representatives(table_of_marks("A5")))
ZZRingElem[1, 2, 3, 4, 5, 6, 10, 12, 60]
```

`representative`

— Method`representative(tom::GAPGroupTableOfMarks, i::Int)`

Return a representative from the `i`

-th class of subgroups of `tom`

.

An exception is thrown if `tom`

does not store a group, or if `i`

is larger than `length(tom)`

.

**Examples**

```
julia> representative(table_of_marks("A5"), 2)
Permutation group of degree 5 and order 2
```

## Marks vectors

The $\mathbb Z$-linear combinations of the rows of the table of marks of the group $G$ can be interpreted as elements of the integral *Burnside ring* of $G$: The rows of the table represent the isomorphism classes of transitive $G$-sets, the sum of two rows represents the isomorphism class of the disjoint union of the two $G$-sets, and the pointwise product of two rows represents the isomorphism class of the Cartesian product of the two $G$-sets. The coefficients of the decomposition of a linear combination of rows can be computed by `coordinates(chi::GAPGroupMarksVector)`

.

The rows of a table of marks and their $\mathbb Z$-linear combinations are implemented as marks vector objects, with `parent`

the table of marks.

length and iteration:

The length of a marks vector is the number of columns of the table of marks. iteration is defined w.r.t. the ordering of columns.

arithmetic operations:

`chi == psi`

: two marks vectors are equal if and only if they belong to the same table of marks and have the same values,`chi + psi`

and`chi - psi`

are the pointwise sum and difference, respectively, of the two marks vectors`chi`

,`psi`

,`n * chi`

is the pointwise`n`

-fold sum of`chi`

, for an integer`n`

,`chi * psi`

is the pointwise product of`chi`

and`psi`

,`zero(chi)`

is the marks vector that is zero on all classes,`one(chi)`

is the all-one marks vector, corresponding to the $G$-set that consists of one point,`chi^n`

is the`n`

-th power of`chi`

, for positive integers`n`

.

`coordinates`

— Method```
coordinates(::Type{T} = ZZRingElem, chi::GAPGroupMarksVector)
where T <: Union{IntegerUnion, QQFieldElem}
```

Return the vector $[a_1, a_2, \ldots, a_n]$ such that `chi`

is equal to $\sum_{i=1}^n a_i t[i]$ where $t$ is `parent(chi)`

.

The result is an instance of `Vector{T}`

. Note that the result can be shorter than `ncols(parent(chi))`

.

**Examples**

```
julia> tom = table_of_marks(symmetric_group(4));
julia> chi = tom[3] * tom[6]
marks_vector(table of marks of Sym(4), ZZRingElem[72, 0, 4])
julia> println(coordinates(Int, chi))
[2, 0, 2]
```

`restrict`

— Method`restrict(chi::GAPGroupMarksVector, tbl::GAPGroupCharacterTable)`

Return the class function with parent `tbl`

that is the restriction of `chi`

. For that, `parent(chi)`

and `tbl`

must belong to the same group $G$.

If `chi`

is the `i`

-th row in the table of marks `parent(chi)`

then the result is the permutation character of the action of $G$ on the right cosets of its subgroup `representative(parent(chi), i)`

.

**Examples**

```
julia> tom = table_of_marks("A5"); tbl = character_table(tom);
julia> chi = tom[5]
marks_vector(table of marks of A5, ZZRingElem[12, 0, 0, 0, 2])
julia> println(values(restrict(chi, tbl)))
QQAbFieldElem{AbsSimpleNumFieldElem}[12, 0, 0, 2, 2]
```

## The interface between tables of marks and character tables

`character_table`

— Method`character_table(tom::GAPGroupTableOfMarks)`

Return the character table of the group of `tom`

. If `tom`

belongs to the library of tables of marks then the corresponding character table from the library of character tables is returned, otherwise the character table of `group(tom)`

.

**Examples**

```
julia> g = symmetric_group(3); tom = table_of_marks(g);
julia> character_table(tom) == character_table(g)
true
```

`table_of_marks`

— Method`table_of_marks(tbl::GAPGroupCharacterTable)`

Return the table of marks of the group of `tbl`

. If `tbl`

does not store a group and if the library of tables of marks contains the table of marks corresponding to `tbl`

then this is returned, otherwise `nothing`

.

**Examples**

```
julia> g = symmetric_group(3); tbl = character_table(g);
julia> table_of_marks(tbl) == table_of_marks(g)
true
```