The construction of all irreducible K[G]-modules for a finite group G is of major interest. If G is soluble there is a very effective method that dates back to Schur. This proceeds by working up a composition series for G and constructing the irreducibles for each subgroup by inducing or extending representations from the previous subgroup. This works equally well over finite fields and over fields of characteristic zero. If G is non-soluble the situation is more difficult. Starting with a faithful representation, by a theorem of Burnside, it is possible to construct all representations by splitting tensor powers of the faithful representation. This approach will be called the Burnside algorithm. An algorithm based on this idea developed by John Cannon and Derek Holt uses the Meataxe to split representations and works well over small finite fields. An algorithm for enumerating all rational irreducible representations has been developed by Allan Steel and has been in use for some years. In order to compute the ordinary irreducible modules Allan Steel, in his PhD thesis, developed a method which constructs the irreducible modules recursively by taking irreducibles of subgroups and lifting them to G using induction and extension. Heavy use of character tables is made to guide the procedure. The implemented algorithm was made available in Magma for the first time in March, 2021.
The functions described in this section construct all irreducible representations of a finite group. The choice of algorithm depends upon the type of group and the kind of field given. The individual algorithms may be invoked directly by means of intrinsic functions described in subsequent sections.
The Burnside algorithm finds all irreducible K[G]-modules with a faithful K[G]-module P and looks for the distinct irreducibles among the tensor powers of P. Both irreducible and absolutely irreducible modules may be found. At present the algorithm is restricted to finite fields. In more detail the algorithm starts with a some faithful permutation module over the given field, splits it into irreducibles using the meataxe, and constructing further modules to split as tensor products of those already found. A warning is printed if all irreducible modules are not found.
Let G be a finite group and let K be a field. If G is soluble then K may be either a finite field, the rational field or a cyclotomic field whose order divides the exponent of G. If G is non-soluble, then currently K is restricted to being a finite field or the rational field. These functions construct all of the irreducible or absolutely irreducible G-modules over K. Since V2.16, if K is the rational field, then by default a new algorithm is used. Otherwise, if G is soluble, Schur's algorithm is normally used while if G is non-soluble, the Burnside method is used.Alg: MonStgElt Default:The parameter Alg may be used to override the usual choice of algorithm if desired. Note that Schur's algorithm may only be applied to soluble groups, while, for the time being, Burnside's method requires that the field K is finite.The Schur algorithm is usually very fast and is often able to find the complex representations more quickly than it is possible to compute the character table. The speed of the Burnside algorithm is determined firstly by the maximal degree of the irreducible modules and secondly by the number of irreducible modules. It will start to become quite slow if G has modules of dimension in excess of 1000. In order to prevent the Burnside method from wasting huge amounts of time, the algorithm takes a parameter which controls the degree of the largest module that will be consider for splitting.
DimLim: RngInt Default: 2000The parameter DimLim only affects the Burnside algorithm where it is used to limit the dimension of the modules which will be considered for splitting. If this limit prevents all irreducibles being found, a warning message is output and those irreducibles that have been found will be returned. This possibility allows the user to determine a sample of low degree modules without using excessive time.
> G := SmallGroup(416, 136);
> G;
GrpPC : G of order 416 = 2^5 * 13
PC-Relations:
G.1^2 = Id(G),
G.2^2 = G.5,
G.3^2 = Id(G),
G.4^2 = G.5,
G.5^2 = Id(G),
G.6^13 = Id(G),
G.3^G.1 = G.3 * G.5,
G.3^G.2 = G.3 * G.4,
G.4^G.2 = G.4 * G.5,
G.4^G.3 = G.4 * G.5,
G.6^G.1 = G.6^12
We first compute the K[G]-modules for the finite fields K = GF(p), where p runs through the primes dividing the order of G.
> IrreducibleModules(G, GF(2));
[
GModule of dimension 1 over GF(2),
GModule of dimension 12 over GF(2)
]
> IrreducibleModules(G, GF(13));
[
GModule of dimension 1 over GF(13),
GModule of dimension 1 over GF(13),
GModule of dimension 1 over GF(13),
GModule of dimension 1 over GF(13),
GModule of dimension 1 over GF(13),
GModule of dimension 1 over GF(13),
GModule of dimension 1 over GF(13),
GModule of dimension 1 over GF(13),
GModule of dimension 2 over GF(13),
GModule of dimension 2 over GF(13),
GModule of dimension 4 over GF(13)
]
We now compute the K[G]-modules where K is the rational field.
> time L := IrreducibleModules(G, Rationals());
Time: 16.170
> L;
[
GModule of dimension 1 over Rational Field,
GModule of dimension 1 over Rational Field,
GModule of dimension 1 over Rational Field,
GModule of dimension 1 over Rational Field,
GModule of dimension 1 over Rational Field,
GModule of dimension 1 over Rational Field,
GModule of dimension 1 over Rational Field,
GModule of dimension 1 over Rational Field,
GModule of dimension 2 over Rational Field,
GModule of dimension 2 over Rational Field,
GModule of dimension 8 over Rational Field,
GModule of dimension 12 over Rational Field,
GModule of dimension 12 over Rational Field,
GModule of dimension 12 over Rational Field,
GModule of dimension 12 over Rational Field,
GModule of dimension 24 over Rational Field,
GModule of dimension 96 over Rational Field
]
Finally, we compute the K[G]-modules taking K to be the splitting field over the rationals and verify that the number of irreducibles is equal to the number of conjugacy classes of G.
> Exponent(G); 104 > mods := IrreducibleModules(G, CyclotomicField(104)); > #mods; 53; > #Classes(G); 53 > [ Dimension(N) : N in mods ]; [ 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4 ] > X := CharacterTable(G); > [ Degree(x) : x in X ]; [ 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4 ]
DimLim: RngIntElt Default: 2000
Given a finite group G and a finite field K, this function constructs the absolutely irreducible K[G]-modules over extensions of K. Currently, the group G is restricted to a permutation group. The maximum dimension of a module considered for splitting is controlled by the parameter DimLim, which has default value 2000.
DimLim: RngIntElt Default: 2000
Given a finite group G and a finite field K, this function constructs the irreducible K[G]-modules over K. Currently, the group G is restricted to a permutation group. The maximum dimension of a module considered for splitting is controlled by the parameter DimLim, which has default value 2000.
Given an irreducible module M, return M if it is already absolutely irreducible, else return the absolutely irreducible modules obtained by finding the constituents of M after extending the base field of M to a splitting field.
> load m11; Loading "/home/magma/libs/pergps/m11" M11 - Mathieu group on 11 letters - degree 11 Order 7 920 = 2^4 * 3^2 * 5 * 11; Base 1,2,3,4 Group: G > IrreducibleModules(G, GF(2)); [ GModule of dimension 1 over GF(2), GModule of dimension 10 over GF(2), GModule of dimension 44 over GF(2), GModule of dimension 32 over GF(2) ] > AbsolutelyIrreducibleModules(G, GF(2)); [ GModule of dimension 1 over GF(2), GModule of dimension 10 over GF(2), GModule of dimension 44 over GF(2), GModule of dimension 16 over GF(2^2), GModule of dimension 16 over GF(2^2) ]
This collection of functions allows the user to find all irreducible modules of a finite soluble group. The group is first replaced by an isomorphic group defined by a power-conjugate presentation. The irreducibles are then found using Schur's method of working up the composition series for G defined by the pc-presentation.
Let G be a finite soluble group and let K be one the following types of field: a finite field, the rational field or a cyclotomic field. The order of a cyclotomic field must divide the exponent of G. The function constructs all absolutely irreducible representations of G over appropriate extensions or subfields of the field K. The modules returned are non-isomorphic and consist of all distinct modules, subject to the conditions imposed. In the case when K is a finite field, the Glasby-Howlett algorithm is used to determine the minimal field over which an irreducible module may be realised. If K has characteristic 0, the field over which an irreducible module is given may not be minimal.The irreducible modules are found using Schur's method of climbing the composition series for G defined by the pc-presentation.
Process: BoolElt Default: trueIf the parameter Process is set true then the list is a list of pairs comprising an integer and a representation. This list or any sublist of it is a suitable value for the argument L in the last versions of the function, and in this case only the representations in L will be extended up the series. This allows the user to inspect the representations produced along the way and cull any that are uninteresting.GaloisAction: MonStgElt Default: "Yes"Possible values are "Yes", "No" and "Relative". The default is "Yes" for intermediate levels and "No" for the whole group. The value "Yes" means that it only lists one irreducible from each orbit of the action of the absolute Galois group Gal(K/hbox(primefield(K))). Setting this parameter to "No" turns this reduction off (thus listing all inequivalent representations), while setting it to "Relative" uses the group Gal(K/k).MaxDimension: RngIntElt Default:Restrict the irreducible to those of dimension ≤ MaxDimension. Default is no restriction.ExactDimension: SetEnum Default:If ExactDimension is assigned a set S of positive integers, attention is restricted to irreducible having dimensions lying in the set S. The default is equivalent to taking the set of all positive integers.If both MaxDimension and ExactDimension are assigned values, then irreducible having dimensions that are either bounded by MaxDimension or contained in ExactDimension are produced.
Compute irreducible modules for G over the given field K. All arguments and parameters are as for the absolutely irreducible case.The computation proceeds by first computing the absolutely irreducible representations subject to the given conditions, then rewriting over the field K, with a consequent change of dimension of the representation.
> G := DihedralGroup(GrpPC, 10); > FactoredOrder(G); [ <2, 2>, <5, 1> ]
First some modular representations with characteristic 2.
> r := IrreducibleModulesSchur(G, GF(2));
> r;
[*
GModule of dimension 1 over GF(2),
GModule of dimension 4 over GF(2)
*]
> r := AbsolutelyIrreducibleModulesSchur(G, GF(2));
> r;
[*
GModule of dimension 1 over GF(2),
GModule of dimension 2 over GF(2^2),
GModule of dimension 2 over GF(2^2)
*]
> r := AbsolutelyIrreducibleModulesSchur(G, GF(2) : GaloisAction:="Yes");
> r;
[*
GModule of dimension 1 over GF(2),
GModule of dimension 2 over GF(2^2)
*]
The irreducible representation of dimension 4 is not absolutely irreducible,
as over GF(4) it splits into two Galois-equivalent representations.
Finding irreducible modules over the complex field is straightforward, despite not being able to use the complex field as the field argument. We could instead specify the cyclotomic field having order equal to the exponent of G, but it is preferable to ask for all absolutely irreducible modules over the rationals.
> r := AbsolutelyIrreducibleModulesSchur(G, Rationals()); > r; [* GModule of dimension 1 over Rational Field, GModule of dimension 1 over Rational Field, GModule of dimension 1 over Rational Field, GModule of dimension 1 over Rational Field, GModule of dimension 2 over Cyclotomic Field of order 5 and degree 4, GModule of dimension 2 over Cyclotomic Field of order 5 and degree 4, GModule of dimension 2 over Cyclotomic Field of order 5 and degree 4, GModule of dimension 2 over Cyclotomic Field of order 5 and degree 4 *] > Representation(r[6])(G.2); [zeta_5^3 0] [ 0 zeta_5^2]
Magma V2.16 contains a new algorithm for constructing irreducible rational representations of an arbitrary finite group. This algorithm is now selected by default in the function IrreducibleModules(G, K) when the field K is Q.
Given an irreducible complex character for a group G, the sum of its Galois orbit gives an irreducible rational character for G. The Schur index of an irreducible rational character χ is defined to be the Schur index of an irreducible complex character whose Galois orbit sum is χ.
We call the sequence of all possible irreducible rational characters for G (sorted by degree) the rational character table of G. The irreducible modules returned by IrreducibleModules(G, RationalField()) always match the rational character table.
Given a finite group G, this function returns a sequence L of all irreducible rational K[G]-modules, and also the rational character table of G as a sequence C, which matches L. The character of the i-th module L[i] is always si .C[i], where si is the Schur index of C[i]. Thus the dimension of the irreducible module L[i] is si .Deg(C[i]).MaxDegree: RngIntElt Default: 0Setting the parameter MaxDegree to a positive integer D instructs the algorithm not to spend effort on constructing irreducible modules whose corresponding irreducible rational characters have degree greater than D. Note that irreducible modules whose character degrees greater than D may be returned in any case, if they are easily constructed (often as side effects of operations used to construct smaller-dimensional modules).Characters: [AlgChtrElt] Default:Setting the parameter Characters to a set or sequence S of characters for the group G instructs the algorithm to attempt to construct only the irreducible modules whose characters are in S. Each character in S may either be an irreducible rational character, or a (complex) ordinary character χ, in which case the irreducible rational character corresponding to χ (the orbit sum of χ) is used. As for the parameter MaxDegree, irreducible modules whose characters are not in S may be returned in any case, if they are easily constructed or are needed as intermediate modules to construct the desired modules.CharacterDegrees: [RngIntElt] Default:Setting the parameter CharacterDegrees to a set or sequence I of positive integers instructs the algorithm to attempt to construct only the irreducible modules whose character degrees are in S. This is equivalent to setting the parameter Characters to [c: c in RationalCharacterTable(G) | Degree(c) in I].UseInduction: BoolElt Default: trueBy default, as the algorithm proceeds, it automatically searches for subgroups Hi of G such that irreducible rational Hi-modules may be induced up to G to yield G-modules from which irreducible G-modules may be computed. In general, this method is very effective (and often yields modules for G with small entries) but can be very slow for some groups (particularly when G has many subgroups). Thus setting the parameter UseInduction to {false} will force the algorithm not to use induction.
Given a finite group G, return the rational character table of G as a sequence C of the irreducible rational characters of G (sorted by degree), and also a index sequence I, such that for each i, C[i] is the sum of the Galois orbit of T[I[i]], where T is the ordinary (complex) character table of G.
> G := PSL(3, 3); #G;
5616
> T := CharacterTable(G); [Degree(x): x in T];
[ 1, 12, 13, 16, 16, 16, 16, 26, 26, 26, 27, 39 ]
> C := RationalCharacterTable(G); C;
[
( 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ),
( 12, 4, 3, 0, 0, 1, 0, 0, -1, -1, -1, -1 ),
( 13, -3, 4, 1, 1, 0, -1, -1, 0, 0, 0, 0 ),
( 26, 2, -1, -1, 2, -1, 0, 0, 0, 0, 0, 0 ),
( 27, 3, 0, 0, -1, 0, -1, -1, 1, 1, 1, 1 ),
( 39, -1, 3, 0, -1, -1, 1, 1, 0, 0, 0, 0 ),
( 52, -4, -2, -2, 0, 2, 0, 0, 0, 0, 0, 0 ),
( 64, 0, -8, 4, 0, 0, 0, 0, -1, -1, -1, -1 )
]
> time L := IrreducibleModules(G, RationalField());
Time: 0.760
> L;
[
GModule of dimension 1 over Rational Field,
GModule of dimension 12 over Rational Field,
GModule of dimension 13 over Rational Field,
GModule of dimension 26 over Rational Field,
GModule of dimension 27 over Rational Field,
GModule of dimension 39 over Rational Field,
GModule of dimension 52 over Rational Field,
GModule of dimension 64 over Rational Field
]
> [Character(M): M in L];
[
( 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ),
( 12, 4, 3, 0, 0, 1, 0, 0, -1, -1, -1, -1 ),
( 13, -3, 4, 1, 1, 0, -1, -1, 0, 0, 0, 0 ),
( 26, 2, -1, -1, 2, -1, 0, 0, 0, 0, 0, 0 ),
( 27, 3, 0, 0, -1, 0, -1, -1, 1, 1, 1, 1 ),
( 39, -1, 3, 0, -1, -1, 1, 1, 0, 0, 0, 0 ),
( 52, -4, -2, -2, 0, 2, 0, 0, 0, 0, 0, 0 ),
( 64, 0, -8, 4, 0, 0, 0, 0, -1, -1, -1, -1 )
]
> load m23;
Loading "/home/magma/libs/pergps/m23"
M23 - Mathieu group on 23 letters - degree 23
Order 10 200 960 = 2^7 * 3^2 * 5 * 7 * 11 * 23; Base 1,2,3,4,5,6
Group: G
> T := CharacterTable(G); [Degree(x): x in T];
[ 1, 22, 45, 45, 230, 231, 231, 231, 253, 770, 770,
896, 896, 990, 990, 1035, 2024 ]
> C := RationalCharacterTable(G); C;
[
( 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ),
( 22, 6, 4, 2, 2, 0, 1, 1, 0, 0, 0, -1, -1, -1, -1, -1, -1 ),
( 90, -6, 0, 2, 0, 0, -1, -1, -2, 2, 2, 1, 1, 0, 0, -2, -2 ),
( 230, 22, 5, 2, 0, 1, -1, -1, 0, -1, -1, 1, 1, 0, 0, 0, 0 ),
( 231, 7, 6, -1, 1, -2, 0, 0, -1, 0, 0, 0, 0, 1, 1, 1, 1 ),
( 253, 13, 1, 1, -2, 1, 1, 1, -1, 0, 0, -1, -1, 1, 1, 0, 0 ),
( 462, 14, -6, -2, 2, 2, 0, 0, -2, 0, 0, 0, 0, -1, -1, 2, 2 ),
( 1035, 27, 0, -1, 0, 0, -1, -1, 1, 1, 1, -1, -1, 0, 0, 0, 0 ),
( 1540, -28, 10, -4, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, -1 ),
( 1792, 0, -8, 0, 2, 0, 0, 0, 0, -1, -1, 0, 0, 2, 2, -2, -2 ),
( 1980, -36, 0, 4, 0, 0, -1, -1, 0, 0, 0, -1, -1, 0, 0, 2, 2 ),
( 2024, 8, -1, 0, -1, -1, 1, 1, 0, 0, 0, 1, 1, -1, -1, 0, 0 )
]
> Q := RationalField();
> time L := IrreducibleModules(G, Q: MaxDegree := 253);
Time: 23.400
> L;
[
GModule of dimension 1 over Rational Field,
GModule of dimension 22 over Rational Field,
GModule of dimension 90 over Rational Field,
GModule of dimension 230 over Rational Field,
GModule of dimension 231 over Rational Field,
GModule of dimension 253 over Rational Field,
undef,
undef,
undef,
undef,
GModule of dimension 1980 over Rational Field
]
Note that the module of dimension 1980 is included (it was easily
constructed as the tensor product of modules of dimension 20 and 90).