This is SchurFunctors.info, produced by Macaulay2, version 1.25.05

SchurFunctors -- for computing Schur functors
*********************************************

Description
===========

This package provides methods for computing Schur functors.

Authors
=======

  * Michael E. Stillman (see http://www.math.cornell.edu/~mike )
    <mike@math.cornell.edu>
  * Anton Leykin
  * Mauricio Velasco

Version
=======

This documentation describes version 0.1 of SchurFunctors.

Citation
========

If you have used this package in your research, please cite it as follows:

+-----------------------------------------------------------------------------+
|@misc{SchurFunctorsSource,                                                   |
|  title = {{SchurFunctors: Schur modules and maps between them. Version~0.1}}|
|  author = {Michael E. Stillman and Anton Leykin and Mauricio Velasco},      |
|  howpublished = {A \emph{Macaulay2} package available at                    |
|    \url{https://github.com/Macaulay2/M2/tree/master/M2/Macaulay2/packages}} |
|}                                                                            |
|-----------------------------------------------------------------------------|
|,                                                                            |
+-----------------------------------------------------------------------------+

Exports
=======

  * Types
      * Filling (missing documentation)
  * Functions and commands
      * augmentFilling (missing documentation)
      * character -- Determines the character of a
        composition of Schur functors applied to the representation of GL(V) on
        V
      * characterRep (missing documentation)
      * decomposeRep (missing documentation)
      * printSchurModuleElement (missing documentation)
      * schur -- creates a map between Schur modules
      * schurModule -- creates Schur module from a
        partition and free module
      * schurModulesMap -- creates a map between two
        Schur modules via the specified function.
      * splitCharacter -- Decomposes a symmetric
        polynomial as a sum of Schur functions
      * straighten -- Given a tableau of shape lambda
        express it as a linear combination of SST in the given Schur module
  * Methods
      * augmentFilling(Filling,ZZ,ZZ) (missing documentation)
      * "character(List,ZZ)" -- see character, -- Determines
        the character of a composition of Schur functors applied to the
        representation of GL(V) on V
      * characterRep(Matrix) (missing documentation)
      * conjugate(Filling) (missing documentation)
      * decomposeRep(Matrix) (missing documentation)
      * exchange(Filling,ZZ,ZZ,List) (missing documentation)
      * Filling ? Filling (missing documentation)
      * Filling _ List (missing documentation)
      * net(Filling) (missing documentation)
      * printSchurModuleElement(Vector,Module) (missing documentation)
      * "schur(List,Matrix)" -- see schur, -- creates a map
        between Schur modules
      * "schurModule(List,Module)" -- see schurModule, --
        creates Schur module from a partition and free module
      * "schurModulesMap(Module,Module,Function)" -- see schurModulesMap,
        -- creates a map between two Schur modules via the
        specified function.
      * "splitCharacter(RingElement)" -- see splitCharacter,
        -- Decomposes a symmetric polynomial as a sum of Schur
        functions
      * "straighten(Filling,Module)" -- see straighten, --
        Given a tableau of shape lambda express it as a linear combination of
        SST in the given Schur module

For the programmer
==================

The object SchurFunctors, is a package (Macaulay2Doc),
defined in SchurFunctors.m2, with auxiliary files in
SchurFunctors/.

-------------------------------------------------------------------------------

The source of this document is in SchurFunctors.m2:394:0.

augmentFilling
**************

Ways to use augmentFilling:
===========================

  * augmentFilling(Filling,ZZ,ZZ) (missing documentation)

For the programmer
==================

The object augmentFilling (missing documentation) is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in
/home/runner/work/M2/M2/M2/BUILD/build/Macaulay2/packages/currentString:2:0.

character -- Determines the character of a composition of Schur functors applied to the representation of GL(V) on V
********************************************************************************************************************

  * Usage:
        character(L,d)
  * Inputs:
      * L, a list (Macaulay2Doc), A nested list whose entries are
        partitions
      * d, an integer (Macaulay2Doc), An integer
  * Outputs:
      * p, a ring element (Macaulay2Doc), A symmetric
        polynomial

Description
===========

Given a list L of partitions {L1,...,Ln} computes the character of the
composition of Schur functors SL1(SL2(...(SLn(V)))) applied to the canonical
representation of GL(V) where dim(V)=d

+-----------------------------------------------------------------------------+
|i1 : character({{1,1,1},{2}},4)--The GL(4) action on the Grassmannian of 3-di|
|                                                                             |
|      3 3    4         3 2       2 3        4       3   2     2 2 2       3 2|
|o1 = x x  + x x x  + 2x x x  + 2x x x  + x x x  + 2x x x  + 2x x x  + 2x x x |
|      0 1    0 1 2     0 1 2     0 1 2    0 1 2     0 1 2     0 1 2     0 1 2|
|     ------------------------------------------------------------------------|
|        3 3     2   3       2 3    3 3        4    4         3 2       2 3   |
|     + x x  + 2x x x  + 2x x x  + x x  + x x x  + x x x  + 2x x x  + 2x x x  |
|        0 2     0 1 2     0 1 2    1 2    0 1 2    0 1 3     0 1 3     0 1 3 |
|     ------------------------------------------------------------------------|
|          4      4         3           2 2           3        4         3 2  |
|     + x x x  + x x x  + 4x x x x  + 5x x x x  + 4x x x x  + x x x  + 2x x x |
|        0 1 3    0 2 3     0 1 2 3     0 1 2 3     0 1 2 3    1 2 3     0 2 3|
|     ------------------------------------------------------------------------|
|         2   2         2 2       3 2       2 3           3       2 3         |
|     + 5x x x x  + 5x x x x  + 2x x x  + 2x x x  + 4x x x x  + 2x x x  +     |
|         0 1 2 3     0 1 2 3     1 2 3     0 2 3     0 1 2 3     1 2 3       |
|     ------------------------------------------------------------------------|
|        4        4       3   2     2 2 2       3 2     3   2     2     2     |
|     x x x  + x x x  + 2x x x  + 2x x x  + 2x x x  + 2x x x  + 5x x x x  +   |
|      0 2 3    1 2 3     0 1 3     0 1 3     0 1 3     0 2 3     0 1 2 3     |
|     ------------------------------------------------------------------------|
|         2   2     3   2     2 2 2         2 2     2 2 2       3 2       3 2 |
|     5x x x x  + 2x x x  + 2x x x  + 5x x x x  + 2x x x  + 2x x x  + 2x x x  |
|       0 1 2 3     1 2 3     0 2 3     0 1 2 3     1 2 3     0 2 3     1 2 3 |
|     ------------------------------------------------------------------------|
|        3 3     2   3       2 3    3 3     2   3           3     2   3       |
|     + x x  + 2x x x  + 2x x x  + x x  + 2x x x  + 4x x x x  + 2x x x  +     |
|        0 3     0 1 3     0 1 3    1 3     0 2 3     0 1 2 3     1 2 3       |
|     ------------------------------------------------------------------------|
|         2 3       2 3    3 3        4        4        4                     |
|     2x x x  + 2x x x  + x x  + x x x  + x x x  + x x x                      |
|       0 2 3     1 2 3    2 3    0 1 3    0 2 3    1 2 3                     |
|                                                                             |
|o1 : QQ[x ..x ]                                                              |
|         0   3                                                               |
|-----------------------------------------------------------------------------|
|mensional subspaces of quadrics in four variables                            |
+-----------------------------------------------------------------------------+

See also
========

  * schur -- creates a map between Schur modules

Ways to use character:
======================

  * "character(List,ZZ)"

For the programmer
==================

The object character, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in SchurFunctors.m2:400:0.

characterRep
************

Ways to use characterRep:
=========================

  * characterRep(Matrix) (missing documentation)

For the programmer
==================

The object characterRep (missing documentation) is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in
/home/runner/work/M2/M2/M2/BUILD/build/Macaulay2/packages/currentString:2:0.

decomposeRep
************

Ways to use decomposeRep:
=========================

  * decomposeRep(Matrix) (missing documentation)

For the programmer
==================

The object decomposeRep (missing documentation) is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in
/home/runner/work/M2/M2/M2/BUILD/build/Macaulay2/packages/currentString:2:0.

Filling
*******

Methods that use an object of class Filling:
============================================

  * augmentFilling(Filling,ZZ,ZZ) (missing documentation)
  * conjugate(Filling) (missing documentation)
  * exchange(Filling,ZZ,ZZ,List) (missing documentation)
  * Filling ? Filling (missing documentation)
  * Filling _ List (missing documentation)
  * net(Filling) (missing documentation)
  * "straighten(Filling,Module)" -- see straighten, -- Given
    a tableau of shape lambda express it as a linear combination of SST in the
    given Schur module

For the programmer
==================

The object Filling (missing documentation) is a type (Macaulay2Doc),
with ancestor classes BasicList (Macaulay2Doc),
< Thing (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in
/home/runner/work/M2/M2/M2/BUILD/build/Macaulay2/packages/currentString:2:0.

printSchurModuleElement
***********************

Ways to use printSchurModuleElement:
====================================

  * printSchurModuleElement(Vector,Module) (missing documentation)

For the programmer
==================

The object printSchurModuleElement (missing documentation) is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in
/home/runner/work/M2/M2/M2/BUILD/build/Macaulay2/packages/currentString:2:0.

schur -- creates a map between Schur modules
********************************************

  * Usage:
        schur(lambda,f)
  * Inputs:
      * lambda, a list (Macaulay2Doc), a list of numbers
        representing a partition
      * f, a module (Macaulay2Doc), a map between two free
        modules
  * Outputs:
      * F, a matrix (Macaulay2Doc), the result of applying the
        Schur functor associated to lambda to f

Description
===========

Applies the Schur functor associated to lambda to the map f between free
modules. The modules source F and target F are Schur modules containing certain
data in cache (see schurModule).

+-----------------------------------------------+
|i1 : R=QQ[x_1,x_2,x_3]                         |
|                                               |
|o1 = R                                         |
|                                               |
|o1 : PolynomialRing                            |
+-----------------------------------------------+
|i2 : F=map(R^1,R^3,vars R)                     |
|                                               |
|o2 = | x_1 x_2 x_3 |                           |
|                                               |
|             1      3                          |
|o2 : Matrix R  <-- R                           |
+-----------------------------------------------+
|i3 : L=schur({2},F) -- 2nd veronese embedding  |
|                                               |
|o3 = | x_1^2 x_1x_2 x_1x_3 x_2^2 x_2x_3 x_3^2 ||
|                                               |
|             1      6                          |
|o3 : Matrix R  <-- R                           |
+-----------------------------------------------+
|i4 : F=matrix{{1_QQ,2,4},{3,9,27},{4,16,64}}   |
|                                               |
|o4 = | 1 2  4  |                               |
|     | 3 9  27 |                               |
|     | 4 16 64 |                               |
|                                               |
|              3       3                        |
|o4 : Matrix QQ  <-- QQ                         |
+-----------------------------------------------+
|i5 : schur({1,1},F)                            |
|                                               |
|o5 = | 3  15 18  |                             |
|     | 8  48 64  |                             |
|     | 12 84 144 |                             |
|                                               |
|              3       3                        |
|o5 : Matrix QQ  <-- QQ                         |
+-----------------------------------------------+
|i6 : minors(2,F)                               |
|                                               |
|o6 = ideal (3, 8, 12, 15, 48, 84, 18, 64, 144) |
|                                               |
|o6 : Ideal of QQ                               |
+-----------------------------------------------+
|i7 : schur({1,1,1},F) == det F                 |
|                                               |
|o7 = true                                      |
+-----------------------------------------------+

Caveat
======

The partition lambda should be a valid nonempty partition.

See also
========

  * schurModule -- creates Schur module from a partition
    and free module

Ways to use schur:
==================

  * "schur(List,Matrix)"

For the programmer
==================

The object schur, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in SchurFunctors.m2:397:0.

schurModule -- creates Schur module from a partition and free module
********************************************************************

  * Usage:
        schurModule(lambda,E)
  * Inputs:
      * lambda, a list (Macaulay2Doc), a list of numbers
        representing a partition; e.g. {3,1} stands for 2 rows of length 3 and
        1.
      * E, a module (Macaulay2Doc), a free module
  * Outputs:
      * M, a module (Macaulay2Doc), The result of application of
        the Schur functor associated to lambda to E.

Description
===========

Applies the Schur functor associated to lambda to the free module E. For a
detailed definition of the Schur module see p.106 of Fulton "Young Tableaux".

The resulting M comes with cached data M.cache.Schur = {f, finv, AT, ST} where

{"f is a map from exterior_mu E to M;", "finv is a map from M to exterior_mu
E;", "AT is a hash table of all tableaux, whose entries increase in every
column;", "ST is a hash table of all standard tableaux (tableaux in AT, whose
entries nondecrease in every row)." }

Tableaux are represented with objects of class Filling, which is a double list
whose entries are lists giving the fillings of the corresponding columns.

+-----------------------------------------------------------------------------+
|i1 : M=QQ^3;                                                                 |
+-----------------------------------------------------------------------------+
|i2 : scan(4, i-> << i+1 << "-th symmetric power of M = " <<                  |
|                              3                                              |
|1-th symmetric power of M = QQ                                               |
|                              6                                              |
|2-th symmetric power of M = QQ                                               |
|                              10                                             |
|3-th symmetric power of M = QQ                                               |
|                              15                                             |
|4-th symmetric power of M = QQ                                               |
|-----------------------------------------------------------------------------|
|schurModule({i+1},M) << endl)                                                |
+-----------------------------------------------------------------------------+
|i3 : S = schurModule({3,2,1}, M);                                            |
+-----------------------------------------------------------------------------+
|i4 : v = sum(numgens S, i-> (i+1)*S_i) -- an element of S represented by a   |
|                                                                             |
|o4 = | 1 |                                                                   |
|     | 2 |                                                                   |
|     | 3 |                                                                   |
|     | 4 |                                                                   |
|     | 5 |                                                                   |
|     | 6 |                                                                   |
|     | 7 |                                                                   |
|     | 8 |                                                                   |
|                                                                             |
|       8                                                                     |
|o4 : QQ                                                                      |
|-----------------------------------------------------------------------------|
|vector                                                                       |
+-----------------------------------------------------------------------------+
|i5 : printSchurModuleElement(v, S);                                          |
|  +-+-+-+   +-+-+-+   +-+-+-+   +-+-+-+   +-+-+-+   +-+-+-+   +-+-+-+        |
|1*|0|0|0| 2*|0|0|1| 3*|0|0|2| 4*|0|0|0| 5*|0|0|1| 6*|0|0|2| 7*|0|1|1|        |
|  |1|1| |   |1|1| |   |1|1| |   |1|2| |   |1|2| |   |1|2| |   |1|2| |        |
|  |2| | |   |2| | |   |2| | |   |2| | |   |2| | |   |2| | |   |2| | |        |
|  +-+-+-+   +-+-+-+   +-+-+-+   +-+-+-+   +-+-+-+   +-+-+-+   +-+-+-+        |
|-----------------------------------------------------------------------------|
|  +-+-+-+                                                                    |
|8*|0|1|2|                                                                    |
|  |1|2| |                                                                    |
|  |2| | |                                                                    |
|  +-+-+-+                                                                    |
+-----------------------------------------------------------------------------+

Caveat
======

The partition lambda should be a valid nonempty partition.

See also
========

  * schur -- creates a map between Schur modules

Ways to use schurModule:
========================

  * "schurModule(List,Module)"

For the programmer
==================

The object schurModule, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in SchurFunctors.m2:396:0.

schurModulesMap -- creates a map between two Schur modules via the specified function.
**************************************************************************************

  * Usage:
        schurModulesMap(N,M,F)
  * Inputs:
      * N, a module (Macaulay2Doc), Schur module
      * M, a module (Macaulay2Doc), Schur module
      * F, a function (Macaulay2Doc), The function should
        specify, for every SST in the basis of M, a linear combination of
        tableaux of the shape specified by N. The output of F should be a
        sequence of pairs (c,T) where c is a coefficient in ring(N) and T a
        tableau (not necessarily semistandard).
  * Outputs:
      * G, a matrix (Macaulay2Doc), A map between M and N.

Description
===========

Constructs the map between M and N specified by the function F.

+-----------------------------------------------------------------------------+
|i1 : n = 4;      --j-th differential of the Koszul Complex on the variables  |
|-----------------------------------------------------------------------------|
|of R                                                                         |
+-----------------------------------------------------------------------------+
|i2 : j = 2;                                                                  |
+-----------------------------------------------------------------------------+
|i3 : mu1=apply(j,j->1)                                                       |
|                                                                             |
|o3 = {1, 1}                                                                  |
|                                                                             |
|o3 : List                                                                    |
+-----------------------------------------------------------------------------+
|i4 : mu2=apply(j+1,j->1)                                                     |
|                                                                             |
|o4 = {1, 1, 1}                                                               |
|                                                                             |
|o4 : List                                                                    |
+-----------------------------------------------------------------------------+
|i5 : R = QQ[x_1..x_n];                                                       |
+-----------------------------------------------------------------------------+
|i6 : M=schurModule(mu1,R^n);                                                 |
+-----------------------------------------------------------------------------+
|i7 : N=schurModule(mu2,R^n);                                                 |
+-----------------------------------------------------------------------------+
|i8 : F = T -> apply(numgens R, j -> (R_j, augmentFilling(T,0,j)))            |
|                                                                             |
|o8 = F                                                                       |
|                                                                             |
|o8 : FunctionClosure                                                         |
+-----------------------------------------------------------------------------+
|i9 : schurModulesMap(N,M,F)                                                  |
|                                                                             |
|o9 = | x_3 -x_2 x_1 0    0    0   |                                          |
|     | x_4 0    0   -x_2 x_1  0   |                                          |
|     | 0   x_4  0   -x_3 0    x_1 |                                          |
|     | 0   0    x_4 0    -x_3 x_2 |                                          |
|                                                                             |
|             4      6                                                        |
|o9 : Matrix R  <-- R                                                         |
+-----------------------------------------------------------------------------+

Caveat
======

The function F should output lists of pairs where the second component is a
filling of the partition corresponding to N.

See also
========

  * schur -- creates a map between Schur modules

Ways to use schurModulesMap:
============================

  * "schurModulesMap(Module,Module,Function)"

For the programmer
==================

The object schurModulesMap, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in SchurFunctors.m2:399:0.

splitCharacter -- Decomposes a symmetric polynomial as a sum of Schur functions
*******************************************************************************

  * Usage:
        splitCharacter(c)
  * Inputs:
      * c, a ring element (Macaulay2Doc), A Symmetric
        polynomial
  * Outputs:
      * p, a ring element (Macaulay2Doc),

Description
===========

Expresses a symmetric polynomial c as a linear combination of Schur functions

+-----------------------------------------------------------------------------+
|i1 : c=character({{1,1,1},{2}},4)                                            |
|                                                                             |
|      3 3    4         3 2       2 3        4       3   2     2 2 2       3 2|
|o1 = x x  + x x x  + 2x x x  + 2x x x  + x x x  + 2x x x  + 2x x x  + 2x x x |
|      0 1    0 1 2     0 1 2     0 1 2    0 1 2     0 1 2     0 1 2     0 1 2|
|     ------------------------------------------------------------------------|
|        3 3     2   3       2 3    3 3        4    4         3 2       2 3   |
|     + x x  + 2x x x  + 2x x x  + x x  + x x x  + x x x  + 2x x x  + 2x x x  |
|        0 2     0 1 2     0 1 2    1 2    0 1 2    0 1 3     0 1 3     0 1 3 |
|     ------------------------------------------------------------------------|
|          4      4         3           2 2           3        4         3 2  |
|     + x x x  + x x x  + 4x x x x  + 5x x x x  + 4x x x x  + x x x  + 2x x x |
|        0 1 3    0 2 3     0 1 2 3     0 1 2 3     0 1 2 3    1 2 3     0 2 3|
|     ------------------------------------------------------------------------|
|         2   2         2 2       3 2       2 3           3       2 3         |
|     + 5x x x x  + 5x x x x  + 2x x x  + 2x x x  + 4x x x x  + 2x x x  +     |
|         0 1 2 3     0 1 2 3     1 2 3     0 2 3     0 1 2 3     1 2 3       |
|     ------------------------------------------------------------------------|
|        4        4       3   2     2 2 2       3 2     3   2     2     2     |
|     x x x  + x x x  + 2x x x  + 2x x x  + 2x x x  + 2x x x  + 5x x x x  +   |
|      0 2 3    1 2 3     0 1 3     0 1 3     0 1 3     0 2 3     0 1 2 3     |
|     ------------------------------------------------------------------------|
|         2   2     3   2     2 2 2         2 2     2 2 2       3 2       3 2 |
|     5x x x x  + 2x x x  + 2x x x  + 5x x x x  + 2x x x  + 2x x x  + 2x x x  |
|       0 1 2 3     1 2 3     0 2 3     0 1 2 3     1 2 3     0 2 3     1 2 3 |
|     ------------------------------------------------------------------------|
|        3 3     2   3       2 3    3 3     2   3           3     2   3       |
|     + x x  + 2x x x  + 2x x x  + x x  + 2x x x  + 4x x x x  + 2x x x  +     |
|        0 3     0 1 3     0 1 3    1 3     0 2 3     0 1 2 3     1 2 3       |
|     ------------------------------------------------------------------------|
|         2 3       2 3    3 3        4        4        4                     |
|     2x x x  + 2x x x  + x x  + x x x  + x x x  + x x x                      |
|       0 2 3     1 2 3    2 3    0 1 3    0 2 3    1 2 3                     |
|                                                                             |
|o1 : QQ[x ..x ]                                                              |
|         0   3                                                               |
+-----------------------------------------------------------------------------+
|i2 : splitCharacter(c)                                                       |
|                                                                             |
|o2 = s      + s                                                              |
|      4,1,1    3,3                                                           |
|                                                                             |
|o2 : schurRing (QQ, s, 4)                                                    |
+-----------------------------------------------------------------------------+

Ways to use splitCharacter:
===========================

  * "splitCharacter(RingElement)"

For the programmer
==================

The object splitCharacter, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in SchurFunctors.m2:401:0.

straighten -- Given a tableau of shape lambda express it as a linear combination of SST in the given Schur module
*****************************************************************************************************************

  * Usage:
        straighten(T,M)
  * Inputs:
      * T, an instance of the type Filling (missing documentation), Any filling
        with shape mu and entries between 0 and rank(E)-1.
      * M, a module (Macaulay2Doc), A Schur module of the form
        S_{mu}(E) for some partition mu.
  * Outputs:
      * T2,

Description
===========

A linear combination of semistandard tableaux representing  T in M.

+-----------+
|i1 : bla   |
|           |
|o1 = bla   |
|           |
|o1 : Symbol|
+-----------+

Caveat
======

The function F should output lists of pairs where the second component is a
filling of the partition corresponding to N.

See also
========

  * schur -- creates a map between Schur modules

Ways to use straighten:
=======================

  * "straighten(Filling,Module)"

For the programmer
==================

The object straighten, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in SchurFunctors.m2:398:0.