schurModule -- Schur module of a partition applied to a free module

Usage:

schurModule(lambda, E)
Inputs:
- lambda, a list, a partition $\lambda = (\lambda_1 \ge \cdots \ge \lambda_r)$
- E, a module, a free module over some ring $R$
Outputs:
- a module, the Schur module $S_\lambda(E)$, a free $R$-module whose rank equals the number of semistandard Young tableaux of shape $\lambda$ with entries in $\{0,\ldots,\mathrm{rank}(E) - 1\}$

Description

The Schur functor $S_\lambda$ is a polynomial functor on free modules, realized here as the quotient of $\wedge^{\lambda'_1}(E) \otimes \cdots \otimes \wedge^{\lambda'_k}(E)$ by the Garnir relations across adjacent columns of the Young diagram. See Fulton, Young Tableaux, Chapter 8.

The partition $\lambda$ is specified as a (non-strictly) decreasing list of positive integers. The rank of the output module matches the Weyl dimension formula $$\dim S_\lambda(R^d) = \#\{\text{SSYT of shape } \lambda \text{ with entries in } 1,\ldots,d\}.$$

Cached data. The returned module M stores in M.cache#"Schur" the 4-tuple (f, finv, AT, ST):

f : the quotient projection $\wedge^{\lambda'_1}(E) \otimes \cdots \otimes \wedge^{\lambda'_k}(E) \twoheadrightarrow M$ (the straightening map, realized in the SSYT basis of M);
finv : a splitting M $\to \wedge^{\lambda'_1}(E) \otimes \cdots$ sending each standard-basis vector to its canonical lift in the ambient tensor product (so f*finv == id_M);
AT : a HashTable keyed by all column-standard Fillings of shape $\lambda$ with values their positions in the ambient tensor product;
ST : the sub-HashTable keyed only by the SSYT (the standard basis of M).

These are consumed by straighten (for a fast-path module evaluation) and by schurModulesMap (for building homomorphisms).

Examples. Symmetric and exterior powers recover the familiar functors; with a partition of shape $(k)$ we get $\mathrm{Sym}^k(E)$ and with shape $(1^k)$ we get $\wedge^k(E)$:

i1 : E = QQ^3;

i2 : schurModule({3}, E)

       10
o2 = QQ

o2 : QQ-module, free

i3 : schurModule({1,1,1}, E)   -- top exterior power: rank 1

       1
o3 = QQ

o3 : QQ-module, free

The first genuinely mixed shape:

i4 : M = schurModule({2,1}, E);

i5 : rank M

o5 = 8

i6 : standardTableaux(3, {2,1})

      +-+-+  +-+-+  +-+-+  +-+-+  +-+-+  +-+-+  +-+-+  +-+-+
o6 = {|0|0|, |0|1|, |0|2|, |0|0|, |0|1|, |0|2|, |1|1|, |1|2|}
      |1| |  |1| |  |1| |  |2| |  |2| |  |2| |  |2| |  |2| |
      +-+-+  +-+-+  +-+-+  +-+-+  +-+-+  +-+-+  +-+-+  +-+-+

o6 : List

i7 : M.cache#"Schur"

                                                             +-+-+       
o7 = {| 1 0 0 0 0 0 0  0 0 |, | 1 0 0 0 0 0 0 0 |, HashTable{|0|0| => 0},
      | 0 1 0 0 0 0 0  0 0 |  | 0 1 0 0 0 0 0 0 |            |1| |       
      | 0 0 1 0 0 0 -1 0 0 |  | 0 0 1 0 0 0 0 0 |            +-+-+       
      | 0 0 0 1 0 0 0  0 0 |  | 0 0 0 1 0 0 0 0 |            +-+-+       
      | 0 0 0 0 1 0 1  0 0 |  | 0 0 0 0 1 0 0 0 |            |0|1| => 1  
      | 0 0 0 0 0 1 0  0 0 |  | 0 0 0 0 0 1 0 0 |            |1| |       
      | 0 0 0 0 0 0 0  1 0 |  | 0 0 0 0 0 0 0 0 |            +-+-+       
      | 0 0 0 0 0 0 0  0 1 |  | 0 0 0 0 0 0 1 0 |            +-+-+       
                              | 0 0 0 0 0 0 0 1 |            |0|2| => 2  
                                                             |1| |       
                                                             +-+-+       
                                                             +-+-+       
                                                             |0|0| => 3  
                                                             |2| |       
                                                             +-+-+       
                                                             +-+-+       
                                                             |0|1| => 4  
                                                             |2| |       
                                                             +-+-+       
                                                             +-+-+       
                                                             |0|2| => 5  
                                                             |2| |       
                                                             +-+-+       
                                                             +-+-+       
                                                             |1|0| => 6  
                                                             |2| |       
                                                             +-+-+       
                                                             +-+-+       
                                                             |1|1| => 7  
                                                             |2| |       
                                                             +-+-+       
                                                             +-+-+
                                                             |1|2| => 8
                                                             |2| |
                                                             +-+-+
     ------------------------------------------------------------------------
               +-+-+
     HashTable{|0|0| => 0}}
               |1| |
               +-+-+
               +-+-+
               |0|1| => 1
               |1| |
               +-+-+
               +-+-+
               |0|2| => 2
               |1| |
               +-+-+
               +-+-+
               |0|0| => 3
               |2| |
               +-+-+
               +-+-+
               |0|1| => 4
               |2| |
               +-+-+
               +-+-+
               |0|2| => 5
               |2| |
               +-+-+
               +-+-+
               |1|1| => 6
               |2| |
               +-+-+
               +-+-+
               |1|2| => 7
               |2| |
               +-+-+

o7 : List

The cached quotient projection / splitting satisfy f * finv == id_M by construction:

i8 : (f, finv, AT, ST) = toSequence M.cache#"Schur";

i9 : f * finv == id_M

o9 = true

Caveat

The partition lambda should be nonempty and weakly decreasing. Entries of lambda should not exceed rank E, or else the output module has rank 0.

Ways to use schurModule:

schurModule(List,Module)

For the programmer

The object schurModule is a method function.

The source of this document is in /build/reproducible-path/macaulay2-1.26.05+ds/M2/Macaulay2/packages/SchurFunctors.m2:1949:0.

schurModule -- Schur module of a partition applied to a free module

Description

Caveat

See also

Ways to use schurModule:

For the programmer