# SchurRings -- Rings representing irreducible representations of general linear or symmetric groups

## Description

This package makes computations in the representation rings of general linear groups and symmetric groups possible.

Given a positive integer n we may define a polynomial ring in n variables over an arbitrary base ring , whose monomials correspond to the irreducible representations of GL(n), and where multiplication is given by the decomposition of the tensor product of representations. We create such a ring in Macaulay2 using the schurRing function.

 i1 : S = schurRing(QQ,s,4) o1 = S o1 : SchurRing i2 : R = schurRing(r,infinity) o2 = R o2 : SchurRing

Note that in the above, n is allowed to be equal to \infty. However, in this version of the package, many of the features from the case n finite are missing from the infinite case, so the user is advised to use large values for n as a substitute, whenever necessary.

We determine the relative dimension of a SchurRing over its base using the numgens function:

 i3 : numgens S o3 = 4 i4 : numgens R o4 = infinity o4 : InfiniteNumber

For k\leq n, one may interpret the degree k homogeneous component of a SchurRing as the representation ring of the symmetric group S_k. In this ring, the multiplication is different than the one in the representation ring of GL(n). By default, the elements of a SchurRing are interpreted as (virtual) characters of a general linear group. This interpretation is controlled by the option GroupActing, whose default value is "GL". To indicate that the elements of a Schur ring should be interpreted as characters of the symmetric group, one has to set the option GroupActing to "Sn".

 i5 : Q = schurRing(q,4,GroupActing => "Sn") o5 = Q o5 : SchurRing

A monomial in S represents the irreducible representation with a given highest weight. The standard GL(4)-representation is

 i6 : V = s_1 o6 = s 1 o6 : S

We may see the dimension of the corresponding irreducible representation using dim:

 i7 : dim V o7 = 4

Multiplication of elements corresponds to tensor product of representations. The value is computed using a variant of the Littlewood-Richardson rule.

 i8 : V * V o8 = s + s 2 1,1 o8 : S i9 : V^3 o9 = s + 2s + s 3 2,1 1,1,1 o9 : S

The third symmetric power of V is obtained by

 i10 : W = s_{3} o10 = s 3 o10 : S i11 : dim W o11 = 20

and the third exterior power of V can be obtained using

 i12 : U = s_{1,1,1} o12 = s 1,1,1 o12 : S i13 : dim U o13 = 4

Alternatively, one can use the functions symmetricPower and exteriorPower:

 i14 : W = symmetricPower(3,V) o14 = s 3 o14 : S i15 : U = exteriorPower(3,V) o15 = s 1,1,1 o15 : S

We can in fact take symmetric powers and exterior powers of any representation:

 i16 : exteriorPower(2,W) o16 = s + s 5,1 3,3 o16 : S i17 : symmetricPower(2,U) o17 = s 2,2,2 o17 : S

and compute even more general forms of plethysm:

 i18 : plethysm(W+U,W+U) o18 = s + s + 2s + 2s + s + 2s + 2s + 2s + 9 7,2 7,1,1 6,3 6,2,1 6,1,1,1 5,3,1 5,2,2 ----------------------------------------------------------------------- 3s + 2s + 2s + 2s + 2s + 2s 5,2,1,1 4,4,1 4,3,1,1 4,2,2,1 3,3,3 3,2,2,2 o18 : S

Alternatively, we can use the binary operator @ to compute plethysm:

 i19 : s_2 @ s_3 o19 = s + s 6 4,2 o19 : S i20 : (W+U) @ (W+U) o20 = s + s + 2s + 2s + s + 2s + 2s + 2s + 9 7,2 7,1,1 6,3 6,2,1 6,1,1,1 5,3,1 5,2,2 ----------------------------------------------------------------------- 3s + 2s + 2s + 2s + 2s + 2s 5,2,1,1 4,4,1 4,3,1,1 4,2,2,1 3,3,3 3,2,2,2 o20 : S

All the above calculations assume that we're dealing with representations of GL(4). But as symmetric functions of degree three, W and U, can be thought of as characters of the symmetric group S_3. Let us first move'' these symmetric functions into a Schur ring designed to deal with characters of symmetric groups (like the ring Q defined above):

 i21 : W' = toS(W,Q) o21 = q 3 o21 : Q i22 : U' = toS(U,Q) o22 = q 1,1,1 o22 : Q

Now W' corresponds to the trivial representation of S_3, and U' to the sign representation. As such, we can tensor them together using the function internalProduct, or the binary operator *.

 i23 : W' * U' o23 = q 1,1,1 o23 : Q

We can generate the class function corresponding to an S_n-representation, using the function classFunction:

 i24 : cfW = classFunction(W') o24 = ClassFunction{{1, 1, 1} => 1} {2, 1} => 1 {3} => 1 o24 : ClassFunction i25 : cfU = classFunction(U') o25 = ClassFunction{{1, 1, 1} => 1} {2, 1} => -1 {3} => 1 o25 : ClassFunction

