MATH666
A. Hulpke
Possible Permutation Characters
One can get candidates for permutation characters by testing linear combinations of irreducible
characters with nonnegative integer coefficients for fulfilling certain necessary conditions. While
there is no guarantee, usually most of the resulting characters are bona fide permutation characters.
gap> c:=CharacterTable("A5");
CharacterTable( "A5" )
gap> p:=PermChars(c);
[ Character( CharacterTable( "A5"
Character( CharacterTable( "A5"
Character( CharacterTable( "A5"
Character( CharacterTable( "A5"
Character( CharacterTable( "A5"
Character( CharacterTable( "A5"
Character( CharacterTable( "A5"
Character( CharacterTable( "A5"
Character( CharacterTable( "A5"
),
),
),
),
),
),
),
),
),
[
[
[
[
[
[
[
[
[
1, 1, 1, 1, 1 ] ),
5, 1, 2, 0, 0 ] ),
6, 2, 0, 1, 1 ] ),
10, 2, 1, 0, 0 ] ),
12, 0, 0, 2, 2 ] ),
15, 3, 0, 0, 0 ] ),
20, 0, 2, 0, 0 ] ),
30, 2, 0, 0, 0 ] ),
60, 0, 0, 0, 0 ] ) ]
Sylow theorems show easily that in this case all must be proper permutation characters.
Note that π2 = χ1 + χ4 and π4 = χ1 + χ4 + χ5 , while the corresponding subgroups are not contained
in each other, thus subgroup inclusion cannot be determined from permutation characters.
Determining subgroups from a character table
We want to study subgroups of M11 , based on information in its character table. We start by obtaining
the table and the potential permutation characters:
gap> c:=CharacterTable("M11");;
gap> p:=PermChars(c);
[ Character( CharacterTable( "M11"
Character( CharacterTable( "M11"
Character( CharacterTable( "M11"
[...]
Character( CharacterTable( "M11"
), [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ] ),
), [ 11, 3, 2, 3, 1, 0, 1, 1, 0, 0 ] ),
), [ 12, 4, 3, 0, 2, 1, 0, 0, 1, 1 ] ),
), [ 7920, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] ) ]
Lets start looking at the 2-Sylow subgroup. As 7920 = 24 32 5 ⋅ 11 it has index 7920/16 = 495. There is
only one potential permutation character of this degree.
gap> pc:=Filtered(p,i->i[1]=495);
[ Character( CharacterTable( "M11" ), [ 495, 15, 0, 3, 0, 0, 1, 1, 0, 0 ] ) ]
gap> pc:=pc[1];
Let U be a 2-Sylow subgroup. From the formula for the induced class function, we can calculate
how many elements of U lie in each class of G:
gap>
[ 1,
gap>
[ 1,
List([1..10],i->pc[i]/pc[1]*SizesConjugacyClasses(c)[i]);
5, 0, 6, 0, 0, 2, 2, 0, 0 ]
OrdersClassRepresentatives(c);
2, 3, 4, 5, 6, 8, 8, 11, 11 ]
We have one element of order 1, five elements of order 2, six elements of order 4 and twice two
elements of order 8. Inspecting the list of groups of order 16, this already uniquely identifies the
isomorphism type of U.
gap> NrSmallGroups(16);
14
gap> List([1..14],i->Collected(List(Elements(SmallGroup(16,i)),Order)));
[ [ [ 1, 1 ], [ 2, 1 ], [ 4, 2 ], [ 8, 4 ], [ 16, 8 ] ], [...]
[ [ 1, 1 ], [ 2, 5 ], [ 4, 6 ], [ 8, 4 ] ], [...] ]
Lets now look at the subgroup S of index 11 (a point stabilizer) in more detail. Again we get numbers
of elements as well as the indices of the classes in which the elements lie.
gap> pc:=p[2];
Character( CharacterTable( "M11" ), [ 11, 3, 2, 3, 1, 0, 1, 1, 0, 0 ] )
gap> sz:=List([1..10],i->pc[i]/pc[1]*SizesConjugacyClasses(c)[i]);
[ 1, 45, 80, 270, 144, 0, 90, 90, 0, 0 ]
gap> sel:=Filtered([1..10],i->sz[i]>0);
[ 1, 2, 3, 4, 5, 7, 8 ]
Based on these numbers, we can already calculate the scalar product of restrictions of characters of
M11 to S.
gap> prdrest:=function(a,b)
> return pc[1]/Size(c)*Sum(sel,i->sz[i]*a[i]*GaloisCyc(b[i],-1));end;
gap> gram:=List(Irr(c),i->List(Irr(c),j->prdrest(i,j)));;
gap> Display(gram);
[ [ 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 ],
[ 1, 2, 0, 0, 0, 0, 0, 1, 1, 0 ],
[ 0, 0, 1, 0, 0, 0, 0, 0, 1, 1 ],
[ 0, 0, 0, 1, 0, 0, 0, 0, 1, 1 ],
[ 0, 0, 0, 0, 2, 0, 0, 1, 0, 1 ],
[ 0, 0, 0, 0, 0, 1, 1, 1, 1, 1 ],
[ 0, 0, 0, 0, 0, 1, 1, 1, 1, 1 ],
[ 0, 1, 0, 0, 1, 1, 1, 4, 2, 3 ],
[ 0, 1, 1, 1, 0, 1, 1, 2, 4, 3 ],
[ 0, 0, 1, 1, 1, 1, 1, 3, 3, 5 ] ]
This tells us that χ1 , χ2 −χ1 , χ3 ,χ4 and χ6 restrict to irreducible characters. We also take the restrictions
of the remaining characters.
gap> s:=[Irr(c)[1],Irr(c)[2]-Irr(c)[1],Irr(c)[3],Irr(c)[4],Irr(c)[6]];;
gap> r:=Irr(c){[5,7,8,9,10]};
Next we reduce the restricted characters with the restricted irreducibles. Two reduce completely,
two proper reducible characters, each of norm 2, remain.
gap> List(r,i->List(s,j->prdrest(i,j)));
[ [ 0,0,0,0,0 ], [ 0,0,0,0,1 ], [ 0,1,0,0,1 ], [ 0,1,1,1,1 ], [ 0,0,1,1,1 ] ]
gap> r[2]:=r[2]-s[5];;
gap> r[3]:=r[3]-s[2]-s[5];;r[4]:=r[4]-s[2]-s[3]-s[4]-s[5];;
gap> r[5]:=r[5]-s[3]-s[4]-s[5];;
gap> List(r,i->prdrest(i,i));
[ 2, 0, 2, 0, 2 ]
gap> r[3]{sel}=r[5]{sel};
true
gap> r:=r{[1,3]};;
These two reducible characters have degrees 11 and 19 they have the form χ1 + χ2 and χ1 + χ3 where
all three characters are irreducible characters of S that are not yet known.
gap> List(r,i->i[1]);
[ 11, 19 ]
gap> List(r,i->List(r,j->prdrest(i,j)));
[ [ 2, 1 ], [ 1, 2 ] ]
We now look at the list of irreducible restrictions. Their degrees sum up to 538.
gap> List(s,i->i{sel});
[ [ 1, 1, 1, 1, 1, 1, 1 ], [ 9, 1, 0, 1, -1, -1, -1 ],
[ 10, -2, 1, 0, 0, E(8)+E(8)^3, -E(8)-E(8)^3 ],
[ 10, -2, 1, 0, 0, -E(8)-E(8)^3, E(8)+E(8)^3 ], [ 16, 0, -2, 0, 1, 0, 0 ] ]
gap> 1^2+9^2+10^2+10^2+16^2;
538
gap> RootInt(720-538);
13
We now search for tuples of numbers in {1, . . . , 13} such that their squares sum up to 182. Furthermore the reducible characters tell us that there must be degrees a, b, c among the numbers such that
a + b = 11 and a + c − 19.
gap> Filtered(UnorderedTuples([1..13],2),i->Sum(i,j->j^2)=182);
[ ]
gap> Filtered(UnorderedTuples([1..13],3),i->Sum(i,j->j^2)=182);
[ [ 1, 9, 10 ], [ 2, 3, 13 ], [ 5, 6, 11 ] ]
gap> Filtered(UnorderedTuples([1..13],4),i->Sum(i,j->j^2)=182);
[ [ 1, 1, 6, 12 ], [ 1, 6, 8, 9 ], [ 2, 3, 5, 12 ], [ 2, 4, 9, 9 ],
[ 3, 3, 8, 10 ], [ 3, 4, 6, 11 ], [ 4, 6, 7, 9 ] ]
gap> Filtered(UnorderedTuples([1..13],5),i->Sum(i,j->j^2)=182);
[ [ 1, 1, 4, 8, 10 ], [ 1, 2, 2, 2, 13 ], [ 1, 2, 7, 8, 8 ],
[...]
[ 4, 4, 5, 5, 10 ], [ 5, 6, 6, 6, 7 ] ]
the only possibility from among these numbers is 1, 9, 10, the character degrees of S thus are 1, 1, 9, 9, 10, 10, 10, 16.
We thus miss one class. If we look at potential centralizer orders, we find that the fourth class (element order 4) must split.
gap> List(sz{sel},i->720/i);
[ 720, 16, 9, 8/3, 5, 8, 8 ]
gap> sz[4];
270
To determine class orders a, b we note that the class orders must add up to 270. They also are the
indices of the element centralizers and thus (the elements of order 4 centralize themselves) must
divide 720/4 = 180. This leaves only one choice, class orders 90 and 180.
gap> d:=DivisorsInt(720/4);
[ 1, 2, 3, 4, 5, 6, 9, 10, 12, 15, 18, 20, 30, 36, 45, 60, 90, 180 ]
gap> Filtered(UnorderedTuples(d,2),x->Sum(x)=270);
[ [ 90, 180 ] ]
All the restrictions that we know to be irreducible will have the same value on these two classes.
At this point it is easy to complete the character table of S from orthogonality relations and the
values of the two reducible restrictions.
Class Fusion, Induction and Restrictions
If G ≤ H every representation of H also gives a representation of G. To restrict characters we need
to know which class of G lies in which class of H (we call this a class fusion). Such a class fusion
is given by a list, which tells for every class of the smaller group, into which class (number) of the
larger group it fuses.
For complete character tables FusionConjugacyClasses can often compute such a fusion (the
library tables have them stored), in other cases one can use information about the groups. For
example suppose we now look at A6 :
1
∣r∣
1
G
∣r ∣
1
∣CG (r)∣ 360
2,2
2
45
8
3
3
40
9
3,3 4,2
3
4
40 90
9
4
5
5
72
5
5
5
72
5
This gives the character table head:
gap> d:=rec(Identifier:="A6",
> OrdersClassRepresentatives:=[ 1, 2, 3, 3, 4, 5, 5 ],
> SizesCentralizers:=[ 360, 8, 9, 9, 4, 5, 5 ],
> UnderlyingCharacteristic:=0);;
gap> ConvertToCharacterTable(d);
CharacterTable( "A6" )
The class fusion is obtained by the cycle structures of the representatives. We store the fusion in the
character tables:
gap> fus:=[1,3,5,7,9,10,10];;
gap> StoreFusion(d,c,fus);
Now we can restrict the characters of S6 to A6 . (We form a set to remove duplicates.)
gap> res:=Set(Restricted(c,d,Irr(c)));
[ [...] ClassFunction( CharacterTable( "A6" ), [ 5, 1, -1, 2, -1, 0, 0 ] ),
[...]
We calculate the norms and (as expected) find that some restrictions are irreducible, the remaining
characters are sums of two conjugate characters. We store the irreducible ones and remember the
(in this case one) reducible character.
gap> List(res,i->ScalarProduct(i,i));
[ 1, 1, 1, 1, 1, 2 ]
gap> l:=res{[1..5]};;
gap> psi:=res[6];;
ClassFunction( CharacterTable( "A6" ), [ 16, 0, -2, -2, 0, 1, 1 ] )
We know that ψ is the sum of two conjugate irreducible characters. As the first five classes are S n classes, conjugation cannot change character values. Thus the irreducible constituents of ψ must
have the form
χ6 8 0 −1 −1 0 x y
χ7 8 0 −1 −1 0 z w
where x + z = 1 = y + w. The orthogonality relations give again that x = w must fulfill x 2 − x − 1, we
thus can choose one root and get the missing character values:
gap>
gap>
1
gap>
gap>
gap>
chi:=Character(d,[8,0,-1,-1,0,-EB(5),GaloisCyc(-EB(5),2)]);;
ScalarProduct(chi,chi);
Add(l,chi);
chi:=Character(d,[8,0,-1,-1,0,GaloisCyc(-EB(5),2),-EB(5)]);;
Add(l,chi);
The list of characters is complete. We sort by degrees and store the list
gap> Sort(l); A6
gap> SetIrr(d,l);
gap> Display(d);
2
3
5
3 3 . . 2 .
2 . 2 2 . .
1 . . . . 1
1a 2a 3a 3b 4a 5a
X.1
1 1 1 1 1 1
X.2
5 1 2 -1 -1 .
X.3
5 1 -1 2 -1 .
X.4
8 . -1 -1 . A
X.5
8 . -1 -1 . *A
X.6
9 1 . . 1 -1
X.7
10 -2 1 1 . .
A = -E(5)-E(5)^4 = (1-ER(5))/2 =
.
.
1
5b
1
.
.
*A
A
-1
.
-b5
Let us now look at an example for induction. We want to calculate the character table of SL2 (8) ≅
PSL2 (8). (This is the only simple group of order 504.) Using normal form theory (with a bit of extra
work to go from GL to SL), we find that the group contains the following classes:
∣r∣
∣CG (r)∣
∣r G ∣
1
504
1
2
3
8 9
63 56
7
7
72
7
7
72
7
7
72
9
9
56
9
9
56
9
9
56
We form a table for this information:
gap> ct:=rec(Identifier:="SL2(8)",
> OrdersClassRepresentatives:=[1,2,3,7,7,7,9,9,9],
> SizesCentralizers:=[504,8,9,7,7,7,9,9,9],
> UnderlyingCharacteristic:=0);;
gap> ConvertToCharacterTable(ct);;
gap> irr:=[Character(ct,[1,1,1,1,1,1,1,1,1])];;
We also observe that squaring the representatives of the classes of order 7 and 9 gives mutually the
other classes.
Let us first consider a cyclic subgroup of order 9. We can create the character table for this group
easily (homework!), using 9th roots of unity.
gap> d:=CharacterTable("cyclic",9);; Display(d);
1a 9a 9b 3a 9c 9d 3b 9e 9f
X.2
1 A B C D /D /C /B /A
Next we compute the fusion from this subgroup into the table of G. We know that the classes of
order 3 all must fuse into the one class of order 3. The first class of order 9 can be (we have not
identified the classes of G) assumed to fuse in the first class of elements of order 9. The actual values
of the roots of unity then give the power map for prime 2 (already displayed above) and thus tells
how classes fuse.
gap> fus:=[1,7,8,3,9,9,3,8,7];;
gap> StoreFusion(d,ct,fus);
We are now able to induce the characters. We remove any contribution of the trivial character
gap> ind:=Induced(d,ct,Irr(d));
[ Character( CharacterTable( "SL2(8)" ), [ 56, 0, 2, 0, ...
gap> ind:=Reduced(irr,ind);
rec( remainders := [ VirtualCharacter( CharacterTable( "SL2(8)" ),
[ 55,-1,1,-1,-1,-1,1,1,1] ), ... ] ) ], irreducibles := [ ] )
gap> ind:=ind.remainders;;
For a second subgroup consider the upper triangular matrices. We have 7 choices for the diagonal (as the determinant is 1) and 8 choices for the upper right corner, thus this is a subgroup of
order 56. It is easyly seen that it is a semidirect product of a group of type F+8 ≅ C23 with a cyclic
group (F∗8 ) of order 7. Similarly to the dihedral group example in the homework we could determine
its character table by hand. (Here we let GAP just do it, constructing the semidirect product as a
permutation group by its action on the normal subgroup of order 8).
gap> s:=Group((1,2)(3,4)(5,6)(7,8),(2,3,5,6,7,4,8));;
gap> d:=CharacterTable(s);;Display(d);
1a 7a 7b 7c 7d 7e 7f 2a
2P 1a 7c 7d 7e 7f 7a 7b 1a
X.2
1 A /B B C /C /A 1 ...
X.8
7 . . . . . . -1
A = E(7)^6, B = E(7)^5, C = E(7)^4
Again the second power map tells us the possible fusion
gap> fus:=[1,4,5,5,6,6,4,2];;
gap> StoreFusion(d,ct,fus);
gap> ind2:=Induced(d,ct,Irr(d));
[ Character( CharacterTable( "SL2(8)" ), [ 9, 1, 0, 2, 2, 2, 0, 0, 0 ] ), ...
gap> ind2:=Reduced(irr,ind2);
rec( remainders := [ VirtualCharacter( CharacterTable( "SL2(8)" ), ...
irreducibles := [ Character( CharacterTable( "SL2(8)" ),
[ 8, 0, -1, 1, 1, 1, -1, -1, -1 ] ), ...
We find 4 irreducible characters and 1 remaining reducible character. We use the irreducible characters to clean out further and keep the reducible characters:
gap>
gap>
gap>
rec(
gap>
gap>
[ 3,
Append(irr,ind2.irreducibles);
Append(ind,ind2.remainders);
ind:=Reduced(irr,ind);
remainders := [ ... irreducibles := [
ind:=ind.remainders;;
List(ind,i->ScalarProduct(i,i));
3, 3, 3, 4 ]
] )
LLL-Reduction
We now could try to find further characters for reduction or use clever tricks based on the mutual
inner products. However the combinatorics involved soon becomes rather hard.
Instead the LLL algorithm (due to H.Lenstra, A.Lenstra and L.Lovasz) forms integer linear
combinations of a set of vectors and tries to find short vectors (i.e. it finds short vectors in a lattice).
Often this leads to irreducible characters.
gap> LLL(ct,ind);
rec( irreducibles := [ Character( CharacterTable( SL2(8) ), [ ...
, remainders := [ ], norms := [ ] )
This gives us the whole table
gap> Append(irr,last.irreducibles);
gap> SetIrr(ct,irr);
gap> Display(ct);
2 3 3 . . . . . . .
3 2 . 2 . . . 2 2 2
7 1 . . 1 1 1 . . .
1a 2a 3a 7a 7b 7c 9a 9b 9c
X.1
X.2
X.3
X.4
X.5
X.6
X.7
X.8
X.9
1
7
7
7
7
8
9
9
9
1 1
-1 -2
-1 1
-1 1
-1 1
. -1
1 .
1 .
1 .
1
.
.
.
.
1
A
B
C
1
.
.
.
.
1
B
C
A
1 1 1 1
. 1 1 1
. D F E
. E D F
. F E D
1 -1 -1 -1
C . . .
A . . .
B . . .
A = E(7)^3+E(7)^4, B = E(7)+E(7)^6, C = E(7)^2+E(7)^5
D = -E(9)^4-E(9)^5, E = -E(9)^2-E(9)^7, F = E(9)^2+E(9)^4+E(9)^5+E(9)^7
Indeed today a standard method for obtaining the character table of a finite group is to determine
the irreducible characters for sufficiently many small subgroups (if they are of the form A ⋊ B with
A, B cyclic this is easy) and to induce these characters up to the whole group, using LLL reduction
to obtain irreducibles.