# 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 . 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≤n, one may interpret the degree k homogeneous component of a SchurRing as the representation ring of the symmetric group Sk. 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 @ (missing documentation) 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 S3. 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 S3, and U’ to the sign representation. As such, we can tensor them together using the function internalProduct, or the binary operator * (missing documentation).

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

We can generate the class function corresponding to an Sn-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 Sn-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 , e , e , p , p , p , p , h , h , h , h ] 1 2 3 4 1 2 3 4 1 2 3 4``` ```i31 : toH U 3 o31 = h - 2h h + h 1 1 2 3 o31 : QQ[e , e , e , e , p , p , p , p , h , h , h , h ] 1 2 3 4 1 2 3 4 1 2 3 4``` ```i32 : toP W 1 3 1 1 o32 = -p + -p p + -p 6 1 2 1 2 3 3 o32 : QQ[e , e , e , e , p , p , p , p , h , h , h , h ] 1 2 3 4 1 2 3 4 1 2 3 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)×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 Sn-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 1S. The space of linear forms in the polynomial ring considered as a GL-representation has character V = s1.

 ```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 Sn has character sn. The space of linear forms in the polynomial ring considered as an Sn-representation coincides with the permutation representation of Sn, thus has character sn + sn-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.