We can multiply class functions together, and transform class functions into symmetric functions using the function symmetricFunction:

 i26 : cfWU = cfW * cfU o26 = ClassFunction{{1, 1, 1} => 1} {2, 1} => -1 {3} => 1 o26 : ClassFunction i27 : symmetricFunction(cfWU,Q) o27 = q 1,1,1 o27 : Q

The result of the previous computation is of course the same as that of taking the product of W' and U'.

We can take exterior and symmetric powers of S_n-representations, just as for GL-modules (compare to o16 and o17):

 i28 : exteriorPower(2,W') o28 = 0 o28 : Q i29 : symmetricPower(2,U') o29 = q 3 o29 : Q

We can write any symmetric function in terms of the standard e- (elementary symmetric), h- (complete) and p- (power sum) bases, using the functions toE, toH, toP respectively:

 i30 : toE U o30 = e 3 o30 : QQ[e ..e , p ..p , h ..h ] 1 4 1 4 1 4 i31 : toH U 3 o31 = h - 2h h + h 1 1 2 3 o31 : QQ[e ..e , p ..p , h ..h ] 1 4 1 4 1 4 i32 : toP W 1 3 1 1 o32 = -p + -p p + -p 6 1 2 1 2 3 3 o32 : QQ[e ..e , p ..p , h ..h ] 1 4 1 4 1 4

These expressions live in the Symmetric ring associated to S, which can be obtained using the function symmetricRing:

 i33 : A = symmetricRing S o33 = A o33 : PolynomialRing

Similarly, any Symmetric ring has a Schur ring attached to it, which can be obtained using the function schurRing:

 i34 : schurRing A === S o34 = true

We construct tensor products of Schur rings iteratively by allowing Schur rings over base rings that are also Schur rings:

 i35 : T = schurRing(S,t,3) o35 = T o35 : SchurRing

The Schur ring T can thus be thought of as the representation ring of GL(V)\times GL(V'), where V is as before a vector space of dimension 4, and V' is a vector space of dimension 3. The representation corresponding to V' is

 i36 : V' = t_1 o36 = t 1 o36 : T

The function schurLevel indicates the number of Schur rings that have been tensored together to obtain any given ring:

 i37 : schurLevel T o37 = 2 i38 : schurLevel S o38 = 1 i39 : schurLevel QQ o39 = 0

We can now check Cauchy's formula for decomposing symmetric/exterior powers of a tensor product:

 i40 : symmetricPower(3,V*V') o40 = s t + s t + s t 3 3 2,1 2,1 1,1,1 1,1,1 o40 : T i41 : exteriorPower(3,V*V') o41 = s t + s t + s t 1,1,1 3 2,1 2,1 3 1,1,1 o41 : T

We end with the computation of the GL(n)- and S_n-equivariant resolutions of the residue field of a polynomial ring in n variables. The function that does this calculation, schurResolution, is based on an empirical method, which gives the correct answer in surprisingly many situations.

In the GL(n) situation, we are resolving the residue field which as a representation has character 1_S. The space of linear forms in the polynomial ring considered as a GL-representation has character V = s_1.

 i42 : n = 4 o42 = 4 i43 : M = {1_S} o43 = {s } () o43 : List i44 : schurResolution(V,M,DegreeLimit => n) o44 = {{(0, s )}, {(1, s )}, {(2, s )}, {(3, s )}, {(4, s )}} () 1 1,1 1,1,1 1,1,1,1 o44 : List

Not surprisingly, the syzygy modules are generated by the exterior powers of V.

The residue field as a representation of the symmetric group S_n has character s_n. The space of linear forms in the polynomial ring considered as an S_n-representation coincides with the permutation representation of S_n, thus has character s_n + s_{n-1,1}.

 i45 : rep = q_n + q_(n-1,1) o45 = q + q 4 3,1 o45 : Q i46 : M = {q_n} o46 = {q } 4 o46 : List i47 : sR = schurResolution(rep,M,DegreeLimit => n) o47 = {{(0, q )}, {(1, q + q )}, {(2, q + q )}, {(3, q + 4 4 3,1 3,1 2,1,1 2,1,1 ----------------------------------------------------------------------- q )}, {(4, q )}} 1,1,1,1 1,1,1,1 o47 : List

We can check that the second syzygy module is generated by the second exterior power of the permutation representation.

 i48 : eP2rep = exteriorPower(2,rep) o48 = q + q 3,1 2,1,1 o48 : Q i49 : eP2rep == last sR#2#0 o49 = true

## Version

This documentation describes version 1.1 of SchurRings.

## Source code

The source code from which this documentation is derived is in the file SchurRings.m2.

## For the programmer

The object SchurRings is .