Character Tables in GAP
There are essentially 3 ways of obtaining and working with a character table in GAP. The first is to simply get
the table from GAP’s extensive library of character tables:
gap> c:=CharacterTable("M11");
CharacterTable( "M11" )
gap> OrdersClassRepresentatives(c);
[ 1,2,3,4,5,6,8,8,11,11 ]
gap> SizesCentralizers(c);
[ 7920,48,18,8,5,6,8,8,11,11 ]
gap> Display(c);
The result of Display is the character table with extra information.
M11
2
3
5
11
4
2
1
1
4
1
.
.
1
2
.
.
3
.
.
.
.
.
1
.
1
1
.
.
3
.
.
.
3
.
.
.
.
.
.
1
.
.
.
1
2P
3P
5P
11P
1a
1a
1a
1a
1a
2a
1a
2a
2a
2a
3a
3a
1a
3a
3a
4a
2a
4a
4a
4a
5a
5a
5a
1a
5a
6a
3a
2a
6a
6a
8a
4a
8a
8b
8a
8b
4a
8b
8a
8b
11a
11b
11a
11a
1a
11b
11a
11b
11b
1a
1
10
10
10
11
16
16
44
45
55
1 1 1 1 1 1 1
2 1 2 . -1 . .
-2 1 . . 1 A -A
-2 1 . . 1 -A A
3 2 -1 1 . -1 -1
. -2 . 1 . . .
. -2 . 1 . . .
4 -1 . -1 1 . .
-3 . 1 . . -1 -1
-1 1 -1 . -1 1 1
1
-1
-1
-1
.
B
/B
.
1
.
1
-1
-1
-1
.
/B
B
.
1
.
X.1
X.2
X.3
X.4
X.5
X.6
X.7
X.8
X.9
X.10
A = E(8)+E(8)^3 = ER(-2) = i2
B = E(11)+E(11)^3+E(11)^4+E(11)^5+E(11)^9
= (-1+ER(-11))/2 = b11
Once a table has been obtained,the Irr component can be used to obtain the list of irreducible characters.
Scalar products can be used for decomposition into irreducibles. The character functions also permit to pass
lists of character values as argument,as long as the character table is given as an extra argument.
gap> Irr(c)[2];
Character( CharacterTable( "M11" ),[ 10,2,1,2,0,-1,0,0,-1,-1 ] )
gap> ScalarProduct(Irr(c)[2],Irr(c)[3]);
0
gap> reg:=[7920,0,0,0,0,0,0,0,0,0,0,0,0,0,0];; # regular character
gap> ScalarProduct(c,Irr(c)[2],reg);
10
gap> MatScalarProducts(c,Irr(c),[reg]);
[ [ 1,10,10,10,11,16,16,44,45,55 ] ]
Computing a character table for a group
The second possibility is to use an algorithm due to John Dixon to compute the (central) characters as common
eigenvectors of the structure constants of the character table. GAP will do this automatically if a group is given.
(We will see later in the lecture how it works.)
gap> g:=TransitiveGroup(12,295);
M(12)
gap> c:=CharacterTable(g);
CharacterTable( M(12) )
gap> Display(c);
CT1 [...]
The call to CharacterTable in fact computes only the table head (classes,powermap),the call to Display (or
a call to Irr) will enforce computation of the characters (and thus takes some time). This process can take
substantial time and memory.
Computing a character table by character arithmetic
In this approach,we start with information about conjugacy classes and some representation and try to use the
properties of a character table and character operations to obtain irreducible characters. (This is the method
with which – using many extensions – many tables have been computed for the first time,often without being
able to compute explicitly in the group. The calculations would be feasible by hand, but it is far more convenient
to use the computer.)
We illustrate this in the example of the symmetric group S6 . Its conjugacy classes are given by the partitions
of 6:
∣r∣
∣r G ∣
∣CG (r)∣
1
2
1
2
1 15
720 48
2,2 2,2,2
2
2
45
15
16
48
3
3
40
18
3,2 3,3
6
3
120 40
6 18
4 4,2
4
4
90 90
8
8
5
5
144
5
6
6
120
6
Here we have calculated the class orders by a combinatorial argument and obtained the centralizer orders in
turn.
We now create a character table (head) with this information:
gap> c:=rec(Identifier:="S6",
> OrdersClassRepresentatives:=[ 1,2,2,2,3,6,3,4,4,5,6 ],
> SizesCentralizers:=[ 720,48,16,48,18,6,18,8,8,5,6 ],
> UnderlyingCharacteristic:=0);;
gap> ConvertToCharacterTable(c);
CharacterTable( "S6" )
We start building a list of irreducible characters. Our first entries are the two characters of degree 1 (as S6′ = A6 ).
gap> l:=[];;
gap> Add(l,Character(c,[1,1,1,1,1,1,1,1,1,1,1]));
gap> Add(l,Character(c,[ 1,-1,1,-1,1,-1,1,-1,1,1,-1 ]));
Next we build the permutation character (again based on the cycle shapes of the elements). We find that it has
product 2 with itself and thus must be the sum of two irreducibles. By problem 1 we know that one of them is
the trivial character,but we can also check this with character arithmetic:
gap> p:=Character(c,[ 6,4,2,0,3,1,0,2,0,1,0 ]);;
gap> ScalarProduct(p,p);
2
gap> ScalarProduct(p,l[1]);
1
We thus can subtract the trivial character and obtain an irreducible one:
gap> p:=p-l[1];
VirtualCharacter(CharacterTable("S6"),[5,3,1,-1,2,0,-1,1,-1,0,-1])
In fact it turns out to be more convenient to use the Reduced command. This takes a list of irreducible characters
and a list of characters and projects on the orthogonal complement of the first list. It also notes arising irreducible
characters:
gap> Reduced(l,[p]);
rec( remainders := [ ],
irreducibles :=
[ Character(CharacterTable("S6"),[5 ,1 -1,2,0,-1,1,-1,0,-1]) ]
gap> Add(l,last.irreducibles[1]);
)
We now can use simple products to compute tensor products of characters and immediately get one further
irreducible character:
gap> t:=l[2]*l[3];
Character( CharacterTable("S6"),[ 5,-3,1,1,2,0,-1,-1,-1,0,1 ] )
gap> ScalarProduct(t,t);
1
gap> t in l;
false
gap> Add(l,t);
Next we try the characters for (anti)symmetric parts of a tensor product. By Problem 25 we can calculate
these,once we know the second powermape (which we do from the element cycle structures) and store it in
the table:
gap> pow:=[1,1,1,1,5,5,7,3,3,10,7];;
gap> ComputedPowerMaps(c)[2]:=pow;;
Once we obtain lists of characters,we reduce by the irreducible characters we know and remember found irreducible characters.
gap> s:=AntiSymmetricParts(c,l,2);
[ VirtualCharacter( CharacterTable("S6"),[ 0,0,0,0,0,0,0,0,0,0,0 ] ),
[...]
Character( CharacterTable("S6"),[ 10,2,-2,-2,1,-1,1,0,0,0,1 ] ) ]
gap> r:=Reduced(l,s);
rec( remainders := [ ],
irreducibles := [ Character( CharacterTable("S6"),[ 10,2,-2,-2,1,
-1,1,0,0,0,1 ] ) ] )
gap> Add(l,last.irreducibles[1]);
The same for symmetric parts. (We could iterate for the newly found characters,but this does not give any new
information.)
gap> s:=SymmetricParts(c,l,2);
[ Character( CharacterTable("S6"),[ 1,1,1,1,1,1,1,1,1,1,1 ] ),
[...]
Character( CharacterTable("S6"),[ 55,7,7,7,1,1,1,-1,-1,0,1 ] ) ]
gap> r:=Reduced(l,s);
rec( remainders :=
[ VirtualCharacter( CharacterTable("S6"),[26,0,2,0,-4,0,2,0,-2,1,0 ] ) ],
irreducibles:=[Character( CharacterTable("S6"),[9,3,1,3,0,0,0,-1,1,-1,0])])
gap> Add(l,last.irreducibles[1]);
Finally we form some tensor products,namely of all found irreducible characters with the irreducibles number
3 and 5. Again we reduce.
gap> t:=Tensored(l,l{[3,5]});;
gap> r:=Reduced(l,t);
rec( remainders := [ ],irreducibles :=
[ Character( CharacterTable("S6"),[ 5,-1,1,3,-1,-1,2,1,-1,0,0 ] ),
[...]
Character( CharacterTable("S6"),[ 16,0,0,0,-2,0,-2,0,0,1,0 ] ) ] )
gap> Append(l,last.irreducibles);
We found the correct number or irreducible characters, and thus store them in the table.
gap> Length(l);
11
gap> SetIrr(c,l);
gap> Display(c);
S6
2 4 4 4 4 1 1 1 3 3 . 1
3 2 1 . 1 2 1 2 . . . 1
5 1 . . . . . . . . 1 .
1a 2a 2b 2c 3a 6a 3b 4a 4b 5a 6b
2P 1a 1a 1a 1a 3a 3a 3b 2b 2b 5a 3b
X.1
X.2
X.3
X.4
X.5
X.6
X.7
X.8
X.9
X.10
X.11
1
1
5
5
10
9
5
5
9
10
16
1 1 1 1 1 1 1 1 1 1
-1 1 -1 1 -1 1 -1 1 1 -1
3 1 -1 2 . -1 1 -1 . -1
-3 1 1 2 . -1 -1 -1 . 1
2 -2 -2 1 -1 1 . . . 1
3 1 3 . . . -1 1 -1 .
-1 1 3 -1 -1 2 1 -1 . .
1 1 -3 -1 1 2 -1 -1 . .
-3 1 -3 . . . 1 1 -1 .
-2 -2 2 1 1 1 . . . -1
. . . -2 . -2 . . 1 .