This is Tableaux.info, produced by Macaulay2, version 1.26.06

Tableaux -- a package for computing with Young tableaux
*******************************************************

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

This package provides the classes YoungTableau,
MutableYoungTableau, and Tabloid. These
classes can be used to construct (skew) tableaux, and entries in the boxes may
be any class. See the constructor's page youngTableau, for
some basics of this class.

+--------------------------------------------------+
|i1 : lam = new Partition from {4,3,2}             |
|                                                  |
|o1 = Partition{4, 3, 2}                           |
|                                                  |
|o1 : Partition                                    |
+--------------------------------------------------+
|i2 : mu = new Partition from {3,1}                |
|                                                  |
|o2 = Partition{3, 1}                              |
|                                                  |
|o2 : Partition                                    |
+--------------------------------------------------+
|i3 : T = youngTableau(lam, mu, {1,2,3,3,9})       |
|                                                  |
|                 ┌───┐                            |
|o3 =             │ 1 │                            |
|         ┌───┬───┼───┘                            |
|         │ 2 │ 3 │                                |
|     ┌───┼───┼───┘                                |
|     │ 3 │ 9 │                                    |
|     └───┴───┘                                    |
|                                                  |
|o3 : YoungTableau                                 |
+--------------------------------------------------+
|i4 : allStandardTableaux(new Partition from {2,1})|
|                                                  |
|o4 = -*a bagged sequence of length 2*-            |
|                                                  |
|o4 : Bag                                          |
+--------------------------------------------------+

See also
========

  * youngTableau -- constructor for type YoungTableau
  * mutableYoungTableau -- constructor for type
    MutableYoungTableau
  * tabloid -- constructor for type Tabloid
  * allStandardTableaux -- list all standard Young
    tableaux of a given shape
  * allSemistandardTableaux -- list all
    semistandard Young tableaux of a given shape

Author
======

  * John Graf (see https://j-graf.github.io/ ) <jrgraf@udel.edu>

Version
=======

This documentation describes version 0.6 of Tableaux, released January 13,
2026.

Citation
========

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

+----------------------------------------------------------------------------+
|@misc{TableauxSource,                                                       |
|  title = {{Tableaux: constructing Young tableaux. Version~0.6}},           |
|  author = {John Graf},                                                     |
|  howpublished = {A \emph{Macaulay2} package available at                   |
|    \url{https://github.com/Macaulay2/M2/tree/stable/M2/Macaulay2/packages}}|
|}                                                                           |
|                                                                            |
+----------------------------------------------------------------------------+

Exports
=======

  * Types
      * MutableYoungTableau -- a type of HashTable
        representing a Young tableau, with mutable entries
      * Tabloid -- a type of HashTable representing a Young
        tabloid
      * YoungTableau -- a type of HashTable representing a
        Young tableau
  * Functions and commands
      * allSemistandardTableaux -- list all
        semistandard Young tableaux of a given shape
      * allStandardTableaux -- list all standard
        Young tableaux of a given shape
      * allSubPartitions -- list all partitions whose
        Young diagrams are contained in another
      * allTabloids -- list all tabloids of a given shape
      * applyEntries -- apply a function to all entries in
        the tableau
      * applyPositions -- apply a function to all
        positions of boxes in a tableau
      * boxContent -- compute the content of a box of a
        tableau
      * columnEntries -- get the entries in a column
      * columnRange -- the range of column indices of a
        tableau
      * columnStabilizer -- the column stabilizer of a
        tableau
      * drawInnerShape -- option to draw the inner shape
        of a tableau
      * ferrersDiagram -- a net of the Ferrers diagram
      * hookLength -- compute the hook length of a box of a
        tableau
      * horizontalNet -- multiple nets concatenated
        horizontally
      * innerShape -- the inner shape of a (skew) Young
        tableau
      * isCorner -- checks if a box is a corner of a tableau
      * isNonnegative -- check if shapes are nonnegative
      * isSemistandard -- checks if a Young tableau is
        semistandard
      * isSkew -- checks if a Young tableau is skew
      * isStandard -- checks if a Young tableau is standard
      * isWeaklyDecreasing -- check if shapes are
        weakly decreasing
      * mutableYoungTableau -- constructor for type
        MutableYoungTableau
      * numSemistandardTableaux -- compute the
        number of semistandard Young tableaux of a given shape
      * numStandardTableaux -- compute the number
        of standard Young tableaux of a given shape
      * numTabloids -- compute the number of tabloids of a
        given shape
      * outerShape -- the outer shape of a (skew) Young
        tableau
      * positionList -- get the positions of all the boxes
        in a tableau
      * randomSemistandardTableau -- get a
        random semistandard Young Tableau
      * randomStandardTableau -- get a random
        standard Young Tableau
      * randomTabloid -- get a random tabloid
      * readingWord -- get the reading word of a tableau
      * representative -- get a canonical representative
        of a tabloid
      * rowEntries -- get the entries in a row
      * rowRange -- the range of row indices of a tableau
      * rowStabilizer -- the row stabilizer of a tableau
      * shape -- the shape of a Young tableau
      * shift -- shift a tableau
      * skewShape -- the shape of a skew tableau
      * standardize -- standardize the lengths of a pair of
        partitions
      * tabloid -- constructor for type Tabloid
      * toIndex -- get the index of a box, given its position
      * toPartitionChain -- decompose a tableau into a
        chain of partitions
      * toPosition -- get the position of a box, given its
        index
      * unshift -- unshift a tableau
      * verticalConcatenate -- vertical
        concatenation of a list of tableaux
      * verticalNet -- multiple nets concatenated
        vertically
      * youngDiagram -- a net of the Young diagram
      * youngTableau -- constructor for type YoungTableau
  * Methods
      * "allSemistandardTableaux(List)" -- see allSemistandardTableaux,
        -- list all semistandard Young tableaux of a
        given shape
      * "allSemistandardTableaux(Partition)" -- see
        allSemistandardTableaux, -- list all
        semistandard Young tableaux of a given shape
      * "allSemistandardTableaux(Partition,Partition)" -- see
        allSemistandardTableaux, -- list all
        semistandard Young tableaux of a given shape
      * "allSemistandardTableaux(Partition,Partition,ZZ)" -- see
        allSemistandardTableaux, -- list all
        semistandard Young tableaux of a given shape
      * "allSemistandardTableaux(Partition,ZZ)" -- see
        allSemistandardTableaux, -- list all
        semistandard Young tableaux of a given shape
      * "allStandardTableaux(Partition)" -- see allStandardTableaux,
        -- list all standard Young tableaux of a given
        shape
      * "allSubPartitions(Partition)" -- see allSubPartitions,
        -- list all partitions whose Young diagrams are
        contained in another
      * "allSubPartitions(Partition,Partition)" -- see allSubPartitions,
        -- list all partitions whose Young diagrams are
        contained in another
      * "allTabloids(Partition)" -- see allTabloids, -- list
        all tabloids of a given shape
      * "allTabloids(Partition,Partition)" -- see allTabloids,
        -- list all tabloids of a given shape
      * "applyEntries(YoungTableau,Function)" -- see applyEntries,
        -- apply a function to all entries in the tableau
      * "applyPositions(YoungTableau,Function)" -- see applyPositions,
        -- apply a function to all positions of boxes in a
        tableau
      * "boxContent(ZZ,ZZ)" -- see boxContent, -- compute the
        content of a box of a tableau
      * "columnEntries(YoungTableau,ZZ)" -- see columnEntries,
        -- get the entries in a column
      * "columnEntries(ZZ,YoungTableau)" -- see columnEntries,
        -- get the entries in a column
      * "columnRange(YoungTableau)" -- see columnRange, --
        the range of column indices of a tableau
      * "columnStabilizer(YoungTableau)" -- see columnStabilizer,
        -- the column stabilizer of a tableau
      * components(YoungTableau) -- get
        the connected components of a tableau
      * conjugate(YoungTableau), --
        conjugate a tableau
      * "drawInnerShape(Boolean)" -- see drawInnerShape,
        -- option to draw the inner shape of a tableau
      * entries(YoungTableau) -- the filling
        of a tableau
      * "ferrersDiagram(Partition)" -- see ferrersDiagram,
        -- a net of the Ferrers diagram
      * "ferrersDiagram(Partition,Partition)" -- see ferrersDiagram,
        -- a net of the Ferrers diagram
      * "ferrersDiagram(YoungTableau)" -- see ferrersDiagram,
        -- a net of the Ferrers diagram
      * "hookLength(Partition)" -- see hookLength, -- compute
        the hook length of a box of a tableau
      * "hookLength(Sequence,YoungTableau)" -- see hookLength,
        -- compute the hook length of a box of a tableau
      * "innerShape(YoungTableau)" -- see innerShape, -- the
        inner shape of a (skew) Young tableau
      * "isCorner(Sequence,Partition)" -- see isCorner, --
        checks if a box is a corner of a tableau
      * "isCorner(Sequence,YoungTableau)" -- see isCorner, --
        checks if a box is a corner of a tableau
      * "isNonnegative(Partition)" -- see isNonnegative,
        -- check if shapes are nonnegative
      * "isNonnegative(Partition,Partition)" -- see isNonnegative,
        -- check if shapes are nonnegative
      * "isNonnegative(YoungTableau)" -- see isNonnegative,
        -- check if shapes are nonnegative
      * "isSemistandard(YoungTableau)" -- see isSemistandard,
        -- checks if a Young tableau is semistandard
      * "isSkew(YoungTableau)" -- see isSkew, -- checks if a
        Young tableau is skew
      * "isStandard(YoungTableau)" -- see isStandard, --
        checks if a Young tableau is standard
      * "isWeaklyDecreasing(Partition)" -- see isWeaklyDecreasing,
        -- check if shapes are weakly decreasing
      * "isWeaklyDecreasing(Partition,Partition)" -- see
        isWeaklyDecreasing, -- check if shapes are weakly
        decreasing
      * "isWeaklyDecreasing(YoungTableau)" -- see isWeaklyDecreasing,
        -- check if shapes are weakly decreasing
      * "mutableYoungTableau(Partition)" -- see mutableYoungTableau,
        -- constructor for type MutableYoungTableau
      * "mutableYoungTableau(Partition,List)" -- see mutableYoungTableau,
        -- constructor for type MutableYoungTableau
      * "mutableYoungTableau(Partition,Partition)" -- see
        mutableYoungTableau, -- constructor for type
        MutableYoungTableau
      * "mutableYoungTableau(Partition,Partition,List)" -- see
        mutableYoungTableau, -- constructor for type
        MutableYoungTableau
      * "mutableYoungTableau(Sequence,List)" -- see mutableYoungTableau,
        -- constructor for type MutableYoungTableau
      * MutableYoungTableau _ Sequence = Thing
        -- change an entry of a mutable Young tableau
      * numColumns(YoungTableau) -- the
        number of columns in a tableau
      * numRows(YoungTableau) -- the number
        of rows in a tableau
      * "numSemistandardTableaux(Partition)" -- see
        numSemistandardTableaux, -- compute the number
        of semistandard Young tableaux of a given shape
      * "numSemistandardTableaux(Partition,ZZ)" -- see
        numSemistandardTableaux, -- compute the number
        of semistandard Young tableaux of a given shape
      * "numStandardTableaux(Partition)" -- see numStandardTableaux,
        -- compute the number of standard Young tableaux
        of a given shape
      * "numTabloids(Partition)" -- see numTabloids, --
        compute the number of tabloids of a given shape
      * "numTabloids(Partition,Partition)" -- see numTabloids,
        -- compute the number of tabloids of a given shape
      * "outerShape(YoungTableau)" -- see outerShape, -- the
        outer shape of a (skew) Young tableau
      * "positionList(YoungTableau)" -- see positionList,
        -- get the positions of all the boxes in a tableau
      * "positionList(YoungTableau,Function)" -- see positionList,
        -- get the positions of all the boxes in a tableau
      * "randomSemistandardTableau(Partition)" -- see
        randomSemistandardTableau, -- get a random
        semistandard Young Tableau
      * "randomSemistandardTableau(Partition,Partition)" -- see
        randomSemistandardTableau, -- get a random
        semistandard Young Tableau
      * "randomSemistandardTableau(Partition,Partition,ZZ)" -- see
        randomSemistandardTableau, -- get a random
        semistandard Young Tableau
      * "randomSemistandardTableau(Partition,ZZ)" -- see
        randomSemistandardTableau, -- get a random
        semistandard Young Tableau
      * "randomStandardTableau(Partition)" -- see randomStandardTableau,
        -- get a random standard Young Tableau
      * "randomTabloid(Partition)" -- see randomTabloid,
        -- get a random tabloid
      * "randomTabloid(Partition,Partition)" -- see randomTabloid,
        -- get a random tabloid
      * "readingWord(YoungTableau)" -- see readingWord, --
        get the reading word of a tableau
      * "representative(Tabloid)" -- see representative,
        -- get a canonical representative of a tabloid
      * "rowEntries(YoungTableau,ZZ)" -- see rowEntries, --
        get the entries in a row
      * "rowEntries(ZZ,YoungTableau)" -- see rowEntries, --
        get the entries in a row
      * "rowRange(YoungTableau)" -- see rowRange, -- the range
        of row indices of a tableau
      * "rowStabilizer(YoungTableau)" -- see rowStabilizer,
        -- the row stabilizer of a tableau
      * "shape(YoungTableau)" -- see shape, -- the shape of a
        Young tableau
      * "trim(Partition)" -- see shape, -- the shape of a Young
        tableau
      * "shift(YoungTableau)" -- see shift, -- shift a tableau
      * "shift(YoungTableau,ZZ)" -- see shift, -- shift a tableau
      * size(YoungTableau) -- the number of
        boxes in a tableau
      * "pad(Partition,Partition)" -- see skewShape, -- the
        shape of a skew tableau
      * "skewShape(YoungTableau)" -- see skewShape, -- the
        shape of a skew tableau
      * "trim(Partition,Partition)" -- see skewShape, -- the
        shape of a skew tableau
      * "standardize(Partition,Partition)" -- see standardize,
        -- standardize the lengths of a pair of partitions
      * "tabloid(Partition,List)" -- see tabloid, -- constructor
        for type Tabloid
      * "tabloid(Partition,Partition,List)" -- see tabloid, --
        constructor for type Tabloid
      * "tabloid(Sequence,List)" -- see tabloid, -- constructor
        for type Tabloid
      * "tabloid(YoungTableau)" -- see tabloid, -- constructor
        for type Tabloid
      * Tabloid == Tabloid -- check if two tabloids
        are equal
      * tex(YoungTableau) -- LaTeX output for a
        tableau
      * "toIndex(Sequence,YoungTableau)" -- see toIndex, -- get
        the index of a box, given its position
      * "toIndex(YoungTableau,Sequence)" -- see toIndex, -- get
        the index of a box, given its position
      * toList(Tabloid) -- list representation of a
        tabloid
      * "toPartitionChain(YoungTableau)" -- see toPartitionChain,
        -- decompose a tableau into a chain of partitions
      * "toPosition(YoungTableau,ZZ)" -- see toPosition, --
        get the position of a box, given its index
      * "toPosition(ZZ,YoungTableau)" -- see toPosition, --
        get the position of a box, given its index
      * "unshift(YoungTableau)" -- see unshift, -- unshift a
        tableau
      * "unshift(YoungTableau,ZZ)" -- see unshift, -- unshift a
        tableau
      * "verticalConcatenate(List)" -- see verticalConcatenate,
        -- vertical concatenation of a list of tableaux
      * "youngDiagram(Partition)" -- see youngDiagram, -- a
        net of the Young diagram
      * "youngDiagram(Partition,Partition)" -- see youngDiagram,
        -- a net of the Young diagram
      * "youngDiagram(YoungTableau)" -- see youngDiagram,
        -- a net of the Young diagram
      * "net(YoungTableau)" -- see YoungTableau, -- a type
        of HashTable representing a Young tableau
      * "youngTableau(Partition)" -- see youngTableau, --
        constructor for type YoungTableau
      * "youngTableau(Partition,List)" -- see youngTableau,
        -- constructor for type YoungTableau
      * "youngTableau(Partition,Partition)" -- see youngTableau,
        -- constructor for type YoungTableau
      * "youngTableau(Partition,Partition,List)" -- see youngTableau,
        -- constructor for type YoungTableau
      * "youngTableau(Sequence,List)" -- see youngTableau,
        -- constructor for type YoungTableau
      * "youngTableau(Tabloid)" -- see youngTableau, --
        constructor for type YoungTableau
      * YoungTableau ++ YoungTableau, --
        direct sum of tableaux
      * YoungTableau == YoungTableau, --
        check if two Young tableaux are equal
      * YoungTableau ^ ZZ -- get the entries in a row
      * YoungTableau _ Sequence -- get the
        entry at a specific position
      * YoungTableau _ ZZ -- get the entries in a
        column
      * YoungTableau || YoungTableau, --
        vertical concatenation of two tableaux

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

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

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

The source of this document is in Tableaux/documentation.m2:25:0.

allSemistandardTableaux -- list all semistandard Young tableaux of a given shape
********************************************************************************

  * Usage:
        allSemistandardTableaux(lam,mu,N)
        allSemistandardTableaux L
  * Inputs:
      * lam, an instance of the type Partition (Macaulay2Doc),
        the outer shape, $\lambda$.
      * mu, an instance of the type Partition (Macaulay2Doc),
        the inner shape, $\mu$.
      * N, an integer (Macaulay2Doc), the maximum entry.
      * L, a list (Macaulay2Doc), a list of tuples
        ($\lambda^{(i)}$,$\mu^{(i)}$,$N^{(i)}$).
  * Outputs:
      * b, a bag (Macaulay2Doc), bagged list of all SSYT of given
        shape and entries in 1..N. If N is not provided, it is assumed to be
        the length of the shape.

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

The resulting bag can be thought of as the set $\mathrm{SSYT}(\lambda,\mu,N)$
of semistandard Young tableaux of shape $\lambda/\mu$ and entries in
$1,2,\ldots,N$.

+-----------------------------------------------------------------------------+
|i1 : theBag = allSemistandardTableaux(new Partition from {5,4,2}, new        |
|                                                                             |
|o1 = -*a bagged sequence of length 144*-                                     |
|                                                                             |
|o1 : Bag                                                                     |
|-----------------------------------------------------------------------------|
|Partition from {3,1})                                                        |
+-----------------------------------------------------------------------------+
|i2 : for i from 0 to 4 do print theBag#i                                     |
|            ┌───┬───┐                                                        |
|            │ 1 │ 1 │                                                        |
|    ┌───┬───┼───┼───┘                                                        |
|    │ 1 │ 1 │ 2 │                                                            |
|┌───┼───┼───┴───┘                                                            |
|│ 1 │ 2 │                                                                    |
|└───┴───┘                                                                    |
|            ┌───┬───┐                                                        |
|            │ 1 │ 1 │                                                        |
|    ┌───┬───┼───┼───┘                                                        |
|    │ 1 │ 1 │ 2 │                                                            |
|┌───┼───┼───┴───┘                                                            |
|│ 1 │ 3 │                                                                    |
|└───┴───┘                                                                    |
|            ┌───┬───┐                                                        |
|            │ 1 │ 1 │                                                        |
|    ┌───┬───┼───┼───┘                                                        |
|    │ 1 │ 1 │ 2 │                                                            |
|┌───┼───┼───┴───┘                                                            |
|│ 2 │ 2 │                                                                    |
|└───┴───┘                                                                    |
|            ┌───┬───┐                                                        |
|            │ 1 │ 1 │                                                        |
|    ┌───┬───┼───┼───┘                                                        |
|    │ 1 │ 1 │ 2 │                                                            |
|┌───┼───┼───┴───┘                                                            |
|│ 2 │ 3 │                                                                    |
|└───┴───┘                                                                    |
|            ┌───┬───┐                                                        |
|            │ 1 │ 1 │                                                        |
|    ┌───┬───┼───┼───┘                                                        |
|    │ 1 │ 1 │ 2 │                                                            |
|┌───┼───┼───┴───┘                                                            |
|│ 3 │ 3 │                                                                    |
|└───┴───┘                                                                    |
+-----------------------------------------------------------------------------+

When the inner partition is $0$, the function numSemistandardTableaux,
computes the number of SSYT via the hook-content
formula.

+--------------------------------------------------------------+
|i3 : # allSemistandardTableaux(new Partition from {6,6,5,1,1})|
|                                                              |
|o3 = 2520                                                     |
+--------------------------------------------------------------+
|i4 : numSemistandardTableaux(new Partition from {6,6,5,1,1})  |
|                                                              |
|o4 = 2520                                                     |
+--------------------------------------------------------------+

A convenient way to compute the Cartesian product
$\mathrm{SSYT}(\lambda^{(1)},\mu^{(1)},N^{(1)})\times\mathrm{SSYT}(\lambda^{(2
)},\mu^{(2)},N^{(2)})\times\cdots$, is to use a list of the inputs
$L=\{(\lambda^{(1)},\mu^{(1)},N^{(1)}),(\lambda^{(2)},\mu^{(2)},N^{(2)}),\ldots
\}$. In this case, the output is a bagged list of tuples of tableaux.

+----------------------------------------------------------------+
|i5 : lam1 = new Partition from {3,1}                            |
|                                                                |
|o5 = Partition{3, 1}                                            |
|                                                                |
|o5 : Partition                                                  |
+----------------------------------------------------------------+
|i6 : mu1 = new Partition from {2}                               |
|                                                                |
|o6 = Partition{2}                                               |
|                                                                |
|o6 : Partition                                                  |
+----------------------------------------------------------------+
|i7 : lam2 = new Partition from {1,1}                            |
|                                                                |
|o7 = Partition{1, 1}                                            |
|                                                                |
|o7 : Partition                                                  |
+----------------------------------------------------------------+
|i8 : theProduct = allSemistandardTableaux {(lam1,mu1), (lam2,3)}|
|                                                                |
|o8 = -*a bagged sequence of length 12*-                         |
|                                                                |
|o8 : Bag                                                        |
+----------------------------------------------------------------+
|i9 : for i from 0 to 5 do print theProduct#i                    |
|         ┌───┐  ┌───┐                                           |
|(        │ 1 │, │ 1 │)                                          |
| ┌───┐   └───┘  ├───┤                                           |
| │ 1 │          │ 2 │                                           |
| └───┘          └───┘                                           |
|         ┌───┐  ┌───┐                                           |
|(        │ 1 │, │ 1 │)                                          |
| ┌───┐   └───┘  ├───┤                                           |
| │ 1 │          │ 3 │                                           |
| └───┘          └───┘                                           |
|         ┌───┐  ┌───┐                                           |
|(        │ 1 │, │ 2 │)                                          |
| ┌───┐   └───┘  ├───┤                                           |
| │ 1 │          │ 3 │                                           |
| └───┘          └───┘                                           |
|         ┌───┐  ┌───┐                                           |
|(        │ 1 │, │ 1 │)                                          |
| ┌───┐   └───┘  ├───┤                                           |
| │ 2 │          │ 2 │                                           |
| └───┘          └───┘                                           |
|         ┌───┐  ┌───┐                                           |
|(        │ 1 │, │ 1 │)                                          |
| ┌───┐   └───┘  ├───┤                                           |
| │ 2 │          │ 3 │                                           |
| └───┘          └───┘                                           |
|         ┌───┐  ┌───┐                                           |
|(        │ 1 │, │ 2 │)                                          |
| ┌───┐   └───┘  ├───┤                                           |
| │ 2 │          │ 3 │                                           |
| └───┘          └───┘                                           |
+----------------------------------------------------------------+

See also
========

  * numSemistandardTableaux -- compute the
    number of semistandard Young tableaux of a given shape
  * allStandardTableaux -- list all standard Young
    tableaux of a given shape
  * allTabloids -- list all tabloids of a given shape

Ways to use allSemistandardTableaux:
====================================

  * "allSemistandardTableaux(List)"
  * "allSemistandardTableaux(Partition)"
  * "allSemistandardTableaux(Partition,Partition)"
  * "allSemistandardTableaux(Partition,Partition,ZZ)"
  * "allSemistandardTableaux(Partition,ZZ)"

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

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

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

The source of this document is in Tableaux/documentation.m2:150:0.

allStandardTableaux -- list all standard Young tableaux of a given shape
************************************************************************

  * Usage:
        allSemistandardTableaux(lam)
  * Inputs:
      * lam, an instance of the type Partition (Macaulay2Doc),
        the shape, $\lambda$.
  * Outputs:
      * b, a bag (Macaulay2Doc), bagged list of all SYT of given
        shape and entries in $\{1,\ldots,N\}$, where $N$ is the size of
        $\lambda$.

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

+-------------------------------------------------------------+
|i1 : theBag = allStandardTableaux(new Partition from {4,3,1})|
|                                                             |
|o1 = -*a bagged sequence of length 70*-                      |
|                                                             |
|o1 : Bag                                                     |
+-------------------------------------------------------------+
|i2 : for i from 0 to 4 do print theBag#i                     |
|┌───┬───┬───┬───┐                                            |
|│ 1 │ 4 │ 6 │ 8 │                                            |
|├───┼───┼───┼───┘                                            |
|│ 2 │ 5 │ 7 │                                                |
|├───┼───┴───┘                                                |
|│ 3 │                                                        |
|└───┘                                                        |
|┌───┬───┬───┬───┐                                            |
|│ 1 │ 3 │ 6 │ 8 │                                            |
|├───┼───┼───┼───┘                                            |
|│ 2 │ 5 │ 7 │                                                |
|├───┼───┴───┘                                                |
|│ 4 │                                                        |
|└───┘                                                        |
|┌───┬───┬───┬───┐                                            |
|│ 1 │ 2 │ 6 │ 8 │                                            |
|├───┼───┼───┼───┘                                            |
|│ 3 │ 5 │ 7 │                                                |
|├───┼───┴───┘                                                |
|│ 4 │                                                        |
|└───┘                                                        |
|┌───┬───┬───┬───┐                                            |
|│ 1 │ 3 │ 6 │ 8 │                                            |
|├───┼───┼───┼───┘                                            |
|│ 2 │ 4 │ 7 │                                                |
|├───┼───┴───┘                                                |
|│ 5 │                                                        |
|└───┘                                                        |
|┌───┬───┬───┬───┐                                            |
|│ 1 │ 2 │ 6 │ 8 │                                            |
|├───┼───┼───┼───┘                                            |
|│ 3 │ 4 │ 7 │                                                |
|├───┼───┴───┘                                                |
|│ 5 │                                                        |
|└───┘                                                        |
+-------------------------------------------------------------+

The function numStandardTableaux, computes the
number of SYT.

+----------------------------------------------------+
|i3 : # theBag                                       |
|                                                    |
|o3 = 70                                             |
+----------------------------------------------------+
|i4 : numStandardTableaux(new Partition from {4,3,1})|
|                                                    |
|o4 = 70                                             |
+----------------------------------------------------+

See also
========

  * numStandardTableaux -- compute the number of
    standard Young tableaux of a given shape
  * allSemistandardTableaux -- list all
    semistandard Young tableaux of a given shape
  * allTabloids -- list all tabloids of a given shape

Ways to use allStandardTableaux:
================================

  * "allStandardTableaux(Partition)"

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

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

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

The source of this document is in Tableaux/documentation.m2:179:0.

allSubPartitions -- list all partitions whose Young diagrams are contained in another
*************************************************************************************

  * Usage:
        allSubPartitions(lam,mu)
  * Inputs:
      * lam, an instance of the type Partition (Macaulay2Doc),
        the outer shape, $\lambda$.
      * mu, an instance of the type Partition (Macaulay2Doc),
        the inner shape, $\mu$. If not provided, then it is the $0$ partition.
  * Outputs:
      * b, a bag (Macaulay2Doc), bagged list of all partitions $\nu$
        such that $\mu\subseteq\nu\subseteq\lambda$.

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

+-----------------------------------------------------------------------------+
|i1 : theBag = allSubPartitions(new Partition from {2,2,1},new Partition from |
|                                                                             |
|o1 = -*a bagged sequence of length 8*-                                       |
|                                                                             |
|o1 : Bag                                                                     |
|-----------------------------------------------------------------------------|
|{1})                                                                         |
+-----------------------------------------------------------------------------+
|i2 : for nu in theBag do print youngDiagram nu                               |
|┌───┐                                                                        |
|│   │                                                                        |
|└───┘                                                                        |
|┌───┬───┐                                                                    |
|│   │   │                                                                    |
|└───┴───┘                                                                    |
|┌───┐                                                                        |
|│   │                                                                        |
|├───┤                                                                        |
|│   │                                                                        |
|└───┘                                                                        |
|┌───┬───┐                                                                    |
|│   │   │                                                                    |
|├───┼───┘                                                                    |
|│   │                                                                        |
|└───┘                                                                        |
|┌───┬───┐                                                                    |
|│   │   │                                                                    |
|├───┼───┤                                                                    |
|│   │   │                                                                    |
|└───┴───┘                                                                    |
|┌───┐                                                                        |
|│   │                                                                        |
|├───┤                                                                        |
|│   │                                                                        |
|├───┤                                                                        |
|│   │                                                                        |
|└───┘                                                                        |
|┌───┬───┐                                                                    |
|│   │   │                                                                    |
|├───┼───┘                                                                    |
|│   │                                                                        |
|├───┤                                                                        |
|│   │                                                                        |
|└───┘                                                                        |
|┌───┬───┐                                                                    |
|│   │   │                                                                    |
|├───┼───┤                                                                    |
|│   │   │                                                                    |
|├───┼───┘                                                                    |
|│   │                                                                        |
|└───┘                                                                        |
+-----------------------------------------------------------------------------+

See also
========

  * allSemistandardTableaux -- list all
    semistandard Young tableaux of a given shape
  * allStandardTableaux -- list all standard Young
    tableaux of a given shape
  * allTabloids -- list all tabloids of a given shape

Ways to use allSubPartitions:
=============================

  * "allSubPartitions(Partition)"
  * "allSubPartitions(Partition,Partition)"

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

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

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

The source of this document is in Tableaux/documentation.m2:206:0.

allTabloids -- list all tabloids of a given shape
*************************************************

  * Usage:
        allSemistandardTableaux(lam,mu)
  * Inputs:
      * lam, an instance of the type Partition (Macaulay2Doc),
        the outer shape, $\lambda$.
      * mu, an instance of the type Partition (Macaulay2Doc),
        the inner shape, $\mu$.
  * Outputs:
      * b, a bag (Macaulay2Doc), bagged list of all tabloids of
        given shape and entries in $\{1,\ldots,N\}$, where $N$ is the size of
        the tabloid.

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

+-----------------------------------------------------+
|i1 : theBag = allTabloids(new Partition from {4,3,1})|
|                                                     |
|o1 = -*a bagged sequence of length 280*-             |
|                                                     |
|o1 : Bag                                             |
+-----------------------------------------------------+
|i2 : for i from 0 to 4 do print theBag#i             |
|┌───────────────┐                                    |
|│ 1   2   3   4 │                                    |
|├───────────┬───┘                                    |
|│ 5   6   7 │                                        |
|├───┬───────┘                                        |
|│ 8 │                                                |
|└───┘                                                |
|┌───────────────┐                                    |
|│ 1   2   3   4 │                                    |
|├───────────┬───┘                                    |
|│ 5   6   8 │                                        |
|├───┬───────┘                                        |
|│ 7 │                                                |
|└───┘                                                |
|┌───────────────┐                                    |
|│ 1   2   3   4 │                                    |
|├───────────┬───┘                                    |
|│ 5   7   8 │                                        |
|├───┬───────┘                                        |
|│ 6 │                                                |
|└───┘                                                |
|┌───────────────┐                                    |
|│ 1   2   3   4 │                                    |
|├───────────┬───┘                                    |
|│ 6   7   8 │                                        |
|├───┬───────┘                                        |
|│ 5 │                                                |
|└───┘                                                |
|┌───────────────┐                                    |
|│ 1   2   3   5 │                                    |
|├───────────┬───┘                                    |
|│ 4   6   7 │                                        |
|├───┬───────┘                                        |
|│ 8 │                                                |
|└───┘                                                |
+-----------------------------------------------------+

The function numTabloids, computes the number of tabloids.

+--------------------------------------------+
|i3 : # theBag                               |
|                                            |
|o3 = 280                                    |
+--------------------------------------------+
|i4 : numTabloids(new Partition from {4,3,1})|
|                                            |
|o4 = 280                                    |
+--------------------------------------------+

See also
========

  * numTabloids -- compute the number of tabloids of a
    given shape
  * allSemistandardTableaux -- list all
    semistandard Young tableaux of a given shape
  * allStandardTableaux -- list all standard Young
    tableaux of a given shape

Ways to use allTabloids:
========================

  * "allTabloids(Partition)"
  * "allTabloids(Partition,Partition)"

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

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

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

The source of this document is in Tableaux/documentation.m2:239:0.

applyEntries -- apply a function to all entries in the tableau
**************************************************************

  * Usage:
        applyEntries(T,f)
  * Inputs:
      * T, an instance of the type YoungTableau, a
        tableau.
      * f, a function (Macaulay2Doc), acts on the entries of T.
  * Outputs:
      * T', an instance of the type YoungTableau, a
        tableau with the same shape as T, and entries n -> f n.

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

+-----------------------------------------------------------------------------+
|i1 : T = youngTableau(new Partition from {6,3,2}, new Partition from {2},    |
|                                                                             |
|             ┌───┬───┬───┬───┐                                               |
|o1 =         │ 0 │ 1 │ 2 │ 3 │                                               |
|     ┌───┬───┼───┼───┴───┴───┘                                               |
|     │ 4 │ 5 │ 6 │                                                           |
|     ├───┼───┼───┘                                                           |
|     │ 7 │ 8 │                                                               |
|     └───┴───┘                                                               |
|                                                                             |
|o1 : YoungTableau                                                            |
|-----------------------------------------------------------------------------|
|toList(0..8))                                                                |
+-----------------------------------------------------------------------------+
|i2 : applyEntries(T, theBox -> theBox^2)                                     |
|                                                                             |
|               ┌────┬────┬────┬────┐                                         |
|o2 =           │ 0  │ 1  │ 4  │ 9  │                                         |
|     ┌────┬────┼────┼────┴────┴────┘                                         |
|     │ 16 │ 25 │ 36 │                                                        |
|     ├────┼────┼────┘                                                        |
|     │ 49 │ 64 │                                                             |
|     └────┴────┘                                                             |
|                                                                             |
|o2 : YoungTableau                                                            |
+-----------------------------------------------------------------------------+

See also
========

  * applyPositions -- apply a function to all positions
    of boxes in a tableau

Ways to use applyEntries:
=========================

  * "applyEntries(YoungTableau,Function)"

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

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

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

The source of this document is in Tableaux/documentation.m2:263:0.

applyPositions -- apply a function to all positions of boxes in a tableau
*************************************************************************

  * Usage:
        applyPositions(T,f)
  * Inputs:
      * T, an instance of the type YoungTableau, a skew
        Tableau.
      * f, a function (Macaulay2Doc), acts on the entries of T.
  * Outputs:
      * T', an instance of the type YoungTableau, a
        tableau with the same shape as T, and entries (i,j) -> f (i,j).

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

+-----------------------------------------------------------------------------+
|i1 : T = youngTableau(new Partition from {6,3,2}, new Partition from {2},    |
|                                                                             |
|             ┌───┬───┬───┬───┐                                               |
|o1 =         │ 0 │ 1 │ 2 │ 3 │                                               |
|     ┌───┬───┼───┼───┴───┴───┘                                               |
|     │ 4 │ 5 │ 6 │                                                           |
|     ├───┼───┼───┘                                                           |
|     │ 7 │ 8 │                                                               |
|     └───┴───┘                                                               |
|                                                                             |
|o1 : YoungTableau                                                            |
|-----------------------------------------------------------------------------|
|toList(0..8))                                                                |
+-----------------------------------------------------------------------------+
|i2 : applyPositions(T, thePosition -> thePosition)                           |
|                                                                             |
|                       ┌────────┬────────┬────────┬────────┐                 |
|o2 =                   │ (0, 2) │ (0, 3) │ (0, 4) │ (0, 5) │                 |
|     ┌────────┬────────┼────────┼────────┴────────┴────────┘                 |
|     │ (1, 0) │ (1, 1) │ (1, 2) │                                            |
|     ├────────┼────────┼────────┘                                            |
|     │ (2, 0) │ (2, 1) │                                                     |
|     └────────┴────────┘                                                     |
|                                                                             |
|o2 : YoungTableau                                                            |
+-----------------------------------------------------------------------------+
|i3 : applyPositions(T, thePosition -> thePosition#1 - thePosition#0)         |
|                                                                             |
|               ┌────┬────┬────┬────┐                                         |
|o3 =           │ 2  │ 3  │ 4  │ 5  │                                         |
|     ┌────┬────┼────┼────┴────┴────┘                                         |
|     │ -1 │ 0  │ 1  │                                                        |
|     ├────┼────┼────┘                                                        |
|     │ -2 │ -1 │                                                             |
|     └────┴────┘                                                             |
|                                                                             |
|o3 : YoungTableau                                                            |
+-----------------------------------------------------------------------------+
|i4 : applyPositions(T, thePosition -> (T_thePosition)^2)                     |
|                                                                             |
|               ┌────┬────┬────┬────┐                                         |
|o4 =           │ 0  │ 1  │ 4  │ 9  │                                         |
|     ┌────┬────┼────┼────┴────┴────┘                                         |
|     │ 16 │ 25 │ 36 │                                                        |
|     ├────┼────┼────┘                                                        |
|     │ 49 │ 64 │                                                             |
|     └────┴────┘                                                             |
|                                                                             |
|o4 : YoungTableau                                                            |
+-----------------------------------------------------------------------------+

See also
========

  * applyEntries -- apply a function to all entries in the
    tableau

Ways to use applyPositions:
===========================

  * "applyPositions(YoungTableau,Function)"

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

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

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

The source of this document is in Tableaux/documentation.m2:289:0.

boxContent -- compute the content of a box of a tableau
*******************************************************

  * Usage:
        boxContent(i,j)
  * Inputs:
      * i, an integer (Macaulay2Doc), the row index of a box.
      * j, an integer (Macaulay2Doc), the column index of a box.
  * Outputs:
      * n, an integer (Macaulay2Doc), the hook length of box (i,j).

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

The content of box (i,j) is defined as $j-i$.

+-----------------------------------------------------------------------------+
|i1 : T = youngTableau(new Partition from {6,6,5,3,1}, new Partition from     |
|                                                                             |
|             ┌───┬───┬───┬───┐                                               |
|o1 =         │   │   │   │   │                                               |
|         ┌───┼───┼───┼───┼───┤                                               |
|         │   │   │   │   │   │                                               |
|         ├───┼───┼───┼───┼───┘                                               |
|         │   │   │   │   │                                                   |
|     ┌───┼───┼───┼───┴───┘                                                   |
|     │   │   │   │                                                           |
|     ├───┼───┴───┘                                                           |
|     │   │                                                                   |
|     └───┘                                                                   |
|                                                                             |
|o1 : YoungTableau                                                            |
|-----------------------------------------------------------------------------|
|{2,1,1})                                                                     |
+-----------------------------------------------------------------------------+
|i2 : boxContent(1,1)                                                         |
|                                                                             |
|o2 = 0                                                                       |
+-----------------------------------------------------------------------------+
|i3 : applyPositions(T, thePosition -> boxContent thePosition)                |
|                                                                             |
|               ┌────┬────┬────┬────┐                                         |
|o3 =           │ 2  │ 3  │ 4  │ 5  │                                         |
|          ┌────┼────┼────┼────┼────┤                                         |
|          │ 0  │ 1  │ 2  │ 3  │ 4  │                                         |
|          ├────┼────┼────┼────┼────┘                                         |
|          │ -1 │ 0  │ 1  │ 2  │                                              |
|     ┌────┼────┼────┼────┴────┘                                              |
|     │ -3 │ -2 │ -1 │                                                        |
|     ├────┼────┴────┘                                                        |
|     │ -4 │                                                                  |
|     └────┘                                                                  |
|                                                                             |
|o3 : YoungTableau                                                            |
+-----------------------------------------------------------------------------+

Ways to use boxContent:
=======================

  * "boxContent(ZZ,ZZ)"

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

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

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

The source of this document is in Tableaux/documentation.m2:314:0.

columnEntries -- get the entries in a column
********************************************

  * Usage:
        columnEntries(T,j)
        columnEntries(j,T)
  * Inputs:
      * T, an instance of the type YoungTableau, a
        tableau.
      * j, an integer (Macaulay2Doc), the index of a column.
  * Outputs:
      * l, a list (Macaulay2Doc), the entries of column $j$ of T.

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

This returns the entries of a column without extra null (Macaulay2Doc),
entries, as opposed to T_i.

+-----------------------------------------------------------------------------+
|i1 : T = youngTableau(new Partition from {6,3,2}, new Partition from {2},    |
|                                                                             |
|             ┌───┬───┬───┬───┐                                               |
|o1 =         │ 1 │ 2 │ 3 │ 4 │                                               |
|     ┌───┬───┼───┼───┴───┴───┘                                               |
|     │ 5 │ 6 │ 7 │                                                           |
|     ├───┼───┼───┘                                                           |
|     │ 8 │ 9 │                                                               |
|     └───┴───┘                                                               |
|                                                                             |
|o1 : YoungTableau                                                            |
|-----------------------------------------------------------------------------|
|toList(1..9))                                                                |
+-----------------------------------------------------------------------------+
|i2 : columnEntries(T,0)                                                      |
|                                                                             |
|o2 = {5, 8}                                                                  |
|                                                                             |
|o2 : List                                                                    |
+-----------------------------------------------------------------------------+
|i3 : T_0                                                                     |
|                                                                             |
|o3 = {, 5, 8}                                                                |
|                                                                             |
|o3 : List                                                                    |
+-----------------------------------------------------------------------------+

See also
========

  * YoungTableau _ ZZ -- get the entries in a
    column

Ways to use columnEntries:
==========================

  * "columnEntries(YoungTableau,ZZ)"
  * "columnEntries(ZZ,YoungTableau)"

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

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

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

The source of this document is in Tableaux/documentation.m2:343:0.

columnRange -- the range of column indices of a tableau
*******************************************************

  * Usage:
        columnRange T
  * Inputs:
      * T, an instance of the type YoungTableau, a
        tableau.
  * Outputs:
      * seq, a sequence (Macaulay2Doc), the range of column
        indices.

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

Although it is straightforward that the row indices are 0..(numRows T - 1), the
analogous sequence does not work for columns since columns may have negative
indices. Hence, columnRange provides an easy way to iterate over column
indices. The lowest number is the smallest part of the tableau's shape, and the
largest number is the largest part of its shape.

+-----------------------------------------------------------------------------+
|i1 : T = youngTableau(new Partition from {8,7,6,6,1}, new Partition from     |
|                                                                             |
|               ║                   ┌────┬────┬────┬────┐                     |
|o1 =           ║                   │ 1  │ 2  │ 3  │ 4  │                     |
|               ║                   ├────┼────┼────┼────┘                     |
|               ║                   │ 5  │ 6  │ 7  │                          |
|               ║              ┌────┼────┼────┼────┘                          |
|               ║              │ 8  │ 9  │ 10 │                               |
|               ║         ┌────┼────┼────┼────┤                               |
|               ║         │ 11 │ 12 │ 13 │ 14 │                               |
|     ┌────┬────║────┐    └────┴────┴────┴────┘                               |
|     │ 15 │ 16 ║ 17 │                                                        |
|     └────┴────║────┘                                                        |
|                                                                             |
|o1 : YoungTableau                                                            |
|-----------------------------------------------------------------------------|
|{4,4,3,2,-2}, toList(1..17))                                                 |
+-----------------------------------------------------------------------------+
|i2 : columnRange T                                                           |
|                                                                             |
|o2 = (-2, -1, 0, 1, 2, 3, 4, 5, 6, 7)                                        |
|                                                                             |
|o2 : Sequence                                                                |
+-----------------------------------------------------------------------------+
|i3 : for j in columnRange T do print columnEntries(T,j)                      |
|{15}                                                                         |
|{16}                                                                         |
|{17}                                                                         |
|{}                                                                           |
|{11}                                                                         |
|{8, 12}                                                                      |
|{1, 5, 9, 13}                                                                |
|{2, 6, 10, 14}                                                               |
|{3, 7}                                                                       |
|{4}                                                                          |
+-----------------------------------------------------------------------------+

See also
========

  * YoungTableau _ ZZ -- get the entries in a
    column
  * columnEntries -- get the entries in a column
  * rowRange -- the range of row indices of a tableau
  * positionList -- get the positions of all the boxes in
    a tableau

Ways to use columnRange:
========================

  * "columnRange(YoungTableau)"

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

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

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

The source of this document is in Tableaux/documentation.m2:374:0.

columnStabilizer -- the column stabilizer of a tableau
******************************************************

  * Usage:
        columnStabilizer T
  * Inputs:
      * T, an instance of the type YoungTableau, a
        tableau.
  * Outputs:
      * l, a list (Macaulay2Doc), the permutations in the column
        stabilizer.

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

A permutation acts on a tableau by permuting its entries. The column stabilizer
of a tableau is the group of permutations that leave boxes in their original
columns.

+-----------------------------------------------------------------------------+
|i1 : T = youngTableau(new Partition from {2,2,1}, {1,4,2,5,3})               |
|                                                                             |
|     ┌───┬───┐                                                               |
|o1 = │ 1 │ 4 │                                                               |
|     ├───┼───┤                                                               |
|     │ 2 │ 5 │                                                               |
|     ├───┼───┘                                                               |
|     │ 3 │                                                                   |
|     └───┘                                                                   |
|                                                                             |
|o1 : YoungTableau                                                            |
+-----------------------------------------------------------------------------+
|i2 : columnStabilizer T                                                      |
|                                                                             |
|o2 = {Permutation{1, 2, 3, 4, 5}, Permutation{1, 2, 3, 5, 4}, Permutation{1, |
|     ------------------------------------------------------------------------|
|     3, 2, 4, 5}, Permutation{1, 3, 2, 5, 4}, Permutation{2, 1, 3, 4, 5},    |
|     ------------------------------------------------------------------------|
|     Permutation{2, 1, 3, 5, 4}, Permutation{2, 3, 1, 4, 5}, Permutation{2,  |
|     ------------------------------------------------------------------------|
|     3, 1, 5, 4}, Permutation{3, 1, 2, 4, 5}, Permutation{3, 1, 2, 5, 4},    |
|     ------------------------------------------------------------------------|
|     Permutation{3, 2, 1, 4, 5}, Permutation{3, 2, 1, 5, 4}}                 |
|                                                                             |
|o2 : List                                                                    |
+-----------------------------------------------------------------------------+

See also
========

  * rowStabilizer -- the row stabilizer of a tableau

Ways to use columnStabilizer:
=============================

  * "columnStabilizer(YoungTableau)"

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

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

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

The source of this document is in Tableaux/documentation.m2:399:0.

components(YoungTableau) -- get the connected components of a tableau
*********************************************************************

  * Function: components (Macaulay2Doc),
  * Usage:
        components T
  * Inputs:
      * T, an instance of the type YoungTableau, a
        tableau.
  * Outputs:
      * l, a list (Macaulay2Doc), a list of all connected
        components of T.

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

+-----------------------------------------------------------------------------+
|i1 : T = youngTableau(new Partition from {6,2,2}, new Partition from {2},    |
|                                                                             |
|             ┌───┬───┬───┬───┐                                               |
|o1 =         │ 0 │ 1 │ 2 │ 3 │                                               |
|     ┌───┬───┼───┴───┴───┴───┘                                               |
|     │ 4 │ 5 │                                                               |
|     ├───┼───┤                                                               |
|     │ 6 │ 7 │                                                               |
|     └───┴───┘                                                               |
|                                                                             |
|o1 : YoungTableau                                                            |
|-----------------------------------------------------------------------------|
|toList(0..7))                                                                |
+-----------------------------------------------------------------------------+
|i2 : components T                                                            |
|                                                                             |
|      ┌───┬───┬───┬───┐  ┌───┬───┐                                           |
|o2 = {│ 0 │ 1 │ 2 │ 3 │, │ 4 │ 5 │}                                          |
|      └───┴───┴───┴───┘  ├───┼───┤                                           |
|                         │ 6 │ 7 │                                           |
|                         └───┴───┘                                           |
|                                                                             |
|o2 : List                                                                    |
+-----------------------------------------------------------------------------+

See also
========

  * YoungTableau ++ YoungTableau -- direct
    sum of tableaux

Ways to use this method:
========================

  * components(YoungTableau) -- get the
    connected components of a tableau
-------------------------------------------------------------------------------

The source of this document is in Tableaux/documentation.m2:1626:0.

conjugate(YoungTableau) -- conjugate a tableau
**********************************************

  * Function: conjugate (Macaulay2Doc),
  * Usage:
        conjugate T
  * Inputs:
      * T, an instance of the type YoungTableau, a
        tableau.
  * Outputs:
      * S, an instance of the type YoungTableau, the rows
        and columns have been switched.

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

This method conjugates the tableau only if the shape has weakly decreasing
parts, and no negative parts. Otherwise, it will raise an error.

+-----------------------------------------------------------------------------+
|i1 : T = youngTableau(new Partition from {6,6,5,3,1}, new Partition from     |
|                                                                             |
|               ┌────┬────┬────┬────┐                                         |
|o1 =           │ 1  │ 2  │ 3  │ 4  │                                         |
|          ┌────┼────┼────┼────┼────┤                                         |
|          │ 5  │ 6  │ 7  │ 8  │ 9  │                                         |
|          ├────┼────┼────┼────┼────┘                                         |
|          │ 10 │ 11 │ 12 │ 13 │                                              |
|     ┌────┼────┼────┼────┴────┘                                              |
|     │ 14 │ 15 │ 16 │                                                        |
|     ├────┼────┴────┘                                                        |
|     │ 17 │                                                                  |
|     └────┘                                                                  |
|                                                                             |
|o1 : YoungTableau                                                            |
|-----------------------------------------------------------------------------|
|{2,1,1}, toList(1..17))                                                      |
+-----------------------------------------------------------------------------+
|i2 : conjugate T                                                             |
|                                                                             |
|                    ┌────┬────┐                                              |
|o2 =                │ 14 │ 17 │                                              |
|          ┌────┬────┼────┼────┘                                              |
|          │ 5  │ 10 │ 15 │                                                   |
|     ┌────┼────┼────┼────┤                                                   |
|     │ 1  │ 6  │ 11 │ 16 │                                                   |
|     ├────┼────┼────┼────┘                                                   |
|     │ 2  │ 7  │ 12 │                                                        |
|     ├────┼────┼────┤                                                        |
|     │ 3  │ 8  │ 13 │                                                        |
|     ├────┼────┼────┘                                                        |
|     │ 4  │ 9  │                                                             |
|     └────┴────┘                                                             |
|                                                                             |
|o2 : YoungTableau                                                            |
+-----------------------------------------------------------------------------+

Ways to use this method:
========================

  * conjugate(YoungTableau) -- conjugate a
    tableau
-------------------------------------------------------------------------------

The source of this document is in Tableaux/documentation.m2:1648:0.

drawInnerShape -- option to draw the inner shape of a tableau
*************************************************************

  * Usage:
        drawInnerShape b
  * Inputs:
      * b, a Boolean value (Macaulay2Doc), whether to draw the
        shape or not.
  * Outputs:
      * b, a Boolean value (Macaulay2Doc), the inputted value.
  * Consequences:
      * If b is true, then all subsequent calls to net will draw the inner
        shape. If b is false, then the inner shape is not drawn.

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

+-----------------------------------------------------------------------------+
|i1 : T = youngTableau(new Partition from {5,4,1}, new Partition from {2,1,1})|
|                                                                             |
|             ┌───┬───┬───┐                                                   |
|o1 =         │   │   │   │                                                   |
|         ┌───┼───┼───┼───┘                                                   |
|         │   │   │   │                                                       |
|         └───┴───┴───┘                                                       |
|                                                                             |
|                                                                             |
|                                                                             |
|o1 : YoungTableau                                                            |
+-----------------------------------------------------------------------------+
|i2 : drawInnerShape true                                                     |
|                                                                             |
|o2 = true                                                                    |
+-----------------------------------------------------------------------------+
|i3 : T                                                                       |
|                                                                             |
|             ┌───┬───┬───┐                                                   |
|o3 =   ■   ■ │   │   │   │                                                   |
|         ┌───┼───┼───┼───┘                                                   |
|       ■ │   │   │   │                                                       |
|         └───┴───┴───┘                                                       |
|       ■                                                                     |
|                                                                             |
|                                                                             |
|o3 : YoungTableau                                                            |
+-----------------------------------------------------------------------------+
|i4 : drawInnerShape false                                                    |
|                                                                             |
|o4 = false                                                                   |
+-----------------------------------------------------------------------------+
|i5 : T                                                                       |
|                                                                             |
|             ┌───┬───┬───┐                                                   |
|o5 =         │   │   │   │                                                   |
|         ┌───┼───┼───┼───┘                                                   |
|         │   │   │   │                                                       |
|         └───┴───┴───┘                                                       |
|                                                                             |
|                                                                             |
|                                                                             |
|o5 : YoungTableau                                                            |
+-----------------------------------------------------------------------------+

See also
========

  * youngTableau -- constructor for type YoungTableau

Ways to use drawInnerShape:
===========================

  * "drawInnerShape(Boolean)"

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

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

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

The source of this document is in Tableaux/documentation.m2:463:0.

entries(YoungTableau) -- the filling of a tableau
*************************************************

  * Function: entries (Macaulay2Doc),
  * Usage:
        entries T
  * Inputs:
      * T, an instance of the type YoungTableau, a Young
        tableau.
  * Outputs:
      * l, a list (Macaulay2Doc), the filling of T.

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

This returns the filling as a list.

+----------------------------------------------------------------+
|i1 : T = youngTableau(new Partition from {4,3,1,0},toList(1..8))|
|                                                                |
|     ┌───┬───┬───┬───┐                                          |
|o1 = │ 1 │ 2 │ 3 │ 4 │                                          |
|     ├───┼───┼───┼───┘                                          |
|     │ 5 │ 6 │ 7 │                                              |
|     ├───┼───┴───┘                                              |
|     │ 8 │                                                      |
|     └───┘                                                      |
|                                                                |
|o1 : YoungTableau                                               |
+----------------------------------------------------------------+
|i2 : entries T                                                  |
|                                                                |
|o2 = {1, 2, 3, 4, 5, 6, 7, 8}                                   |
|                                                                |
|o2 : List                                                       |
+----------------------------------------------------------------+

See also
========

  * size(YoungTableau) -- the number of boxes in
    a tableau

Ways to use this method:
========================

  * entries(YoungTableau) -- the filling of a
    tableau
-------------------------------------------------------------------------------

The source of this document is in Tableaux/documentation.m2:1671:0.

ferrersDiagram -- a net of the Ferrers diagram
**********************************************

  * Usage:
        ferrersDiagram(lam, mu)
        ferrersDiagram T
  * Inputs:
      * lam, an instance of the type Partition (Macaulay2Doc),
        the outer shape $\lambda$.
      * mu, an instance of the type Partition (Macaulay2Doc),
        the inner shape $\mu$. If not given, if is assumed to be the $0$
        partition.
      * T, an instance of the type YoungTableau, a skew
        tableau.
  * Outputs:
      * n, a net (Macaulay2Doc), a representation of the Ferrers
        diagram of shape $\lambda/\mu$.

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

+-----------------------------------------------------------------------------+
|i1 : T = youngTableau(new Partition from {4,3,1}, new Partition from {2,1},  |
|                                                                             |
|             ┌───┬───┐                                                       |
|o1 =         │ 1 │ 2 │                                                       |
|         ┌───┼───┼───┘                                                       |
|         │ 3 │ 4 │                                                           |
|     ┌───┼───┴───┘                                                           |
|     │ 5 │                                                                   |
|     └───┘                                                                   |
|                                                                             |
|o1 : YoungTableau                                                            |
|-----------------------------------------------------------------------------|
|{1,2,3,4,5})                                                                 |
+-----------------------------------------------------------------------------+
|i2 : ferrersDiagram T                                                        |
|                                                                             |
|o2 =     ● ●                                                                 |
|       ● ●                                                                   |
|     ●                                                                       |
+-----------------------------------------------------------------------------+

See also
========

  * youngTableau -- constructor for type YoungTableau
  * youngDiagram -- a net of the Young diagram

Ways to use ferrersDiagram:
===========================

  * "ferrersDiagram(Partition)"
  * "ferrersDiagram(Partition,Partition)"
  * "ferrersDiagram(YoungTableau)"

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

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

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

The source of this document is in Tableaux/documentation.m2:493:0.

hookLength -- compute the hook length of a box of a tableau
***********************************************************

  * Usage:
        n = hookLength(thePosition,T)
        m = hookLength lam
  * Inputs:
      * thePosition, a sequence (Macaulay2Doc), a pair (i,j) of
        integers.
      * T, an instance of the type YoungTableau, a
        tableau.
      * lam, an instance of the type Partition (Macaulay2Doc),
        a partition.
  * Outputs:
      * n, an integer (Macaulay2Doc), the hook length of box (i,j) in
        T.
      * m, an integer (Macaulay2Doc), the hook length formula for
        lam.

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

The hook length of box (i,j) is defined as the number of boxes directly below,
and directly to the right, of a box, including the box itself.

+-----------------------------------------------------------------------------+
|i1 : T = youngTableau(new Partition from {6,6,5,3,1}, new Partition from     |
|                                                                             |
|             ┌───┬───┬───┬───┐                                               |
|o1 =         │   │   │   │   │                                               |
|         ┌───┼───┼───┼───┼───┤                                               |
|         │   │   │   │   │   │                                               |
|         ├───┼───┼───┼───┼───┘                                               |
|         │   │   │   │   │                                                   |
|     ┌───┼───┼───┼───┴───┘                                                   |
|     │   │   │   │                                                           |
|     ├───┼───┴───┘                                                           |
|     │   │                                                                   |
|     └───┘                                                                   |
|                                                                             |
|o1 : YoungTableau                                                            |
|-----------------------------------------------------------------------------|
|{2,1,1})                                                                     |
+-----------------------------------------------------------------------------+
|i2 : hookLength((1,1),T)                                                     |
|                                                                             |
|o2 = 7                                                                       |
+-----------------------------------------------------------------------------+
|i3 : applyPositions(T, thePosition -> hookLength(thePosition,T))             |
|                                                                             |
|             ┌───┬───┬───┬───┐                                               |
|o3 =         │ 7 │ 5 │ 4 │ 2 │                                               |
|         ┌───┼───┼───┼───┼───┤                                               |
|         │ 7 │ 6 │ 4 │ 3 │ 1 │                                               |
|         ├───┼───┼───┼───┼───┘                                               |
|         │ 5 │ 4 │ 2 │ 1 │                                                   |
|     ┌───┼───┼───┼───┴───┘                                                   |
|     │ 4 │ 2 │ 1 │                                                           |
|     ├───┼───┴───┘                                                           |
|     │ 1 │                                                                   |
|     └───┘                                                                   |
|                                                                             |
|o3 : YoungTableau                                                            |
+-----------------------------------------------------------------------------+

The hook length formula computes the number of standard Young tableau of shape
$\lambda$.

+-------------------------------------+
|i4 : lam = new Partition from {3,2,2}|
|                                     |
|o4 = Partition{3, 2, 2}              |
|                                     |
|o4 : Partition                       |
+-------------------------------------+
|i5 : hookLength lam                  |
|                                     |
|o5 = 21                              |
+-------------------------------------+

See also
========

  * numStandardTableaux -- compute the number of
    standard Young tableaux of a given shape
  * allStandardTableaux -- list all standard Young
    tableaux of a given shape

Ways to use hookLength:
=======================

  * "hookLength(Partition)"
  * "hookLength(Sequence,YoungTableau)"

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

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

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

The source of this document is in Tableaux/documentation.m2:533:0.

horizontalNet -- multiple nets concatenated horizontally
********************************************************

  * Usage:
        horizontalNet L
  * Inputs:
      * L, a list (Macaulay2Doc), a list or sequence.
  * Outputs:
      * n, a net (Macaulay2Doc), a net of objects in L, stacked
        horizontally and justified at the top.

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

If L is a list of objects $A_1,A_2,\ldots,A_n$, then this concatenates their
nets horizontally.

+-----------------------------------------------------------------------------+
|i1 : T1 = youngTableau(new Partition from {6,6,5,3,1}, new Partition from    |
|                                                                             |
|             ┌───┬───┬───┬───┐                                               |
|o1 =         │   │   │   │   │                                               |
|         ┌───┼───┼───┼───┼───┤                                               |
|         │   │   │   │   │   │                                               |
|         ├───┼───┼───┼───┼───┘                                               |
|         │   │   │   │   │                                                   |
|     ┌───┼───┼───┼───┴───┘                                                   |
|     │   │   │   │                                                           |
|     ├───┼───┴───┘                                                           |
|     │   │                                                                   |
|     └───┘                                                                   |
|                                                                             |
|o1 : YoungTableau                                                            |
|-----------------------------------------------------------------------------|
|{2,1,1})                                                                     |
+-----------------------------------------------------------------------------+
|i2 : T2 = youngTableau(new Partition from {3,1}, new Partition from {1},     |
|                                                                             |
|         ┌───┬───┐                                                           |
|o2 =     │ a │ b │                                                           |
|     ┌───┼───┴───┘                                                           |
|     │ c │                                                                   |
|     └───┘                                                                   |
|                                                                             |
|o2 : YoungTableau                                                            |
|-----------------------------------------------------------------------------|
|{"a","b","c"})                                                               |
+-----------------------------------------------------------------------------+
|i3 : horizontalNet {T1, T2}                                                  |
|                                                                             |
|             ┌───┬───┬───┬───┐    ┌───┬───┐                                  |
|o3 =         │   │   │   │   │    │ a │ b │                                  |
|         ┌───┼───┼───┼───┼───┤┌───┼───┴───┘                                  |
|         │   │   │   │   │   ││ c │                                          |
|         ├───┼───┼───┼───┼───┘└───┘                                          |
|         │   │   │   │   │                                                   |
|     ┌───┼───┼───┼───┴───┘                                                   |
|     │   │   │   │                                                           |
|     ├───┼───┴───┘                                                           |
|     │   │                                                                   |
|     └───┘                                                                   |
+-----------------------------------------------------------------------------+

See also
========

  * verticalNet -- multiple nets concatenated vertically

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

The object horizontalNet, is a function closure (Macaulay2Doc).

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

The source of this document is in Tableaux/documentation.m2:557:0.

innerShape -- the inner shape of a (skew) Young tableau
*******************************************************

  * Usage:
        mu = innerShape T
  * Inputs:
      * T, an instance of the type YoungTableau, a Young
        tableau of shape $\lambda/\mu$.
  * Outputs:
      * mu, an instance of the type Partition (Macaulay2Doc),
        the inner shape, $\mu$, of T.

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

If the tableau has (non-skew) shape $\lambda$, then this returns the empty
partition.

+-----------------------------------------------------------------------------+
|i1 : T = youngTableau(new Partition from {4,3,1,0}, new Partition from {3,1})|
|                                                                             |
|                 ┌───┐                                                       |
|o1 =             │   │                                                       |
|         ┌───┬───┼───┘                                                       |
|         │   │   │                                                           |
|     ┌───┼───┴───┘                                                           |
|     │   │                                                                   |
|     └───┘                                                                   |
|                                                                             |
|o1 : YoungTableau                                                            |
+-----------------------------------------------------------------------------+
|i2 : innerShape T                                                            |
|                                                                             |
|o2 = Partition{3, 1}                                                         |
|                                                                             |
|o2 : Partition                                                               |
+-----------------------------------------------------------------------------+

See also
========

  * outerShape -- the outer shape of a (skew) Young tableau
  * shape -- the shape of a Young tableau
  * skewShape -- the shape of a skew tableau

Ways to use innerShape:
=======================

  * "innerShape(YoungTableau)"

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

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

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

The source of this document is in Tableaux/documentation.m2:583:0.

isCorner -- checks if a box is a corner of a tableau
****************************************************

  * Usage:
        isCorner((rowIndex,colIndex), T)
  * Inputs:
      * rowIndex, an integer (Macaulay2Doc), the row index of a box.
      * colIndex, an integer (Macaulay2Doc), the column index of a
        box.
      * T, an instance of the type YoungTableau, a Young
        tableau.
  * Outputs:
      * b, a Boolean value (Macaulay2Doc), returns true if the
        box is a corner, and false otherwise.

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

The corners of a tableau are the boxes that are both the last box in a row, and
the last box in a column.

+-----------------------------------------------------------------------------+
|i1 : T = youngTableau(new Partition from {7,7,6,5,3,2,2,2,1}, new Partition  |
|                                                                             |
|                 ┌───┬───┬───┬───┐                                           |
|o1 =             │   │   │   │   │                                           |
|         ┌───┬───┼───┼───┼───┼───┤                                           |
|         │   │   │   │   │   │   │                                           |
|     ┌───┼───┼───┼───┼───┼───┼───┘                                           |
|     │   │   │   │   │   │   │                                               |
|     ├───┼───┼───┼───┼───┼───┘                                               |
|     │   │   │   │   │   │                                                   |
|     ├───┼───┼───┼───┴───┘                                                   |
|     │   │   │   │                                                           |
|     ├───┼───┼───┘                                                           |
|     │   │   │                                                               |
|     ├───┼───┤                                                               |
|     │   │   │                                                               |
|     ├───┼───┤                                                               |
|     │   │   │                                                               |
|     ├───┼───┘                                                               |
|     │   │                                                                   |
|     └───┘                                                                   |
|                                                                             |
|o1 : YoungTableau                                                            |
|-----------------------------------------------------------------------------|
|from {3,1})                                                                  |
+-----------------------------------------------------------------------------+
|i2 : isCorner((1,3),T)                                                       |
|                                                                             |
|o2 = false                                                                   |
+-----------------------------------------------------------------------------+
|i3 : applyPositions(T,thePosition -> isCorner(thePosition,T))                |
|                                                                             |
|                             ┌───────┬───────┬───────┬───────┐               |
|o3 =                         │ false │ false │ false │ false │               |
|             ┌───────┬───────┼───────┼───────┼───────┼───────┤               |
|             │ false │ false │ false │ false │ false │ true  │               |
|     ┌───────┼───────┼───────┼───────┼───────┼───────┼───────┘               |
|     │ false │ false │ false │ false │ false │ true  │                       |
|     ├───────┼───────┼───────┼───────┼───────┼───────┘                       |
|     │ false │ false │ false │ false │ true  │                               |
|     ├───────┼───────┼───────┼───────┴───────┘                               |
|     │ false │ false │ true  │                                               |
|     ├───────┼───────┼───────┘                                               |
|     │ false │ false │                                                       |
|     ├───────┼───────┤                                                       |
|     │ false │ false │                                                       |
|     ├───────┼───────┤                                                       |
|     │ false │ true  │                                                       |
|     ├───────┼───────┘                                                       |
|     │ true  │                                                               |
|     └───────┘                                                               |
|                                                                             |
|o3 : YoungTableau                                                            |
+-----------------------------------------------------------------------------+

Ways to use isCorner:
=====================

  * "isCorner(Sequence,Partition)"
  * "isCorner(Sequence,YoungTableau)"

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

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

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

The source of this document is in Tableaux/documentation.m2:611:0.

isNonnegative -- check if shapes are nonnegative
************************************************

  * Usage:
        isNonnegative T
        isNonnegative (lam,mu)
        isNonnegative lam
  * Inputs:
      * T, an instance of the type YoungTableau, a
        tableau.
      * lam, an instance of the type Partition (Macaulay2Doc),
        the outer shape, $\lambda$.
      * mu, an instance of the type Partition (Macaulay2Doc),
        the inner shape, $\mu$.
  * Outputs:
      * b, a Boolean value (Macaulay2Doc), returns true if both
        shapes are nonnegative, and false otherwise.

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

+-----------------------------------------------------------------------------+
|i1 : isNonnegative youngTableau(new Partition from {6,6,5,3,1}, new Partition|
|                                                                             |
|o1 = true                                                                    |
|-----------------------------------------------------------------------------|
|from {2,1,1})                                                                |
+-----------------------------------------------------------------------------+
|i2 : isNonnegative new Partition from {5,3,-1,0}                             |
|                                                                             |
|o2 = false                                                                   |
+-----------------------------------------------------------------------------+

Ways to use isNonnegative:
==========================

  * "isNonnegative(Partition)"
  * "isNonnegative(Partition,Partition)"
  * "isNonnegative(YoungTableau)"

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

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

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

The source of this document is in Tableaux/documentation.m2:710:0.

isSemistandard -- checks if a Young tableau is semistandard
***********************************************************

  * Usage:
        isSemistandard T
  * Inputs:
      * T, an instance of the type YoungTableau, a Young
        tableau.
  * Outputs:
      * b, a Boolean value (Macaulay2Doc), returns true if the
        tableau is semistandard, and false otherwise.

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

A semistandard Young tableau (SSYT) has entries in $\N=\{1,2,3,\ldots\}$ where
the rows are weakly increasing, and columns are strictly increasing. Here, we
also require $\lambda$ and $\mu$ to have nonnegative parts.

+-----------------------------------------------------------------------------+
|i1 : T = youngTableau(new Partition from {5,3,2}, new Partition from {3,1},  |
|                                                                             |
|                 ┌───┬───┐                                                   |
|o1 =             │ 1 │ 3 │                                                   |
|         ┌───┬───┼───┴───┘                                                   |
|         │ 2 │ 2 │                                                           |
|     ┌───┼───┼───┘                                                           |
|     │ 2 │ 3 │                                                               |
|     └───┴───┘                                                               |
|                                                                             |
|o1 : YoungTableau                                                            |
|-----------------------------------------------------------------------------|
|{1,3,2,2,2,3})                                                               |
+-----------------------------------------------------------------------------+
|i2 : isSemistandard T                                                        |
|                                                                             |
|o2 = true                                                                    |
+-----------------------------------------------------------------------------+

See also
========

  * isStandard -- checks if a Young tableau is standard

Ways to use isSemistandard:
===========================

  * "isSemistandard(YoungTableau)"

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

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

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

The source of this document is in Tableaux/documentation.m2:636:0.

isSkew -- checks if a Young tableau is skew
*******************************************

  * Usage:
        isSkew T
  * Inputs:
      * T, an instance of the type YoungTableau, a Young
        tableau of shape $\lambda/\mu$.
  * Outputs:
      * b, a Boolean value (Macaulay2Doc), returns true if the
        inner shape $\mu$ is not $0$, and true if $\mu=0$.

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

+-----------------------------------------------------------------------------+
|i1 : T = youngTableau(new Partition from {5,3,2}, new Partition from {3,1},  |
|                                                                             |
|                 ┌───┬───┐                                                   |
|o1 =             │ 1 │ 3 │                                                   |
|         ┌───┬───┼───┴───┘                                                   |
|         │ 2 │ 2 │                                                           |
|     ┌───┼───┼───┘                                                           |
|     │ 2 │ 3 │                                                               |
|     └───┴───┘                                                               |
|                                                                             |
|o1 : YoungTableau                                                            |
|-----------------------------------------------------------------------------|
|{1,3,2,2,2,3})                                                               |
+-----------------------------------------------------------------------------+
|i2 : isSkew T                                                                |
|                                                                             |
|o2 = true                                                                    |
+-----------------------------------------------------------------------------+

Ways to use isSkew:
===================

  * "isSkew(YoungTableau)"

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

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

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

The source of this document is in Tableaux/documentation.m2:656:0.

isStandard -- checks if a Young tableau is standard
***************************************************

  * Usage:
        isStandard T
  * Inputs:
      * T, an instance of the type YoungTableau, a Young
        tableau.
  * Outputs:
      * b, a Boolean value (Macaulay2Doc), returns true if the
        tableau is standard, and false otherwise.

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

A standard Young tableau (SYT) has entries in $\N=\{1,2,3,\ldots,N\}$ where $N$
is the number of boxes, and the rows are columns are strictly increasing. Here,
we also require $\lambda$ to have nonnegative parts, and inner shape $\mu=0$.

+---------------------------------------------------------------+
|i1 : T = youngTableau(new Partition from {5,3,1}, toList(1..9))|
|                                                               |
|     ┌───┬───┬───┬───┬───┐                                     |
|o1 = │ 1 │ 2 │ 3 │ 4 │ 5 │                                     |
|     ├───┼───┼───┼───┴───┘                                     |
|     │ 6 │ 7 │ 8 │                                             |
|     ├───┼───┴───┘                                             |
|     │ 9 │                                                     |
|     └───┘                                                     |
|                                                               |
|o1 : YoungTableau                                              |
+---------------------------------------------------------------+
|i2 : isStandard T                                              |
|                                                               |
|o2 = true                                                      |
+---------------------------------------------------------------+

See also
========

  * isSemistandard -- checks if a Young tableau is
    semistandard

Ways to use isStandard:
=======================

  * "isStandard(YoungTableau)"

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

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

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

The source of this document is in Tableaux/documentation.m2:682:0.

isWeaklyDecreasing -- check if shapes are weakly decreasing
***********************************************************

  * Usage:
        isWeaklyDecreasing T
        isWeaklyDecreasing (lam,mu)
        isWeaklyDecreasing lam
  * Inputs:
      * T, an instance of the type YoungTableau, a
        tableau.
      * lam, an instance of the type Partition (Macaulay2Doc),
        the outer shape, $\lambda$.
      * mu, an instance of the type Partition (Macaulay2Doc),
        the inner shape, $\mu$.
  * Outputs:
      * b, a Boolean value (Macaulay2Doc), returns true if both
        shapes have weakly decreasing parts, and false otherwise.

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

+-----------------------------------------------------------------------------+
|i1 : isWeaklyDecreasing youngTableau(new Partition from {6,6,5,3,1}, new     |
|                                                                             |
|o1 = true                                                                    |
|-----------------------------------------------------------------------------|
|Partition from {2,1,1})                                                      |
+-----------------------------------------------------------------------------+
|i2 : isWeaklyDecreasing new Partition from {5,3,-1,0}                        |
|                                                                             |
|o2 = false                                                                   |
+-----------------------------------------------------------------------------+

Ways to use isWeaklyDecreasing:
===============================

  * "isWeaklyDecreasing(Partition)"
  * "isWeaklyDecreasing(Partition,Partition)"
  * "isWeaklyDecreasing(YoungTableau)"

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

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

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

The source of this document is in Tableaux/documentation.m2:738:0.

MutableYoungTableau -- a type of HashTable representing a Young tableau, with mutable entries
*********************************************************************************************

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

An object of type MutableYoungTableau is a hash table containing two shapes of
type Partition (Macaulay2Doc), and a mutable list of box
entries. The entries may have any type, except for null (Macaulay2Doc),
objects.

The inner and outer shapes, $\lambda$ and $\mu$ respectively, can be any
sequence of integers. In particular, it accepts negative parts, compositions,
rows where $\lambda_i < \mu_i$, and compositions where
$\ell(\lambda)\neq\ell(\mu)$.

+----------------------------------------------+
|i1 : lam = new Partition from {4,3,2}         |
|                                              |
|o1 = Partition{4, 3, 2}                       |
|                                              |
|o1 : Partition                                |
+----------------------------------------------+
|i2 : mu = new Partition from {3,1}            |
|                                              |
|o2 = Partition{3, 1}                          |
|                                              |
|o2 : Partition                                |
+----------------------------------------------+
|i3 : entryList = {1,2,3,3,9}                  |
|                                              |
|o3 = {1, 2, 3, 3, 9}                          |
|                                              |
|o3 : List                                     |
+----------------------------------------------+
|i4 : T = mutableYoungTableau(lam,mu,entryList)|
|                                              |
|                 ┌───┐                        |
|o4 =             │ 1 │                        |
|         ┌───┬───┼───┘                        |
|         │ 2 │ 3 │                            |
|     ┌───┼───┼───┘                            |
|     │ 3 │ 9 │                                |
|     └───┴───┘                                |
|                                              |
|o4 : MutableYoungTableau                      |
+----------------------------------------------+
|i5 : T_(1,1) = 8                              |
|                                              |
|o5 = 8                                        |
+----------------------------------------------+
|i6 : T                                        |
|                                              |
|                 ┌───┐                        |
|o6 =             │ 1 │                        |
|         ┌───┬───┼───┘                        |
|         │ 8 │ 3 │                            |
|     ┌───┼───┼───┘                            |
|     │ 3 │ 9 │                                |
|     └───┴───┘                                |
|                                              |
|o6 : MutableYoungTableau                      |
+----------------------------------------------+

See also
========

  * mutableYoungTableau -- constructor for type
    MutableYoungTableau

Functions and methods returning an object of class MutableYoungTableau:
=======================================================================

  * mutableYoungTableau -- constructor for type
    MutableYoungTableau

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

  * MutableYoungTableau _ Sequence = Thing
    -- change an entry of a mutable Young tableau

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

The object MutableYoungTableau, is a type (Macaulay2Doc),
with ancestor classes YoungTableau, <
HashTable (Macaulay2Doc) < Thing (Macaulay2Doc).

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

The source of this document is in Tableaux/documentation.m2:49:0.

mutableYoungTableau -- constructor for type MutableYoungTableau
***************************************************************

  * Usage:
        mutableYoungTableau(lam, mu, entryList)
        mutableYoungTableau((lam,mu),entryList)
  * Inputs:
      * lam, an instance of the type Partition (Macaulay2Doc),
        the outer shape $\lambda$.
      * mu, an instance of the type Partition (Macaulay2Doc),
        the inner shape $\mu$. If not given, then it is assumed to be the $0$
        partition.
      * entryList, a list (Macaulay2Doc), the filling of the boxes.
        If not given, then box entries are assumed to be the empty string "".
  * Outputs:
      * T, an instance of the type MutableYoungTableau,
        a skew Young tableau of shape $\lambda/\mu$ with
        the given (mutable) filling.
  * Consequences:
      * The list of entries has length equal to
        $\sum_{i=1}^{\ell(\lambda)}|\lambda_i-\mu_i|$. E.g., if $\lambda=(2)$
        and $\mu=(5)$, then the entry list must have length $3$.
      * None of the entries are null.

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

This is the same as type YoungTableau, except that the
entries may be changed.

+-----------------------------------------------------------------------------+
|i1 : T = mutableYoungTableau(new Partition from {4,2,1}, new Partition from  |
|                                                                             |
|         ┌───┬───┬───┐                                                       |
|o1 =     │ 1 │ 2 │ 3 │                                                       |
|     ┌───┼───┼───┴───┘                                                       |
|     │ 4 │ 5 │                                                               |
|     ├───┼───┘                                                               |
|     │ 6 │                                                                   |
|     └───┘                                                                   |
|                                                                             |
|o1 : MutableYoungTableau                                                     |
|-----------------------------------------------------------------------------|
|{1}, toList(1..6))                                                           |
+-----------------------------------------------------------------------------+
|i2 : T_(0,2) = 9                                                             |
|                                                                             |
|o2 = 9                                                                       |
+-----------------------------------------------------------------------------+
|i3 : T                                                                       |
|                                                                             |
|         ┌───┬───┬───┐                                                       |
|o3 =     │ 1 │ 9 │ 3 │                                                       |
|     ┌───┼───┼───┴───┘                                                       |
|     │ 4 │ 5 │                                                               |
|     ├───┼───┘                                                               |
|     │ 6 │                                                                   |
|     └───┘                                                                   |
|                                                                             |
|o3 : MutableYoungTableau                                                     |
+-----------------------------------------------------------------------------+

See also
========

  * MutableYoungTableau _ Sequence = Thing
    -- change an entry of a mutable Young tableau
  * youngTableau -- constructor for type YoungTableau

Ways to use mutableYoungTableau:
================================

  * "mutableYoungTableau(Partition)"
  * "mutableYoungTableau(Partition,List)"
  * "mutableYoungTableau(Partition,Partition)"
  * "mutableYoungTableau(Partition,Partition,List)"
  * "mutableYoungTableau(Sequence,List)"

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

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

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

The source of this document is in Tableaux/documentation.m2:779:0.

MutableYoungTableau _ Sequence = Thing -- change an entry of a mutable Young tableau
************************************************************************************

  * Operator: _ (Macaulay2Doc),
  * Usage:
        T_thePosition = k
  * Inputs:
      * T, an instance of the type MutableYoungTableau,
        a mutable tableau.
      * thePosition, a sequence (Macaulay2Doc), a pair (i,j) of
        integers.
      * k, a thing (Macaulay2Doc), the new entry in position
        (i,j).
  * Outputs:
      * T, an instance of the type MutableYoungTableau,
        a mutable tableau with entry k in position (i,j).

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

+-----------------------------------------------------------------------------+
|i1 : T = mutableYoungTableau(new Partition from {4,2,1}, new Partition from  |
|                                                                             |
|         ┌───┬───┬───┐                                                       |
|o1 =     │ 1 │ 2 │ 3 │                                                       |
|     ┌───┼───┼───┴───┘                                                       |
|     │ 4 │ 5 │                                                               |
|     ├───┼───┘                                                               |
|     │ 6 │                                                                   |
|     └───┘                                                                   |
|                                                                             |
|o1 : MutableYoungTableau                                                     |
|-----------------------------------------------------------------------------|
|{1}, toList(1..6))                                                           |
+-----------------------------------------------------------------------------+
|i2 : T_(0,2) = 9                                                             |
|                                                                             |
|o2 = 9                                                                       |
+-----------------------------------------------------------------------------+
|i3 : T                                                                       |
|                                                                             |
|         ┌───┬───┬───┐                                                       |
|o3 =     │ 1 │ 9 │ 3 │                                                       |
|     ┌───┼───┼───┴───┘                                                       |
|     │ 4 │ 5 │                                                               |
|     ├───┼───┘                                                               |
|     │ 6 │                                                                   |
|     └───┘                                                                   |
|                                                                             |
|o3 : MutableYoungTableau                                                     |
+-----------------------------------------------------------------------------+

Ways to use this method:
========================

  * MutableYoungTableau _ Sequence = Thing
    -- change an entry of a mutable Young tableau
-------------------------------------------------------------------------------

The source of this document is in Tableaux/documentation.m2:803:0.

numColumns(YoungTableau) -- the number of columns in a tableau
**************************************************************

  * Function: numColumns (Macaulay2Doc),
  * Usage:
        numColumns T
  * Inputs:
      * T, an instance of the type YoungTableau, a
        tableau.
  * Outputs:
      * n, an integer (Macaulay2Doc), the number of columns in T.

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

The number of rows is the same as largest part in its shape, minus the smallest
part in the shape.

+-----------------------------------------------------------------------------+
|i1 : drawInnerShape true                                                     |
|                                                                             |
|o1 = true                                                                    |
+-----------------------------------------------------------------------------+
|i2 : T = youngTableau(new Partition from {4,3,1}, new Partition from {1,1,1})|
|                                                                             |
|         ┌───┬───┬───┐                                                       |
|o2 =   ■ │   │   │   │                                                       |
|         ├───┼───┼───┘                                                       |
|       ■ │   │   │                                                           |
|         └───┴───┘                                                           |
|       ■                                                                     |
|                                                                             |
|                                                                             |
|o2 : YoungTableau                                                            |
+-----------------------------------------------------------------------------+
|i3 : numColumns T                                                            |
|                                                                             |
|o3 = 3                                                                       |
+-----------------------------------------------------------------------------+

Note that, if a shape contains negative parts, then columns may have negative
indices.

+-----------------------------------------------------------------------------+
|i4 : T' = youngTableau(new Partition from {4,3,1}, new Partition from        |
|                                                                             |
|     ┌───║───┬───┬───┬───┐                                                   |
|o4 = │   ║   │   │   │   │                                                   |
|     └───║───┼───┼───┼───┘                                                   |
|         ║ ■ │   │   │                                                       |
|         ║   └───┴───┘                                                       |
|         ║ ■                                                                 |
|         ║                                                                   |
|                                                                             |
|o4 : YoungTableau                                                            |
|-----------------------------------------------------------------------------|
|{-1,1,1})                                                                    |
+-----------------------------------------------------------------------------+
|i5 : numColumns T'                                                           |
|                                                                             |
|o5 = 5                                                                       |
+-----------------------------------------------------------------------------+

See also
========

  * numRows(YoungTableau) -- the number of
    rows in a tableau
  * columnRange -- the range of column indices of a tableau

Ways to use this method:
========================

  * numColumns(YoungTableau) -- the number
    of columns in a tableau
-------------------------------------------------------------------------------

The source of this document is in Tableaux/documentation.m2:1701:0.

numRows(YoungTableau) -- the number of rows in a tableau
********************************************************

  * Function: numRows (Macaulay2Doc),
  * Usage:
        numRows T
  * Inputs:
      * T, an instance of the type YoungTableau, a
        tableau.
  * Outputs:
      * n, an integer (Macaulay2Doc), the number of rows in T.

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

The number of rows is the same as the length of its shapes, excluding trailing
$0$'s.

+-----------------------------------------------------------------------------+
|i1 : T = youngTableau(new Partition from {4,3,1,0}, new Partition from       |
|                                                                             |
|         ┌───┬───┬───┐                                                       |
|o1 =     │   │   │   │                                                       |
|         ├───┼───┼───┘                                                       |
|         │   │   │                                                           |
|         ├───┼───┤                                                           |
|         │░░ │░░ │                                                           |
|     ┌───┼───┼───┘                                                           |
|     │░░ │░░ │                                                               |
|     └───┴───┘                                                               |
|                                                                             |
|o1 : YoungTableau                                                            |
|-----------------------------------------------------------------------------|
|{1,1,3,2,0})                                                                 |
+-----------------------------------------------------------------------------+
|i2 : numRows T                                                               |
|                                                                             |
|o2 = 4                                                                       |
+-----------------------------------------------------------------------------+
|i3 : (lam,mu) = standardize skewShape T                                      |
|                                                                             |
|o3 = (Partition{4, 3, 1, 0}, Partition{1, 1, 3, 2})                          |
|                                                                             |
|o3 : Sequence                                                                |
+-----------------------------------------------------------------------------+
|i4 : #lam                                                                    |
|                                                                             |
|o4 = 4                                                                       |
+-----------------------------------------------------------------------------+

See also
========

  * numColumns(YoungTableau) -- the number
    of columns in a tableau

Ways to use this method:
========================

  * numRows(YoungTableau) -- the number of
    rows in a tableau
-------------------------------------------------------------------------------

The source of this document is in Tableaux/documentation.m2:1726:0.

numSemistandardTableaux -- compute the number of semistandard Young tableaux of a given shape
*********************************************************************************************

  * Usage:
        numSemistandardTableaux(lam,N)
  * Inputs:
      * lam, an instance of the type Partition (Macaulay2Doc),
        the shape, $\lambda$.
      * N, an integer (Macaulay2Doc), the maximum entry.
  * Outputs:
      * n, an integer (Macaulay2Doc), the number of SSYT of the given
        shape, and entries in 1..N. If N is not provided, it is assumed to be
        the length of the shape.

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

A bagged list of the tableaux can be created with
allSemistandardTableaux.

+--------------------------------------------------------------+
|i1 : # allSemistandardTableaux(new Partition from {6,6,5,1,1})|
|                                                              |
|o1 = 2520                                                     |
+--------------------------------------------------------------+
|i2 : numSemistandardTableaux(new Partition from {6,6,5,1,1})  |
|                                                              |
|o2 = 2520                                                     |
+--------------------------------------------------------------+

See also
========

  * allSemistandardTableaux -- list all
    semistandard Young tableaux of a given shape
  * numStandardTableaux -- compute the number of
    standard Young tableaux of a given shape
  * numTabloids -- compute the number of tabloids of a
    given shape

Ways to use numSemistandardTableaux:
====================================

  * "numSemistandardTableaux(Partition)"
  * "numSemistandardTableaux(Partition,ZZ)"

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

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

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

The source of this document is in Tableaux/documentation.m2:833:0.

numStandardTableaux -- compute the number of standard Young tableaux of a given shape
*************************************************************************************

  * Usage:
        numStandardTableaux lam
  * Inputs:
      * lam, an instance of the type Partition (Macaulay2Doc),
        the shape, $\lambda$.
  * Outputs:
      * n, an integer (Macaulay2Doc), the number of SYT of the given
        shape, and entries in $\{1,\ldots,N\}$, where $N$ is the number of
        boxes.

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

A bagged list of the tableaux can be created with allStandardTableaux.

+------------------------------------------------------+
|i1 : # allStandardTableaux(new Partition from {4,2,1})|
|                                                      |
|o1 = 35                                               |
+------------------------------------------------------+
|i2 : numStandardTableaux(new Partition from {4,2,1})  |
|                                                      |
|o2 = 35                                               |
+------------------------------------------------------+

See also
========

  * allStandardTableaux -- list all standard Young
    tableaux of a given shape
  * numSemistandardTableaux -- compute the
    number of semistandard Young tableaux of a given shape
  * numTabloids -- compute the number of tabloids of a
    given shape

Ways to use numStandardTableaux:
================================

  * "numStandardTableaux(Partition)"

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

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

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

The source of this document is in Tableaux/documentation.m2:859:0.

numTabloids -- compute the number of tabloids of a given shape
**************************************************************

  * Usage:
        numTabloids(lam,mu)
  * Inputs:
      * lam, an instance of the type Partition (Macaulay2Doc),
        the outer shape $\lambda$.
      * mu, an instance of the type Partition (Macaulay2Doc),
        the inner shape $\mu$. If not given, then it is assumed to be the $0$
        partition.
  * Outputs:
      * n, an integer (Macaulay2Doc), the number of tabloids of the
        given shape, and entries in $\{1,\ldots,N\}$, where $N$ is the number
        of boxes.

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

A bagged list of the tableaux can be created with allTabloids.

+----------------------------------------------+
|i1 : # allTabloids(new Partition from {4,2,1})|
|                                              |
|o1 = 105                                      |
+----------------------------------------------+
|i2 : numTabloids(new Partition from {4,2,1})  |
|                                              |
|o2 = 105                                      |
+----------------------------------------------+

See also
========

  * allTabloids -- list all tabloids of a given shape
  * numSemistandardTableaux -- compute the
    number of semistandard Young tableaux of a given shape
  * numStandardTableaux -- compute the number of
    standard Young tableaux of a given shape

Ways to use numTabloids:
========================

  * "numTabloids(Partition)"
  * "numTabloids(Partition,Partition)"

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

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

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

The source of this document is in Tableaux/documentation.m2:888:0.

outerShape -- the outer shape of a (skew) Young tableau
*******************************************************

  * Usage:
        mu = outerShape T
  * Inputs:
      * T, an instance of the type YoungTableau, a Young
        tableau of shape $\lambda/\mu$.
  * Outputs:
      * lam, an instance of the type Partition (Macaulay2Doc),
        the outer shape, $\lambda, of T.

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

+-----------------------------------------------------------------------------+
|i1 : T = youngTableau(new Partition from {4,3,1,0}, new Partition from {3,1})|
|                                                                             |
|                 ┌───┐                                                       |
|o1 =             │   │                                                       |
|         ┌───┬───┼───┘                                                       |
|         │   │   │                                                           |
|     ┌───┼───┴───┘                                                           |
|     │   │                                                                   |
|     └───┘                                                                   |
|                                                                             |
|o1 : YoungTableau                                                            |
+-----------------------------------------------------------------------------+
|i2 : outerShape T                                                            |
|                                                                             |
|o2 = Partition{4, 3, 1, 0}                                                   |
|                                                                             |
|o2 : Partition                                                               |
+-----------------------------------------------------------------------------+

See also
========

  * innerShape -- the inner shape of a (skew) Young tableau
  * shape -- the shape of a Young tableau
  * skewShape -- the shape of a skew tableau

Ways to use outerShape:
=======================

  * "outerShape(YoungTableau)"

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

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

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

The source of this document is in Tableaux/documentation.m2:912:0.

positionList -- get the positions of all the boxes in a tableau
***************************************************************

  * Usage:
        positionList T
        positionList(T,f)
  * Inputs:
      * T, an instance of the type YoungTableau, a
        tableau.
      * f, a function (Macaulay2Doc), a function that acts on
        the positions, and returns either true or false.
  * Outputs:
      * l, a list (Macaulay2Doc), the positions (i,j) of boxes in
        T. If a function f is provided, then only the positions returning true
        are in the list.

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

This method is useful for iterating over all positions in a tableau.

+-----------------------------------------------------------------------------+
|i1 : T = youngTableau(new Partition from {6,3,2}, new Partition from {2},    |
|                                                                             |
|               ┌────┬────┬────┬────┐                                         |
|o1 =           │ 10 │ 11 │ 12 │ 13 │                                         |
|     ┌────┬────┼────┼────┴────┴────┘                                         |
|     │ 14 │ 15 │ 16 │                                                        |
|     ├────┼────┼────┘                                                        |
|     │ 17 │ 18 │                                                             |
|     └────┴────┘                                                             |
|                                                                             |
|o1 : YoungTableau                                                            |
|-----------------------------------------------------------------------------|
|toList(10..18))                                                              |
+-----------------------------------------------------------------------------+
|i2 : theList = positionList T                                                |
|                                                                             |
|o2 = {(0, 2), (0, 3), (0, 4), (0, 5), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1)}|
|                                                                             |
|o2 : List                                                                    |
+-----------------------------------------------------------------------------+
|i3 : T' = youngTableau(new Partition from {6,3,2}, new Partition from {2},   |
|                                                                             |
|                       ┌────────┬────────┬────────┬────────┐                 |
|o3 =                   │ (0, 2) │ (0, 3) │ (0, 4) │ (0, 5) │                 |
|     ┌────────┬────────┼────────┼────────┴────────┴────────┘                 |
|     │ (1, 0) │ (1, 1) │ (1, 2) │                                            |
|     ├────────┼────────┼────────┘                                            |
|     │ (2, 0) │ (2, 1) │                                                     |
|     └────────┴────────┘                                                     |
|                                                                             |
|o3 : YoungTableau                                                            |
|-----------------------------------------------------------------------------|
|theList)                                                                     |
+-----------------------------------------------------------------------------+

Including a function returns only the positions that return true. For example,
the following code returns all positions of corners in the tableau, using
function isCorner.

+------------------------------------------------------------+
|i4 : positionList(T, thePosition -> isCorner(thePosition,T))|
|                                                            |
|o4 = {(0, 5), (1, 2), (2, 1)}                               |
|                                                            |
|o4 : List                                                   |
+------------------------------------------------------------+

See also
========

  * toPosition -- get the position of a box, given its index
  * toIndex -- get the index of a box, given its position

Ways to use positionList:
=========================

  * "positionList(YoungTableau)"
  * "positionList(YoungTableau,Function)"

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

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

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

The source of this document is in Tableaux/documentation.m2:948:0.

randomSemistandardTableau -- get a random semistandard Young Tableau
********************************************************************

  * Usage:
        randomSemistandardTableau(lam,mu,N)
  * Inputs:
      * lam, an instance of the type Partition (Macaulay2Doc),
        the outer shape, $\lambda$, of T.
      * mu, an instance of the type Partition (Macaulay2Doc),
        the inner shape, $\mu$, of T.
      * N, an integer (Macaulay2Doc), the maximum entry.
  * Outputs:
      * T, an instance of the type YoungTableau, a random
        semistandard Young tableau with entries in $\{1,\ldots,N\}$. If $N$ is
        not provided, then it is assumed to be the length of $\lambda$. If
        $\mu$ is not provided, then it is assumed to be $0$.

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

Note that this does not select a tableau uniformly randomly.

+-----------------------------------------+
|i1 : lam = new Partition from {5,4,3,3,1}|
|                                         |
|o1 = Partition{5, 4, 3, 3, 1}            |
|                                         |
|o1 : Partition                           |
+-----------------------------------------+
|i2 : mu = new Partition from {3,1,1}     |
|                                         |
|o2 = Partition{3, 1, 1}                  |
|                                         |
|o2 : Partition                           |
+-----------------------------------------+
|i3 : randomSemistandardTableau(lam,mu)   |
|                                         |
|                 ┌───┬───┐               |
|o3 =             │ 3 │ 5 │               |
|         ┌───┬───┼───┼───┘               |
|         │ 1 │ 3 │ 5 │                   |
|         ├───┼───┼───┘                   |
|         │ 2 │ 4 │                       |
|     ┌───┼───┼───┤                       |
|     │ 3 │ 3 │ 5 │                       |
|     ├───┼───┴───┘                       |
|     │ 4 │                               |
|     └───┘                               |
|                                         |
|o3 : YoungTableau                        |
+-----------------------------------------+
|i4 : randomSemistandardTableau lam       |
|                                         |
|     ┌───┬───┬───┬───┬───┐               |
|o4 = │ 1 │ 1 │ 2 │ 3 │ 5 │               |
|     ├───┼───┼───┼───┼───┘               |
|     │ 2 │ 3 │ 3 │ 4 │                   |
|     ├───┼───┼───┼───┘                   |
|     │ 3 │ 4 │ 4 │                       |
|     ├───┼───┼───┤                       |
|     │ 4 │ 5 │ 5 │                       |
|     ├───┼───┴───┘                       |
|     │ 5 │                               |
|     └───┘                               |
|                                         |
|o4 : YoungTableau                        |
+-----------------------------------------+

See also
========

  * randomStandardTableau -- get a random
    standard Young Tableau
  * randomTabloid -- get a random tabloid
  * allSemistandardTableaux -- list all
    semistandard Young tableaux of a given shape

Ways to use randomSemistandardTableau:
======================================

  * "randomSemistandardTableau(Partition)"
  * "randomSemistandardTableau(Partition,Partition)"
  * "randomSemistandardTableau(Partition,Partition,ZZ)"
  * "randomSemistandardTableau(Partition,ZZ)"

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

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

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

The source of this document is in Tableaux/documentation.m2:984:0.

randomStandardTableau -- get a random standard Young Tableau
************************************************************

  * Usage:
        randomStandardTableau(lam,mu,N)
  * Inputs:
      * lam, an instance of the type Partition (Macaulay2Doc),
        the outer shape, $\lambda$, of T.
      * mu, an instance of the type Partition (Macaulay2Doc),
        the inner shape, $\mu$, of T.
  * Outputs:
      * T, an instance of the type YoungTableau, a random
        standard Young tableau of shape $\lambda$.

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

Note that this does not select a tableau uniformly randomly.

+-----------------------------------------+
|i1 : lam = new Partition from {5,4,3,3,1}|
|                                         |
|o1 = Partition{5, 4, 3, 3, 1}            |
|                                         |
|o1 : Partition                           |
+-----------------------------------------+
|i2 : randomStandardTableau lam           |
|                                         |
|     ┌────┬────┬────┬────┬────┐          |
|o2 = │ 1  │ 2  │ 5  │ 11 │ 15 │          |
|     ├────┼────┼────┼────┼────┘          |
|     │ 3  │ 4  │ 6  │ 13 │               |
|     ├────┼────┼────┼────┘               |
|     │ 7  │ 8  │ 9  │                    |
|     ├────┼────┼────┤                    |
|     │ 10 │ 12 │ 14 │                    |
|     ├────┼────┴────┘                    |
|     │ 16 │                              |
|     └────┘                              |
|                                         |
|o2 : YoungTableau                        |
+-----------------------------------------+

See also
========

  * randomSemistandardTableau -- get a random
    semistandard Young Tableau
  * randomTabloid -- get a random tabloid
  * allStandardTableaux -- list all standard Young
    tableaux of a given shape

Ways to use randomStandardTableau:
==================================

  * "randomStandardTableau(Partition)"

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

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

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

The source of this document is in Tableaux/documentation.m2:1012:0.

randomTabloid -- get a random tabloid
*************************************

  * Usage:
        randomTabloid(lam,mu)
  * Inputs:
      * lam, an instance of the type Partition (Macaulay2Doc),
        the outer shape, $\lambda$, of T.
      * mu, an instance of the type Partition (Macaulay2Doc),
        the inner shape, $\mu$, of T.
  * Outputs:
      * T, an instance of the type Tabloid, a random tabloid
        with entries in $\{1,\ldots,N\}$, where $N$ is the length of $\lambda$.
        If $\mu$ is not provided, then it is assumed to be $0$.

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

+-----------------------------------------+
|i1 : lam = new Partition from {5,4,3,3,1}|
|                                         |
|o1 = Partition{5, 4, 3, 3, 1}            |
|                                         |
|o1 : Partition                           |
+-----------------------------------------+
|i2 : mu = new Partition from {3,1,1}     |
|                                         |
|o2 = Partition{3, 1, 1}                  |
|                                         |
|o2 : Partition                           |
+-----------------------------------------+
|i3 : randomTabloid(lam,mu)               |
|                                         |
|                    ┌─────────┐          |
|o3 =                │ 6    4  │          |
|          ┌─────────┴────┬────┘          |
|          │ 7    9    2  │               |
|          ├─────────┬────┘               |
|          │ 3    1  │                    |
|     ┌────┴─────────┤                    |
|     │ 10   11   5  │                    |
|     ├────┬─────────┘                    |
|     │ 8  │                              |
|     └────┘                              |
|                                         |
|o3 : Tabloid                             |
+-----------------------------------------+
|i4 : randomTabloid lam                   |
|                                         |
|     ┌────────────────────────┐          |
|o4 = │ 7    4    9    12   2  │          |
|     ├───────────────────┬────┘          |
|     │ 8    16   6    14 │               |
|     ├──────────────┬────┘               |
|     │ 5    15   10 │                    |
|     ├──────────────┤                    |
|     │ 11   1    3  │                    |
|     ├────┬─────────┘                    |
|     │ 13 │                              |
|     └────┘                              |
|                                         |
|o4 : Tabloid                             |
+-----------------------------------------+

See also
========

  * randomSemistandardTableau -- get a random
    semistandard Young Tableau
  * randomStandardTableau -- get a random
    standard Young Tableau
  * allTabloids -- list all tabloids of a given shape

Ways to use randomTabloid:
==========================

  * "randomTabloid(Partition)"
  * "randomTabloid(Partition,Partition)"

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

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

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

The source of this document is in Tableaux/documentation.m2:1043:0.

readingWord -- get the reading word of a tableau
************************************************

  * Usage:
        readingWord T
  * Inputs:
      * T, an instance of the type YoungTableau, a
        tableau.
  * Outputs:
      * l, a list (Macaulay2Doc), the reading word of T.

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

The reading word is the list of entries going up the columns, from left to
right.

+-----------------------------------------------------------------------------+
|i1 : T = youngTableau(new Partition from {6,3,2}, new Partition from {2},    |
|                                                                             |
|               ┌────┬────┬────┬────┐                                         |
|o1 =           │ 10 │ 11 │ 12 │ 13 │                                         |
|     ┌────┬────┼────┼────┴────┴────┘                                         |
|     │ 14 │ 15 │ 16 │                                                        |
|     ├────┼────┼────┘                                                        |
|     │ 17 │ 18 │                                                             |
|     └────┴────┘                                                             |
|                                                                             |
|o1 : YoungTableau                                                            |
|-----------------------------------------------------------------------------|
|toList(10..18))                                                              |
+-----------------------------------------------------------------------------+
|i2 : readingWord T                                                           |
|                                                                             |
|o2 = {17, 14, 18, 15, 16, 10, 11, 12, 13}                                    |
|                                                                             |
|o2 : List                                                                    |
+-----------------------------------------------------------------------------+

Ways to use readingWord:
========================

  * "readingWord(YoungTableau)"

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

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

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

The source of this document is in Tableaux/documentation.m2:1065:0.

representative -- get a canonical representative of a tabloid
*************************************************************

  * Usage:
        representative T
  * Inputs:
      * T, an instance of the type Tabloid, a tabloid.
  * Outputs:
      * T', an instance of the type YoungTableau, a
        representative of T.

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

A tabloid is an equivalence class of Young Tableaux. We can obtain a canonical
representative by sorting the boxes in each row.

+-----------------------------------------------------------------------------+
|i1 : T = tabloid(new Partition from {6,3,2}, new Partition from {2},         |
|                                                                             |
|             ┌───────────────┐                                               |
|o1 =         │ 9   5   1   2 │                                               |
|     ┌───────┴───┬───────────┘                                               |
|     │ 4   3   7 │                                                           |
|     ├───────┬───┘                                                           |
|     │ 8   6 │                                                               |
|     └───────┘                                                               |
|                                                                             |
|o1 : Tabloid                                                                 |
|-----------------------------------------------------------------------------|
|{9,5,1,2,4,3,7,8,6})                                                         |
+-----------------------------------------------------------------------------+
|i2 : representative T                                                        |
|                                                                             |
|             ┌───┬───┬───┬───┐                                               |
|o2 =         │ 1 │ 2 │ 5 │ 9 │                                               |
|     ┌───┬───┼───┼───┴───┴───┘                                               |
|     │ 3 │ 4 │ 7 │                                                           |
|     ├───┼───┼───┘                                                           |
|     │ 6 │ 8 │                                                               |
|     └───┴───┘                                                               |
|                                                                             |
|o2 : YoungTableau                                                            |
+-----------------------------------------------------------------------------+

See also
========

  * Tabloid -- a type of HashTable representing a Young tabloid

Ways to use representative:
===========================

  * "representative(Tabloid)"

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

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

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

The source of this document is in Tableaux/documentation.m2:1090:0.

rowEntries -- get the entries in a row
**************************************

  * Usage:
        rowEntries(T,i)
        rowEntries(i,T)
  * Inputs:
      * T, an instance of the type YoungTableau, a
        tableau.
      * i, an integer (Macaulay2Doc), the index of a row.
  * Outputs:
      * l, a list (Macaulay2Doc), the entries of row $i$ of T.

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

This returns the entries exactly as they appear in the row without extra
null (Macaulay2Doc), entries, as opposed to T^i.

+-----------------------------------------------------------------------------+
|i1 : T = youngTableau(new Partition from {6,3,2}, new Partition from {2},    |
|                                                                             |
|             ┌───┬───┬───┬───┐                                               |
|o1 =         │ 1 │ 2 │ 3 │ 4 │                                               |
|     ┌───┬───┼───┼───┴───┴───┘                                               |
|     │ 5 │ 6 │ 7 │                                                           |
|     ├───┼───┼───┘                                                           |
|     │ 8 │ 9 │                                                               |
|     └───┴───┘                                                               |
|                                                                             |
|o1 : YoungTableau                                                            |
|-----------------------------------------------------------------------------|
|toList(1..9))                                                                |
+-----------------------------------------------------------------------------+
|i2 : rowEntries(T,0)                                                         |
|                                                                             |
|o2 = {1, 2, 3, 4}                                                            |
|                                                                             |
|o2 : List                                                                    |
+-----------------------------------------------------------------------------+
|i3 : T^0                                                                     |
|                                                                             |
|o3 = {, , 1, 2, 3, 4}                                                        |
|                                                                             |
|o3 : List                                                                    |
+-----------------------------------------------------------------------------+

See also
========

  * YoungTableau ^ ZZ -- get the entries in a row

Ways to use rowEntries:
=======================

  * "rowEntries(YoungTableau,ZZ)"
  * "rowEntries(ZZ,YoungTableau)"

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

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

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

The source of this document is in Tableaux/documentation.m2:1119:0.

rowRange -- the range of row indices of a tableau
*************************************************

  * Usage:
        rowRange T
  * Inputs:
      * T, an instance of the type YoungTableau, a
        tableau.
  * Outputs:
      * seq, a sequence (Macaulay2Doc), the range of row
        indices.

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

Returns the sequence 0..(numRows T - 1).

+-----------------------------------------------------------------------------+
|i1 : T = youngTableau(new Partition from {5,4,2,1,0,0}, new Partition from   |
|                                                                             |
|             ┌───┬───┬───┐                                                   |
|o1 =         │ 1 │ 2 │ 3 │                                                   |
|             ├───┼───┼───┘                                                   |
|             │ 4 │ 5 │                                                       |
|             └───┴───┘                                                       |
|                                                                             |
|     ┌───┐                                                                   |
|     │ 6 │                                                                   |
|     └───┘                                                                   |
|                                                                             |
|o1 : YoungTableau                                                            |
|-----------------------------------------------------------------------------|
|{2,2,2}, toList(1..6))                                                       |
+-----------------------------------------------------------------------------+
|i2 : rowRange T                                                              |
|                                                                             |
|o2 = (0, 1, 2, 3)                                                            |
|                                                                             |
|o2 : Sequence                                                                |
+-----------------------------------------------------------------------------+
|i3 : for i in rowRange T do print rowEntries(T,i)                            |
|{1, 2, 3}                                                                    |
|{4, 5}                                                                       |
|{}                                                                           |
|{6}                                                                          |
+-----------------------------------------------------------------------------+

See also
========

  * YoungTableau ^ ZZ -- get the entries in a row
  * rowEntries -- get the entries in a row
  * columnRange -- the range of column indices of a tableau
  * positionList -- get the positions of all the boxes in
    a tableau

Ways to use rowRange:
=====================

  * "rowRange(YoungTableau)"

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

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

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

The source of this document is in Tableaux/documentation.m2:1148:0.

rowStabilizer -- the row stabilizer of a tableau
************************************************

  * Usage:
        rowStabilizer T
  * Inputs:
      * T, an instance of the type YoungTableau, a
        tableau.
  * Outputs:
      * l, a list (Macaulay2Doc), the permutations in the row
        stabilizer.

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

A permutation acts on a tableau by permuting its entries. The row stabilizer of
a tableau is the group of permutations that leave boxes in their original rows.

+-----------------------------------------------------------------------------+
|i1 : T = youngTableau(new Partition from {2,2,1}, {1,4,2,5,3})               |
|                                                                             |
|     ┌───┬───┐                                                               |
|o1 = │ 1 │ 4 │                                                               |
|     ├───┼───┤                                                               |
|     │ 2 │ 5 │                                                               |
|     ├───┼───┘                                                               |
|     │ 3 │                                                                   |
|     └───┘                                                                   |
|                                                                             |
|o1 : YoungTableau                                                            |
+-----------------------------------------------------------------------------+
|i2 : rowStabilizer T                                                         |
|                                                                             |
|o2 = {Permutation{1, 2, 3, 4, 5}, Permutation{1, 5, 3, 4, 2}, Permutation{4, |
|     ------------------------------------------------------------------------|
|     2, 3, 1, 5}, Permutation{4, 5, 3, 1, 2}}                                |
|                                                                             |
|o2 : List                                                                    |
+-----------------------------------------------------------------------------+

See also
========

  * columnStabilizer -- the column stabilizer of a
    tableau

Ways to use rowStabilizer:
==========================

  * "rowStabilizer(YoungTableau)"

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

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

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

The source of this document is in Tableaux/documentation.m2:1173:0.

shape -- the shape of a Young tableau
*************************************

  * Usage:
        lam = shape T
  * Inputs:
      * T, an instance of the type YoungTableau, a Young
        tableau.
  * Outputs:
      * lam, an instance of the type Partition (Macaulay2Doc),
        the shape, $\lambda$, of T.

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

This returns the original shape used to construct the tableau.

+---------------------------------------------------+
|i1 : T = youngTableau(new Partition from {4,3,1,0})|
|                                                   |
|     ┌───┬───┬───┬───┐                             |
|o1 = │   │   │   │   │                             |
|     ├───┼───┼───┼───┘                             |
|     │   │   │   │                                 |
|     ├───┼───┴───┘                                 |
|     │   │                                         |
|     └───┘                                         |
|                                                   |
|o1 : YoungTableau                                  |
+---------------------------------------------------+
|i2 : shape T                                       |
|                                                   |
|o2 = Partition{4, 3, 1, 0}                         |
|                                                   |
|o2 : Partition                                     |
+---------------------------------------------------+

It may be convenient to remove trailing $0$'s from the partitions by using trim
on the partition.

+-----------------------+
|i3 : trim shape T      |
|                       |
|o3 = Partition{4, 3, 1}|
|                       |
|o3 : Partition         |
+-----------------------+

See also
========

  * skewShape -- the shape of a skew tableau

Ways to use shape:
==================

  * "shape(YoungTableau)"

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

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

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

The source of this document is in Tableaux/documentation.m2:1202:0.

shift -- shift a tableau
************************

  * Usage:
        shift T
        shift(T,n)
  * Inputs:
      * T, an instance of the type YoungTableau, a
        tableau.
      * n, an integer (Macaulay2Doc), an additional amount to shift.
  * Outputs:
      * S, an instance of the type YoungTableau, each row
        i of T has been shifted by i + n to the right (where n=0 if not
        provided).

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

+-----------------------------------------------------+
|i1 : T = youngTableau(new Partition from {6,6,5,3,1})|
|                                                     |
|     ┌───┬───┬───┬───┬───┬───┐                       |
|o1 = │   │   │   │   │   │   │                       |
|     ├───┼───┼───┼───┼───┼───┤                       |
|     │   │   │   │   │   │   │                       |
|     ├───┼───┼───┼───┼───┼───┘                       |
|     │   │   │   │   │   │                           |
|     ├───┼───┼───┼───┴───┘                           |
|     │   │   │   │                                   |
|     ├───┼───┴───┘                                   |
|     │   │                                           |
|     └───┘                                           |
|                                                     |
|o1 : YoungTableau                                    |
+-----------------------------------------------------+
|i2 : shift T                                         |
|                                                     |
|     ┌───┬───┬───┬───┬───┬───┐                       |
|o2 = │   │   │   │   │   │   │                       |
|     └───┼───┼───┼───┼───┼───┼───┐                   |
|         │   │   │   │   │   │   │                   |
|         └───┼───┼───┼───┼───┼───┤                   |
|             │   │   │   │   │   │                   |
|             └───┼───┼───┼───┼───┘                   |
|                 │   │   │   │                       |
|                 └───┼───┼───┘                       |
|                     │   │                           |
|                     └───┘                           |
|                                                     |
|o2 : YoungTableau                                    |
+-----------------------------------------------------+
|i3 : shift(T,2)                                      |
|                                                     |
|             ┌───┬───┬───┬───┬───┬───┐               |
|o3 =         │   │   │   │   │   │   │               |
|             └───┼───┼───┼───┼───┼───┼───┐           |
|                 │   │   │   │   │   │   │           |
|                 └───┼───┼───┼───┼───┼───┤           |
|                     │   │   │   │   │   │           |
|                     └───┼───┼───┼───┼───┘           |
|                         │   │   │   │               |
|                         └───┼───┼───┘               |
|                             │   │                   |
|                             └───┘                   |
|                                                     |
|o3 : YoungTableau                                    |
+-----------------------------------------------------+

See also
========

  * unshift -- unshift a tableau

Ways to use shift:
==================

  * "shift(YoungTableau)"
  * "shift(YoungTableau,ZZ)"

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

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

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

The source of this document is in Tableaux/documentation.m2:1229:0.

size(YoungTableau) -- the number of boxes in a tableau
******************************************************

  * Function: size (Macaulay2Doc),
  * Usage:
        size T
  * Inputs:
      * T, an instance of the type YoungTableau, a skew
        Tableau.
  * Outputs:
      * n, an integer (Macaulay2Doc), the number of boxes in T.

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

+---------------------------------------------------+
|i1 : T = youngTableau(new Partition from {4,3,1,0})|
|                                                   |
|     ┌───┬───┬───┬───┐                             |
|o1 = │   │   │   │   │                             |
|     ├───┼───┼───┼───┘                             |
|     │   │   │   │                                 |
|     ├───┼───┴───┘                                 |
|     │   │                                         |
|     └───┘                                         |
|                                                   |
|o1 : YoungTableau                                  |
+---------------------------------------------------+
|i2 : size T                                        |
|                                                   |
|o2 = 8                                             |
+---------------------------------------------------+

See also
========

  * entries(YoungTableau) -- the filling of a
    tableau

Ways to use this method:
========================

  * size(YoungTableau) -- the number of boxes in
    a tableau
-------------------------------------------------------------------------------

The source of this document is in Tableaux/documentation.m2:1747:0.

skewShape -- the shape of a skew tableau
****************************************

  * Usage:
        (lam,mu) = skewShape T
  * Inputs:
      * T, an instance of the type YoungTableau, a skew
        tableau.
  * Outputs:
      * lam, an instance of the type Partition (Macaulay2Doc),
        the outer shape, $\lambda$, of T.
      * mu, an instance of the type Partition (Macaulay2Doc),
        the inner shape, $\mu$, of T.

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

This returns the original shape used to construct the tableau.

+-----------------------------------------------------------------------------+
|i1 : T = youngTableau(new Partition from {4,3,1,0}, new Partition from {2,1},|
|                                                                             |
|             ┌───┬───┐                                                       |
|o1 =         │ 1 │ 2 │                                                       |
|         ┌───┼───┼───┘                                                       |
|         │ 3 │ 4 │                                                           |
|     ┌───┼───┴───┘                                                           |
|     │ 5 │                                                                   |
|     └───┘                                                                   |
|                                                                             |
|o1 : YoungTableau                                                            |
|-----------------------------------------------------------------------------|
|{1,2,3,4,5})                                                                 |
+-----------------------------------------------------------------------------+
|i2 : skewShape T                                                             |
|                                                                             |
|o2 = (Partition{4, 3, 1, 0}, Partition{2, 1})                                |
|                                                                             |
|o2 : Sequence                                                                |
+-----------------------------------------------------------------------------+

It may be convenient to remove trailing $0$'s from the partitions by using trim
on a sequence of two partitions.

+------------------------------------------+
|i3 : trim skewShape T                     |
|                                          |
|o3 = (Partition{4, 3, 1}, Partition{2, 1})|
|                                          |
|o3 : Sequence                             |
+------------------------------------------+

It may also be useful to append $0$s to make the partitions have the same
number of parts.

+-------------------------------------------------------------+
|i4 : (lam',mu') = pad skewShape T                            |
|                                                             |
|o4 = (Partition{4, 3, 1, 0}, Partition{2, 1, 0, 0})          |
|                                                             |
|o4 : Sequence                                                |
+-------------------------------------------------------------+
|i5 : rowLengths' = for i from 0 to #lam'-1 list(lam'#i-mu'#i)|
|                                                             |
|o5 = {2, 2, 1, 0}                                            |
|                                                             |
|o5 : List                                                    |
+-------------------------------------------------------------+

You may also 'standardize' a skew shape to return a pair of partitions of equal
length, without extra $0$'s. I.e., one of the resulting partitions will end
with a nonzero part, and the other will be padded with $0$'s.

+---------------------------------------------------------------+
|i6 : (lam'',mu'') = standardize skewShape T                    |
|                                                               |
|o6 = (Partition{4, 3, 1}, Partition{2, 1, 0})                  |
|                                                               |
|o6 : Sequence                                                  |
+---------------------------------------------------------------+
|i7 : rowLengths = for i from 0 to #lam''-1 list(lam''#i-mu''#i)|
|                                                               |
|o7 = {2, 2, 1}                                                 |
|                                                               |
|o7 : List                                                      |
+---------------------------------------------------------------+

See also
========

  * shape -- the shape of a Young tableau
  * standardize -- standardize the lengths of a pair of
    partitions

Ways to use skewShape:
======================

  * "skewShape(YoungTableau)"

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

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

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

The source of this document is in Tableaux/documentation.m2:1273:0.

standardize -- standardize the lengths of a pair of partitions
**************************************************************

  * Usage:
        (lam',mu') = standardize (lam,mu)
  * Inputs:
      * lam, an instance of the type Partition (Macaulay2Doc),
        a partition.
      * mu, an instance of the type Partition (Macaulay2Doc),
        a partition.
  * Outputs:
      * lam', an instance of the type Partition (Macaulay2Doc),
        a partition obtained from lam, with trailing
        zeros added or removed.
      * mu', an instance of the type Partition (Macaulay2Doc),
        a partition obtained from mu, with trailing zeros added or removed.
  * Consequences:
      * Partitions lam' and mu' have the same number of parts, possibly with
        trailing 0s.

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

A tableau T of shape $\lambda/\mu$ may be constructed with
$\ell(\lambda)\neq\ell(\mu)$. It is common to iterate over the rows of T, and
it is convenient to append trailing 0s to the shorter partition. This method
effectively removes all trailing 0s from both shapes, then appends 0s to the
shorter shape until they have the same length.

+-----------------------------------------------------------------------------+
|i1 : T = youngTableau(new Partition from {4,3,1,0}, new Partition from {2,1})|
|                                                                             |
|             ┌───┬───┐                                                       |
|o1 =         │   │   │                                                       |
|         ┌───┼───┼───┘                                                       |
|         │   │   │                                                           |
|     ┌───┼───┴───┘                                                           |
|     │   │                                                                   |
|     └───┘                                                                   |
|                                                                             |
|o1 : YoungTableau                                                            |
+-----------------------------------------------------------------------------+
|i2 : skewShape T                                                             |
|                                                                             |
|o2 = (Partition{4, 3, 1, 0}, Partition{2, 1})                                |
|                                                                             |
|o2 : Sequence                                                                |
+-----------------------------------------------------------------------------+
|i3 : standardize skewShape T                                                 |
|                                                                             |
|o3 = (Partition{4, 3, 1}, Partition{2, 1, 0})                                |
|                                                                             |
|o3 : Sequence                                                                |
+-----------------------------------------------------------------------------+

See also
========

  * skewShape -- the shape of a skew tableau
  * shape -- the shape of a Young tableau

Ways to use standardize:
========================

  * "standardize(Partition,Partition)"

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

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

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

The source of this document is in Tableaux/documentation.m2:1309:0.

Tabloid -- a type of HashTable representing a Young tabloid
***********************************************************

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

An object of type Tabloid is a subclass of type YoungTableau.
A tabloid represents an equivalence class of Young tableaux,
with entries in $\{1,\ldots,n\}$. Two tabloids are equal if they have the same
shape, and each corresponding row contains the same boxes, up to some
permutation. Hence, rows are drawn without dividing boxes.

+-------------------------------------+
|i1 : lam = new Partition from {4,3,2}|
|                                     |
|o1 = Partition{4, 3, 2}              |
|                                     |
|o1 : Partition                       |
+-------------------------------------+
|i2 : mu = new Partition from {3,1}   |
|                                     |
|o2 = Partition{3, 1}                 |
|                                     |
|o2 : Partition                       |
+-------------------------------------+
|i3 : T = tabloid(lam,mu,{1,2,5,3,4}) |
|                                     |
|                 ┌───┐               |
|o3 =             │ 1 │               |
|         ┌───────┼───┘               |
|         │ 2   5 │                   |
|     ┌───┴───┬───┘                   |
|     │ 3   4 │                       |
|     └───────┘                       |
|                                     |
|o3 : Tabloid                         |
+-------------------------------------+
|i4 : T' = tabloid(lam,mu,{1,5,2,3,4})|
|                                     |
|                 ┌───┐               |
|o4 =             │ 1 │               |
|         ┌───────┼───┘               |
|         │ 5   2 │                   |
|     ┌───┴───┬───┘                   |
|     │ 3   4 │                       |
|     └───────┘                       |
|                                     |
|o4 : Tabloid                         |
+-------------------------------------+
|i5 : T == T'                         |
|                                     |
|o5 = true                            |
+-------------------------------------+

See also
========

  * tabloid -- constructor for type Tabloid

Functions and methods returning an object of class Tabloid:
===========================================================

  * randomTabloid -- get a random tabloid
  * representative -- get a canonical representative of
    a tabloid
  * tabloid -- constructor for type Tabloid

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

  * "representative(Tabloid)" -- see representative, --
    get a canonical representative of a tabloid
  * Tabloid == Tabloid -- check if two tabloids are
    equal
  * toList(Tabloid) -- list representation of a
    tabloid
  * "youngTableau(Tabloid)" -- see youngTableau, --
    constructor for type YoungTableau

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

The object Tabloid, is a type (Macaulay2Doc), with
ancestor classes YoungTableau, < HashTable (Macaulay2Doc)
< Thing (Macaulay2Doc).

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

The source of this document is in Tableaux/documentation.m2:70:0.

tabloid -- constructor for type Tabloid
***************************************

  * Usage:
        tabloid(lam, mu, entryList)
        tabloid((lam,mu),entryList)
  * Inputs:
      * lam, an instance of the type Partition (Macaulay2Doc),
        the outer shape $\lambda$.
      * mu, an instance of the type Partition (Macaulay2Doc),
        the inner shape $\mu$. If not given, then it is assumed to be the $0$
        partition.
      * entryList, a list (Macaulay2Doc), the filling of the boxes.
  * Outputs:
      * T, an instance of the type Tabloid, a tabloid of shape
        $\lambda/\mu$ with the given filling.
  * Consequences:
      * The list of entries has length equal to
        $\sum_{i=1}^{\ell(\lambda)}|\lambda_i-\mu_i|$. E.g., if $\lambda=(2)$
        and $\mu=(5)$, then the entry list must have length $3$.
      * The entries are $\{1,\ldots,N\}$, where $N$ is the number of boxes.

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

+-------------------------------------+
|i1 : lam = new Partition from {4,3,2}|
|                                     |
|o1 = Partition{4, 3, 2}              |
|                                     |
|o1 : Partition                       |
+-------------------------------------+
|i2 : mu = new Partition from {3,1}   |
|                                     |
|o2 = Partition{3, 1}                 |
|                                     |
|o2 : Partition                       |
+-------------------------------------+
|i3 : entryList = {1,4,2,3,5}         |
|                                     |
|o3 = {1, 4, 2, 3, 5}                 |
|                                     |
|o3 : List                            |
+-------------------------------------+
|i4 : T = tabloid(lam,mu,entryList)   |
|                                     |
|                 ┌───┐               |
|o4 =             │ 1 │               |
|         ┌───────┼───┘               |
|         │ 4   2 │                   |
|     ┌───┴───┬───┘                   |
|     │ 3   5 │                       |
|     └───────┘                       |
|                                     |
|o4 : Tabloid                         |
+-------------------------------------+

See also
========

  * Tabloid -- a type of HashTable representing a Young tabloid
  * YoungTableau -- a type of HashTable representing a
    Young tableau

Ways to use tabloid:
====================

  * "tabloid(Partition,List)"
  * "tabloid(Partition,Partition,List)"
  * "tabloid(Sequence,List)"
  * "tabloid(YoungTableau)"

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

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

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

The source of this document is in Tableaux/documentation.m2:1348:0.

Tabloid == Tabloid -- check if two tabloids are equal
*****************************************************

  * Operator: == (Macaulay2Doc),
  * Usage:
        T1 == T2
  * Inputs:
      * T1, an instance of the type Tabloid, a tabloid.
      * T2, an instance of the type Tabloid, a tabloid.
  * Outputs:
      * b, a Boolean value (Macaulay2Doc), whether the tabloids
        are equal or not.

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

Two tabloids are equal if they have the same representative. That is, if their
corresponding rows contain the same numbers.

+-----------------------------------------------------------------------------+
|i1 : T1 = tabloid(new Partition from {5,3,1}, new Partition from {2},        |
|                                                                             |
|             ┌───────────┐                                                   |
|o1 =         │ 7   2   4 │                                                   |
|     ┌───────┴───┬───────┘                                                   |
|     │ 1   3   6 │                                                           |
|     ├───┬───────┘                                                           |
|     │ 5 │                                                                   |
|     └───┘                                                                   |
|                                                                             |
|o1 : Tabloid                                                                 |
|-----------------------------------------------------------------------------|
|{7,2,4,1,3,6,5})                                                             |
+-----------------------------------------------------------------------------+
|i2 : T2 = tabloid(new Partition from {5,3,1}, new Partition from {2},        |
|                                                                             |
|             ┌───────────┐                                                   |
|o2 =         │ 2   7   4 │                                                   |
|     ┌───────┴───┬───────┘                                                   |
|     │ 3   6   1 │                                                           |
|     ├───┬───────┘                                                           |
|     │ 5 │                                                                   |
|     └───┘                                                                   |
|                                                                             |
|o2 : Tabloid                                                                 |
|-----------------------------------------------------------------------------|
|{2,7,4,3,6,1,5})                                                             |
+-----------------------------------------------------------------------------+
|i3 : T1 == T2                                                                |
|                                                                             |
|o3 = true                                                                    |
+-----------------------------------------------------------------------------+

Ways to use this method:
========================

  * Tabloid == Tabloid -- check if two tabloids are
    equal
-------------------------------------------------------------------------------

The source of this document is in Tableaux/documentation.m2:1772:0.

tex(YoungTableau) -- LaTeX output for a tableau
***********************************************

  * Function: tex (Macaulay2Doc),
  * Usage:
        tex T
  * Inputs:
      * T, an instance of the type YoungTableau, a
        tableau.
  * Outputs:
      * s, a string (Macaulay2Doc), the LaTeX code for
        reproducting the given tableau.

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

The LaTeX code uses commands from the LaTeX package aTableau (see
https://github.com/AndrewMathas/aTableau ).

+-----------------------------------------------------------------------------+
|i1 : T = youngTableau(new Partition from {4,3,1}, new Partition from {2,1},  |
|                                                                             |
|             ┌───┬───┐                                                       |
|o1 =         │ 1 │ 2 │                                                       |
|         ┌───┼───┼───┘                                                       |
|         │ 3 │ 4 │                                                           |
|     ┌───┼───┴───┘                                                           |
|     │ 5 │                                                                   |
|     └───┘                                                                   |
|                                                                             |
|o1 : YoungTableau                                                            |
|-----------------------------------------------------------------------------|
|{1,2,3,4,5})                                                                 |
+-----------------------------------------------------------------------------+
|i2 : tex T                                                                   |
|                                                                             |
|o2 = \SkewTableau[skew border, skew boxes]{2, 1, 0}{12, 34, 5}               |
+-----------------------------------------------------------------------------+
|i3 : T' = tabloid T                                                          |
|                                                                             |
|             ┌───────┐                                                       |
|o3 =         │ 1   2 │                                                       |
|         ┌───┴───┬───┘                                                       |
|         │ 3   4 │                                                           |
|     ┌───┼───────┘                                                           |
|     │ 5 │                                                                   |
|     └───┘                                                                   |
|                                                                             |
|o3 : Tabloid                                                                 |
+-----------------------------------------------------------------------------+
|i4 : tex T'                                                                  |
|                                                                             |
|o4 = \Tabloid[skew={2, 1, 0}]{12, 34, 5}                                     |
+-----------------------------------------------------------------------------+

See also
========

  * youngTableau -- constructor for type YoungTableau
  * youngDiagram -- a net of the Young diagram
  * ferrersDiagram -- a net of the Ferrers diagram

Ways to use this method:
========================

  * tex(YoungTableau) -- LaTeX output for a
    tableau
-------------------------------------------------------------------------------

The source of this document is in Tableaux/documentation.m2:1799:0.

toIndex -- get the index of a box, given its position
*****************************************************

  * Usage:
        toIndex(T,seq)
        toIndex(T,(i,j))
        toIndex(seq,T)
        toIndex((i,j),T)
  * Inputs:
      * T, an instance of the type YoungTableau, a
        tableau.
      * seq, a sequence (Macaulay2Doc), the position (i,j) of a
        box.
  * Outputs:
      * k, an integer (Macaulay2Doc), the index k of the box in T.

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

The boxes in entries T fill the tableau from top to bottom, and left to right.
Hence, a position (i,j) corresponds to an index k in entries T

+-----------------------------------------------------------------------------+
|i1 : T = youngTableau(new Partition from {6,3,2}, new Partition from {2},    |
|                                                                             |
|               ┌────┬────┬────┬────┐                                         |
|o1 =           │ 10 │ 11 │ 12 │ 13 │                                         |
|     ┌────┬────┼────┼────┴────┴────┘                                         |
|     │ 14 │ 15 │ 16 │                                                        |
|     ├────┼────┼────┘                                                        |
|     │ 17 │ 18 │                                                             |
|     └────┴────┘                                                             |
|                                                                             |
|o1 : YoungTableau                                                            |
|-----------------------------------------------------------------------------|
|toList(10..18))                                                              |
+-----------------------------------------------------------------------------+
|i2 : thePosition = (1,2)                                                     |
|                                                                             |
|o2 = (1, 2)                                                                  |
|                                                                             |
|o2 : Sequence                                                                |
+-----------------------------------------------------------------------------+
|i3 : T_thePosition                                                           |
|                                                                             |
|o3 = 16                                                                      |
+-----------------------------------------------------------------------------+
|i4 : theIndex = toIndex(T,thePosition)                                       |
|                                                                             |
|o4 = 6                                                                       |
+-----------------------------------------------------------------------------+
|i5 : (entries T)#theIndex                                                    |
|                                                                             |
|o5 = 16                                                                      |
+-----------------------------------------------------------------------------+

We may replace the filling in each box with its index to see the order.

+-----------------------------------------------------------------------------+
|i6 : youngTableau(new Partition from {6,3,2}, new Partition from {2},        |
|                                                                             |
|             ┌───┬───┬───┬───┐                                               |
|o6 =         │ 0 │ 1 │ 2 │ 3 │                                               |
|     ┌───┬───┼───┼───┴───┴───┘                                               |
|     │ 4 │ 5 │ 6 │                                                           |
|     ├───┼───┼───┘                                                           |
|     │ 7 │ 8 │                                                               |
|     └───┴───┘                                                               |
|                                                                             |
|o6 : YoungTableau                                                            |
|-----------------------------------------------------------------------------|
|toList(0..(size T - 1)))                                                     |
+-----------------------------------------------------------------------------+

We may also replace the filling in each box with the corresponding position.

+-----------------------------------------------------------------------------+
|i7 : entryList = for i from 0 to size T - 1 list toPosition(T,i)             |
|                                                                             |
|o7 = {(0, 2), (0, 3), (0, 4), (0, 5), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1)}|
|                                                                             |
|o7 : List                                                                    |
+-----------------------------------------------------------------------------+
|i8 : youngTableau(new Partition from {6,3,2}, new Partition from {2},        |
|                                                                             |
|                       ┌────────┬────────┬────────┬────────┐                 |
|o8 =                   │ (0, 2) │ (0, 3) │ (0, 4) │ (0, 5) │                 |
|     ┌────────┬────────┼────────┼────────┴────────┴────────┘                 |
|     │ (1, 0) │ (1, 1) │ (1, 2) │                                            |
|     ├────────┼────────┼────────┘                                            |
|     │ (2, 0) │ (2, 1) │                                                     |
|     └────────┴────────┘                                                     |
|                                                                             |
|o8 : YoungTableau                                                            |
|-----------------------------------------------------------------------------|
|entryList)                                                                   |
+-----------------------------------------------------------------------------+

See also
========

  * toPosition -- get the position of a box, given its index
  * positionList -- get the positions of all the boxes in
    a tableau

Ways to use toIndex:
====================

  * "toIndex(Sequence,YoungTableau)"
  * "toIndex(YoungTableau,Sequence)"

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

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

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

The source of this document is in Tableaux/documentation.m2:1392:0.

toList(Tabloid) -- list representation of a tabloid
***************************************************

  * Function: toList (Macaulay2Doc),
  * Usage:
        toList T
  * Inputs:
      * T, an instance of the type Tabloid, a tabloid.
  * Outputs:
      * l, a bag (Macaulay2Doc), a bagged list of all Young tableaux
        in the equivalence class T.

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

+-----------------------------------------------------------------------------+
|i1 : T = tabloid(new Partition from {3,1}, {1,2,3,4})                        |
|                                                                             |
|     ┌───────────┐                                                           |
|o1 = │ 1   2   3 │                                                           |
|     ├───┬───────┘                                                           |
|     │ 4 │                                                                   |
|     └───┘                                                                   |
|                                                                             |
|o1 : Tabloid                                                                 |
+-----------------------------------------------------------------------------+
|i2 : listT = toList T                                                        |
|                                                                             |
|o2 = -*a bagged sequence of length 6*-                                       |
|                                                                             |
|o2 : Bag                                                                     |
+-----------------------------------------------------------------------------+
|i3 : peek listT                                                              |
|                                                                             |
|         ┌───┬───┬───┐  ┌───┬───┬───┐  ┌───┬───┬───┐  ┌───┬───┬───┐          |
|o3 = Bag{│ 1 │ 2 │ 3 │, │ 1 │ 3 │ 2 │, │ 2 │ 1 │ 3 │, │ 2 │ 3 │ 1 │,         |
|         ├───┼───┴───┘  ├───┼───┴───┘  ├───┼───┴───┘  ├───┼───┴───┘          |
|         │ 4 │          │ 4 │          │ 4 │          │ 4 │                  |
|         └───┘          └───┘          └───┘          └───┘                  |
|-----------------------------------------------------------------------------|
|┌───┬───┬───┐  ┌───┬───┬───┐                                                 |
|│ 3 │ 1 │ 2 │, │ 3 │ 2 │ 1 │}                                                |
|├───┼───┴───┘  ├───┼───┴───┘                                                 |
|│ 4 │          │ 4 │                                                         |
|└───┘          └───┘                                                         |
+-----------------------------------------------------------------------------+

Ways to use this method:
========================

  * toList(Tabloid) -- list representation of a
    tabloid
-------------------------------------------------------------------------------

The source of this document is in Tableaux/documentation.m2:1819:0.

toPartitionChain -- decompose a tableau into a chain of partitions
******************************************************************

  * Usage:
        toPartitionChain T
  * Inputs:
      * T, an instance of the type YoungTableau, a
        tableau.
  * Outputs:
      * s, a sequence (Macaulay2Doc), a sequence of partitions.

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

A (semistandard) Young tableau of shape $\lambda/\mu$ determines (and is
determined by) a sequence of partitions $(\lambda^{(0)},\ldots,\lambda^{(r)})$,
where $\mu= \lambda^{(0)}\subseteq\lambda^{(1)}\subseteq\cdots\subseteq\lambda
^{(r)}=\lambda$.

+-----------------------------------------------------------------------------+
|i1 : lam = new Partition from {6,6,5,3,2,2,2,1}                              |
|                                                                             |
|o1 = Partition{6, 6, 5, 3, 2, 2, 2, 1}                                       |
|                                                                             |
|o1 : Partition                                                               |
+-----------------------------------------------------------------------------+
|i2 : mu = new Partition from {3,1}                                           |
|                                                                             |
|o2 = Partition{3, 1}                                                         |
|                                                                             |
|o2 : Partition                                                               |
+-----------------------------------------------------------------------------+
|i3 : entryList = {1,1,7,1,3,4,4,8,1,2,4,7,7,2,3,5,3,4,4,5,5,6,8}             |
|                                                                             |
|o3 = {1, 1, 7, 1, 3, 4, 4, 8, 1, 2, 4, 7, 7, 2, 3, 5, 3, 4, 4, 5, 5, 6, 8}   |
|                                                                             |
|o3 : List                                                                    |
+-----------------------------------------------------------------------------+
|i4 : T = youngTableau(lam,mu,entryList)                                      |
|                                                                             |
|                 ┌───┬───┬───┐                                               |
|o4 =             │ 1 │ 1 │ 7 │                                               |
|         ┌───┬───┼───┼───┼───┤                                               |
|         │ 1 │ 3 │ 4 │ 4 │ 8 │                                               |
|     ┌───┼───┼───┼───┼───┼───┘                                               |
|     │ 1 │ 2 │ 4 │ 7 │ 7 │                                                   |
|     ├───┼───┼───┼───┴───┘                                                   |
|     │ 2 │ 3 │ 5 │                                                           |
|     ├───┼───┼───┘                                                           |
|     │ 3 │ 4 │                                                               |
|     ├───┼───┤                                                               |
|     │ 4 │ 5 │                                                               |
|     ├───┼───┤                                                               |
|     │ 5 │ 6 │                                                               |
|     ├───┼───┘                                                               |
|     │ 8 │                                                                   |
|     └───┘                                                                   |
|                                                                             |
|o4 : YoungTableau                                                            |
+-----------------------------------------------------------------------------+
|i5 : theDecomp = toPartitionChain T                                          |
|                                                                             |
|o5 = (Partition{3, 1, 0, 0, 0, 0, 0, 0}, Partition{5, 2, 1, 0, 0, 0, 0, 0},  |
|     ------------------------------------------------------------------------|
|     Partition{5, 2, 2, 1, 0, 0, 0, 0}, Partition{5, 3, 2, 2, 1, 0, 0, 0},   |
|     ------------------------------------------------------------------------|
|     Partition{5, 5, 3, 2, 2, 1, 0, 0}, Partition{5, 5, 3, 3, 2, 2, 1, 0},   |
|     ------------------------------------------------------------------------|
|     Partition{5, 5, 3, 3, 2, 2, 2, 0}, Partition{6, 5, 5, 3, 2, 2, 2, 0},   |
|     ------------------------------------------------------------------------|
|     Partition{6, 6, 5, 3, 2, 2, 2, 1})                                      |
|                                                                             |
|o5 : Sequence                                                                |
+-----------------------------------------------------------------------------+

This chain has the property that each $\lambda^{(i)}/\lambda^{(i-1)}$ is a
horizontal strip.

+-----------------------------------------------------------------------------+
|i6 : drawInnerShape true                                                     |
|                                                                             |
|o6 = true                                                                    |
+-----------------------------------------------------------------------------+
|i7 : for i from 1 to #theDecomp-1 do (                                       |
|         print(toString(toSequence trim theDecomp#i)|"/"|toString(toSequence |
|         print youngTableau(theDecomp#i,theDecomp#(i-1));                    |
|         )                                                                   |
|(5,2,1)/(3,1):                                                               |
|            ┌───┬───┐                                                        |
|  ■   ■   ■ │   │   │                                                        |
|    ┌───┐   └───┴───┘                                                        |
|  ■ │   │                                                                    |
|┌───┼───┘                                                                    |
|│   │                                                                        |
|└───┘                                                                        |
|(5,2,2,1)/(5,2,1):                                                           |
|                                                                             |
|  ■   ■   ■   ■   ■                                                          |
|                                                                             |
|  ■   ■                                                                      |
|    ┌───┐                                                                    |
|  ■ │   │                                                                    |
|┌───┼───┘                                                                    |
|│   │                                                                        |
|└───┘                                                                        |
|(5,3,2,2,1)/(5,2,2,1):                                                       |
|                                                                             |
|  ■   ■   ■   ■   ■                                                          |
|        ┌───┐                                                                |
|  ■   ■ │   │                                                                |
|        └───┘                                                                |
|  ■   ■                                                                      |
|    ┌───┐                                                                    |
|  ■ │   │                                                                    |
|┌───┼───┘                                                                    |
|│   │                                                                        |
|└───┘                                                                        |
|(5,5,3,2,2,1)/(5,3,2,2,1):                                                   |
|                                                                             |
|  ■   ■   ■   ■   ■                                                          |
|            ┌───┬───┐                                                        |
|  ■   ■   ■ │   │   │                                                        |
|        ┌───┼───┴───┘                                                        |
|  ■   ■ │   │                                                                |
|        └───┘                                                                |
|  ■   ■                                                                      |
|    ┌───┐                                                                    |
|  ■ │   │                                                                    |
|┌───┼───┘                                                                    |
|│   │                                                                        |
|└───┘                                                                        |
|(5,5,3,3,2,2,1)/(5,5,3,2,2,1):                                               |
|                                                                             |
|  ■   ■   ■   ■   ■                                                          |
|                                                                             |
|  ■   ■   ■   ■   ■                                                          |
|                                                                             |
|  ■   ■   ■                                                                  |
|        ┌───┐                                                                |
|  ■   ■ │   │                                                                |
|        └───┘                                                                |
|  ■   ■                                                                      |
|    ┌───┐                                                                    |
|  ■ │   │                                                                    |
|┌───┼───┘                                                                    |
|│   │                                                                        |
|└───┘                                                                        |
|(5,5,3,3,2,2,2)/(5,5,3,3,2,2,1):                                             |
|                                                                             |
|  ■   ■   ■   ■   ■                                                          |
|                                                                             |
|  ■   ■   ■   ■   ■                                                          |
|                                                                             |
|  ■   ■   ■                                                                  |
|                                                                             |
|  ■   ■   ■                                                                  |
|                                                                             |
|  ■   ■                                                                      |
|                                                                             |
|  ■   ■                                                                      |
|    ┌───┐                                                                    |
|  ■ │   │                                                                    |
|    └───┘                                                                    |
|(6,5,5,3,2,2,2)/(5,5,3,3,2,2,2):                                             |
|                    ┌───┐                                                    |
|  ■   ■   ■   ■   ■ │   │                                                    |
|                    └───┘                                                    |
|  ■   ■   ■   ■   ■                                                          |
|            ┌───┬───┐                                                        |
|  ■   ■   ■ │   │   │                                                        |
|            └───┴───┘                                                        |
|  ■   ■   ■                                                                  |
|                                                                             |
|  ■   ■                                                                      |
|                                                                             |
|  ■   ■                                                                      |
|                                                                             |
|  ■   ■                                                                      |
|                                                                             |
|(6,6,5,3,2,2,2,1)/(6,5,5,3,2,2,2):                                           |
|                                                                             |
|  ■   ■   ■   ■   ■   ■                                                      |
|                    ┌───┐                                                    |
|  ■   ■   ■   ■   ■ │   │                                                    |
|                    └───┘                                                    |
|  ■   ■   ■   ■   ■                                                          |
|                                                                             |
|  ■   ■   ■                                                                  |
|                                                                             |
|  ■   ■                                                                      |
|                                                                             |
|  ■   ■                                                                      |
|                                                                             |
|  ■   ■                                                                      |
|┌───┐                                                                        |
|│   │                                                                        |
|└───┘                                                                        |
|-----------------------------------------------------------------------------|
|trim theDecomp#(i-1))|":");                                                  |
+-----------------------------------------------------------------------------+

Ways to use toPartitionChain:
=============================

  * "toPartitionChain(YoungTableau)"

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

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

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

The source of this document is in Tableaux/documentation.m2:434:0.

toPosition -- get the position of a box, given its index
********************************************************

  * Usage:
        toPosition(T,k)
        toPosition(k,T)
  * Inputs:
      * T, an instance of the type YoungTableau, a
        tableau.
      * k, an integer (Macaulay2Doc), the index of a box.
  * Outputs:
      * l, a sequence (Macaulay2Doc), the position (i,j) of the
        box in T.

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

The boxes in entries T fill the tableau from top to bottom, and left to right.
Hence, an index in entries T corresponds to a position (i,j).

+-----------------------------------------------------------------------------+
|i1 : T = youngTableau(new Partition from {6,3,2}, new Partition from {2},    |
|                                                                             |
|               ┌────┬────┬────┬────┐                                         |
|o1 =           │ 10 │ 11 │ 12 │ 13 │                                         |
|     ┌────┬────┼────┼────┴────┴────┘                                         |
|     │ 14 │ 15 │ 16 │                                                        |
|     ├────┼────┼────┘                                                        |
|     │ 17 │ 18 │                                                             |
|     └────┴────┘                                                             |
|                                                                             |
|o1 : YoungTableau                                                            |
|-----------------------------------------------------------------------------|
|toList(10..18))                                                              |
+-----------------------------------------------------------------------------+
|i2 : (entries T)#5                                                           |
|                                                                             |
|o2 = 15                                                                      |
+-----------------------------------------------------------------------------+
|i3 : toPosition(T,5)                                                         |
|                                                                             |
|o3 = (1, 1)                                                                  |
|                                                                             |
|o3 : Sequence                                                                |
+-----------------------------------------------------------------------------+

We may replace the filling in each box with its index to see the order.

+-----------------------------------------------------------------------------+
|i4 : youngTableau(new Partition from {6,3,2}, new Partition from {2},        |
|                                                                             |
|             ┌───┬───┬───┬───┐                                               |
|o4 =         │ 0 │ 1 │ 2 │ 3 │                                               |
|     ┌───┬───┼───┼───┴───┴───┘                                               |
|     │ 4 │ 5 │ 6 │                                                           |
|     ├───┼───┼───┘                                                           |
|     │ 7 │ 8 │                                                               |
|     └───┴───┘                                                               |
|                                                                             |
|o4 : YoungTableau                                                            |
|-----------------------------------------------------------------------------|
|toList(0..(size T - 1)))                                                     |
+-----------------------------------------------------------------------------+

We may also replace the filling in each box with the corresponding position.

+-----------------------------------------------------------------------------+
|i5 : entryList = for i from 0 to size T - 1 list toPosition(T,i)             |
|                                                                             |
|o5 = {(0, 2), (0, 3), (0, 4), (0, 5), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1)}|
|                                                                             |
|o5 : List                                                                    |
+-----------------------------------------------------------------------------+
|i6 : youngTableau(new Partition from {6,3,2}, new Partition from {2},        |
|                                                                             |
|                       ┌────────┬────────┬────────┬────────┐                 |
|o6 =                   │ (0, 2) │ (0, 3) │ (0, 4) │ (0, 5) │                 |
|     ┌────────┬────────┼────────┼────────┴────────┴────────┘                 |
|     │ (1, 0) │ (1, 1) │ (1, 2) │                                            |
|     ├────────┼────────┼────────┘                                            |
|     │ (2, 0) │ (2, 1) │                                                     |
|     └────────┴────────┘                                                     |
|                                                                             |
|o6 : YoungTableau                                                            |
|-----------------------------------------------------------------------------|
|entryList)                                                                   |
+-----------------------------------------------------------------------------+

See also
========

  * toIndex -- get the index of a box, given its position
  * positionList -- get the positions of all the boxes in
    a tableau

Ways to use toPosition:
=======================

  * "toPosition(YoungTableau,ZZ)"
  * "toPosition(ZZ,YoungTableau)"

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

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

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

The source of this document is in Tableaux/documentation.m2:1432:0.

unshift -- unshift a tableau
****************************

  * Usage:
        unshift T
        unshift(T,n)
  * Inputs:
      * T, an instance of the type YoungTableau, a skew
        tableau.
      * n, an integer (Macaulay2Doc), an additional amount to shift.
  * Outputs:
      * S, an instance of the type YoungTableau, each row
        i of T has been shifted by i + n to the left (where n=0 if not
        provided).

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

+-----------------------------------------------------+
|i1 : T = youngTableau(new Partition from {6,6,5,3,1})|
|                                                     |
|     ┌───┬───┬───┬───┬───┬───┐                       |
|o1 = │   │   │   │   │   │   │                       |
|     ├───┼───┼───┼───┼───┼───┤                       |
|     │   │   │   │   │   │   │                       |
|     ├───┼───┼───┼───┼───┼───┘                       |
|     │   │   │   │   │   │                           |
|     ├───┼───┼───┼───┴───┘                           |
|     │   │   │   │                                   |
|     ├───┼───┴───┘                                   |
|     │   │                                           |
|     └───┘                                           |
|                                                     |
|o1 : YoungTableau                                    |
+-----------------------------------------------------+
|i2 : T' = shift T                                    |
|                                                     |
|     ┌───┬───┬───┬───┬───┬───┐                       |
|o2 = │   │   │   │   │   │   │                       |
|     └───┼───┼───┼───┼───┼───┼───┐                   |
|         │   │   │   │   │   │   │                   |
|         └───┼───┼───┼───┼───┼───┤                   |
|             │   │   │   │   │   │                   |
|             └───┼───┼───┼───┼───┘                   |
|                 │   │   │   │                       |
|                 └───┼───┼───┘                       |
|                     │   │                           |
|                     └───┘                           |
|                                                     |
|o2 : YoungTableau                                    |
+-----------------------------------------------------+
|i3 : unshift T'                                      |
|                                                     |
|     ┌───┬───┬───┬───┬───┬───┐                       |
|o3 = │   │   │   │   │   │   │                       |
|     ├───┼───┼───┼───┼───┼───┤                       |
|     │   │   │   │   │   │   │                       |
|     ├───┼───┼───┼───┼───┼───┘                       |
|     │   │   │   │   │   │                           |
|     ├───┼───┼───┼───┴───┘                           |
|     │   │   │   │                                   |
|     ├───┼───┴───┘                                   |
|     │   │                                           |
|     └───┘                                           |
|                                                     |
|o3 : YoungTableau                                    |
+-----------------------------------------------------+

See also
========

  * shift -- shift a tableau

Ways to use unshift:
====================

  * "unshift(YoungTableau)"
  * "unshift(YoungTableau,ZZ)"

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

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

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

The source of this document is in Tableaux/documentation.m2:1459:0.

verticalConcatenate -- vertical concatenation of a list of tableaux
*******************************************************************

  * Usage:
        verticalConcatenate l
  * Inputs:
      * l, a list (Macaulay2Doc), a list of tableaux.
  * Outputs:
      * S, an instance of the type YoungTableau, a single
        tableau with combining those in the list.

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

+-----------------------------------------------------------------------------+
|i1 : T1 = youngTableau(new Partition from {5}, new Partition from {2})       |
|                                                                             |
|             ┌───┬───┬───┐                                                   |
|o1 =         │   │   │   │                                                   |
|             └───┴───┴───┘                                                   |
|                                                                             |
|o1 : YoungTableau                                                            |
+-----------------------------------------------------------------------------+
|i2 : T2 = youngTableau(new Partition from {3,2}, new Partition from {1},     |
|                                                                             |
|         ┌───┬───┐                                                           |
|o2 =     │ 1 │ 2 │                                                           |
|     ┌───┼───┼───┘                                                           |
|     │ 3 │ 4 │                                                               |
|     └───┴───┘                                                               |
|                                                                             |
|o2 : YoungTableau                                                            |
|-----------------------------------------------------------------------------|
|{1,2,3,4})                                                                   |
+-----------------------------------------------------------------------------+
|i3 : T3 = youngTableau(new Partition from {5,-3})                            |
|                                                                             |
|                 ║───┬───┬───┬───┬───┐                                       |
|o3 =             ║   │   │   │   │   │                                       |
|     ┌───┬───┬───║───┴───┴───┴───┴───┘                                       |
|     │░░ │░░ │░░ ║                                                           |
|     └───┴───┴───║                                                           |
|                                                                             |
|o3 : YoungTableau                                                            |
+-----------------------------------------------------------------------------+
|i4 : verticalConcatenate {T1,T2,T3}                                          |
|                                                                             |
|                 ║       ┌───┬───┬───┐                                       |
|o4 =             ║       │   │   │   │                                       |
|                 ║   ┌───┼───┼───┴───┘                                       |
|                 ║   │ 1 │ 2 │                                               |
|                 ║───┼───┼───┘                                               |
|                 ║ 3 │ 4 │                                                   |
|                 ║───┼───┼───┬───┬───┐                                       |
|                 ║   │   │   │   │   │                                       |
|     ┌───┬───┬───║───┴───┴───┴───┴───┘                                       |
|     │░░ │░░ │░░ ║                                                           |
|     └───┴───┴───║                                                           |
|                                                                             |
|o4 : YoungTableau                                                            |
+-----------------------------------------------------------------------------+

See also
========

  * YoungTableau || YoungTableau, --
    vertical concatenation of two tableaux

Ways to use verticalConcatenate:
================================

  * "verticalConcatenate(List)"

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

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

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

The source of this document is in Tableaux/documentation.m2:1483:0.

verticalNet -- multiple nets concatenated vertically
****************************************************

  * Usage:
        verticalNet L
  * Inputs:
      * L, a list (Macaulay2Doc), a list or sequence.
  * Outputs:
      * n, a net (Macaulay2Doc), a net of objects in L, stacked
        vertically and justified on the left.

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

If L is a list of objects $A_1,A_2,\ldots,A_n$, then this concatenates their
nets vertically. Note that this concatenates their nets into a single net,
whereas verticalConcatenate, concatenates the
tableaux themselves into a single tableau.

+-----------------------------------------------------------------------------+
|i1 : T1 = youngTableau(new Partition from {6,6,5,3,1}, new Partition from    |
|                                                                             |
|             ┌───┬───┬───┬───┐                                               |
|o1 =         │   │   │   │   │                                               |
|         ┌───┼───┼───┼───┼───┤                                               |
|         │   │   │   │   │   │                                               |
|         ├───┼───┼───┼───┼───┘                                               |
|         │   │   │   │   │                                                   |
|     ┌───┼───┼───┼───┴───┘                                                   |
|     │   │   │   │                                                           |
|     ├───┼───┴───┘                                                           |
|     │   │                                                                   |
|     └───┘                                                                   |
|                                                                             |
|o1 : YoungTableau                                                            |
|-----------------------------------------------------------------------------|
|{2,1,1})                                                                     |
+-----------------------------------------------------------------------------+
|i2 : T2 = youngTableau(new Partition from {3,1}, new Partition from {1},     |
|                                                                             |
|         ┌───┬───┐                                                           |
|o2 =     │ a │ b │                                                           |
|     ┌───┼───┴───┘                                                           |
|     │ c │                                                                   |
|     └───┘                                                                   |
|                                                                             |
|o2 : YoungTableau                                                            |
|-----------------------------------------------------------------------------|
|{"a","b","c"})                                                               |
+-----------------------------------------------------------------------------+
|i3 : verticalNet {T1, T2}                                                    |
|                                                                             |
|             ┌───┬───┬───┬───┐                                               |
|o3 =         │   │   │   │   │                                               |
|         ┌───┼───┼───┼───┼───┤                                               |
|         │   │   │   │   │   │                                               |
|         ├───┼───┼───┼───┼───┘                                               |
|         │   │   │   │   │                                                   |
|     ┌───┼───┼───┼───┴───┘                                                   |
|     │   │   │   │                                                           |
|     ├───┼───┴───┘                                                           |
|     │   │                                                                   |
|     └───┘                                                                   |
|         ┌───┬───┐                                                           |
|         │ a │ b │                                                           |
|     ┌───┼───┴───┘                                                           |
|     │ c │                                                                   |
|     └───┘                                                                   |
+-----------------------------------------------------------------------------+

See also
========

  * horizontalNet -- multiple nets concatenated
    horizontally

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

The object verticalNet, is a function closure (Macaulay2Doc).

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

The source of this document is in Tableaux/documentation.m2:1509:0.

youngDiagram -- a net of the Young diagram
******************************************

  * Usage:
        youngDiagram(lam, mu)
        youngDiagram T
  * Inputs:
      * lam, an instance of the type Partition (Macaulay2Doc),
        the outer shape $\lambda$.
      * mu, an instance of the type Partition (Macaulay2Doc),
        the inner shape $\mu$. If not given, if is assumed to be the $0$
        partition.
      * T, an instance of the type YoungTableau, a skew
        tableau.
  * Outputs:
      * n, a net (Macaulay2Doc), a representation of the Young
        diagram of shape $\lambda/\mu$.

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

+-----------------------------------------------------------------------------+
|i1 : T = youngTableau(new Partition from {4,3,1}, new Partition from {2,1},  |
|                                                                             |
|             ┌───┬───┐                                                       |
|o1 =         │ 1 │ 2 │                                                       |
|         ┌───┼───┼───┘                                                       |
|         │ 3 │ 4 │                                                           |
|     ┌───┼───┴───┘                                                           |
|     │ 5 │                                                                   |
|     └───┘                                                                   |
|                                                                             |
|o1 : YoungTableau                                                            |
|-----------------------------------------------------------------------------|
|{1,2,3,4,5})                                                                 |
+-----------------------------------------------------------------------------+
|i2 : youngDiagram T                                                          |
|                                                                             |
|             ┌───┬───┐                                                       |
|o2 =         │   │   │                                                       |
|         ┌───┼───┼───┘                                                       |
|         │   │   │                                                           |
|     ┌───┼───┴───┘                                                           |
|     │   │                                                                   |
|     └───┘                                                                   |
+-----------------------------------------------------------------------------+

See also
========

  * youngTableau -- constructor for type YoungTableau
  * ferrersDiagram -- a net of the Ferrers diagram

Ways to use youngDiagram:
=========================

  * "youngDiagram(Partition)"
  * "youngDiagram(Partition,Partition)"
  * "youngDiagram(YoungTableau)"

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

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

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

The source of this document is in Tableaux/documentation.m2:1539:0.

YoungTableau -- a type of HashTable representing a Young tableau
****************************************************************

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

An object of type YoungTableau is a hash table containing two shapes of type
Partition (Macaulay2Doc), and a list of box entries. The
entries may have any type, except for null (Macaulay2Doc), objects.

The inner and outer shapes, $\lambda$ and $\mu$ respectively, can be any
sequence of integers. In particular, it accepts negative parts, compositions,
rows where $\lambda_i < \mu_i$, and compositions where
$\ell(\lambda)\neq\ell(\mu)$.

+---------------------------------------+
|i1 : lam = new Partition from {4,3,2}  |
|                                       |
|o1 = Partition{4, 3, 2}                |
|                                       |
|o1 : Partition                         |
+---------------------------------------+
|i2 : mu = new Partition from {3,1}     |
|                                       |
|o2 = Partition{3, 1}                   |
|                                       |
|o2 : Partition                         |
+---------------------------------------+
|i3 : entryList = {1,2,3,3,9}           |
|                                       |
|o3 = {1, 2, 3, 3, 9}                   |
|                                       |
|o3 : List                              |
+---------------------------------------+
|i4 : T = youngTableau(lam,mu,entryList)|
|                                       |
|                 ┌───┐                 |
|o4 =             │ 1 │                 |
|         ┌───┬───┼───┘                 |
|         │ 2 │ 3 │                     |
|     ┌───┼───┼───┘                     |
|     │ 3 │ 9 │                         |
|     └───┴───┘                         |
|                                       |
|o4 : YoungTableau                      |
+---------------------------------------+

See also
========

  * youngTableau -- constructor for type YoungTableau

Types of YoungTableau:
======================

  * MutableYoungTableau -- a type of HashTable
    representing a Young tableau, with mutable entries
  * Tabloid -- a type of HashTable representing a Young tabloid

Functions and methods returning an object of class YoungTableau:
================================================================

  * applyEntries -- apply a function to all entries in the
    tableau
  * applyPositions -- apply a function to all positions
    of boxes in a tableau
  * randomSemistandardTableau -- get a random
    semistandard Young Tableau
  * randomStandardTableau -- get a random
    standard Young Tableau
  * shift -- shift a tableau
  * unshift -- unshift a tableau
  * verticalConcatenate -- vertical concatenation
    of a list of tableaux
  * youngTableau -- constructor for type YoungTableau

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

  * "applyEntries(YoungTableau,Function)" -- see applyEntries,
    -- apply a function to all entries in the tableau
  * "applyPositions(YoungTableau,Function)" -- see applyPositions,
    -- apply a function to all positions of boxes in a tableau
  * "columnEntries(YoungTableau,ZZ)" -- see columnEntries,
    -- get the entries in a column
  * "columnEntries(ZZ,YoungTableau)" -- see columnEntries,
    -- get the entries in a column
  * "columnRange(YoungTableau)" -- see columnRange, -- the
    range of column indices of a tableau
  * "columnStabilizer(YoungTableau)" -- see columnStabilizer,
    -- the column stabilizer of a tableau
  * components(YoungTableau) -- get the
    connected components of a tableau
  * conjugate(YoungTableau) -- conjugate a
    tableau
  * entries(YoungTableau) -- the filling of a
    tableau
  * "ferrersDiagram(YoungTableau)" -- see ferrersDiagram,
    -- a net of the Ferrers diagram
  * "hookLength(Sequence,YoungTableau)" -- see hookLength, --
    compute the hook length of a box of a tableau
  * "innerShape(YoungTableau)" -- see innerShape, -- the
    inner shape of a (skew) Young tableau
  * "isCorner(Sequence,YoungTableau)" -- see isCorner, --
    checks if a box is a corner of a tableau
  * "isNonnegative(YoungTableau)" -- see isNonnegative, --
    check if shapes are nonnegative
  * "isSemistandard(YoungTableau)" -- see isSemistandard,
    -- checks if a Young tableau is semistandard
  * "isSkew(YoungTableau)" -- see isSkew, -- checks if a Young
    tableau is skew
  * "isStandard(YoungTableau)" -- see isStandard, -- checks
    if a Young tableau is standard
  * "isWeaklyDecreasing(YoungTableau)" -- see isWeaklyDecreasing,
    -- check if shapes are weakly decreasing
  * numColumns(YoungTableau) -- the number
    of columns in a tableau
  * numRows(YoungTableau) -- the number of
    rows in a tableau
  * "outerShape(YoungTableau)" -- see outerShape, -- the
    outer shape of a (skew) Young tableau
  * "positionList(YoungTableau)" -- see positionList, --
    get the positions of all the boxes in a tableau
  * "positionList(YoungTableau,Function)" -- see positionList,
    -- get the positions of all the boxes in a tableau
  * "readingWord(YoungTableau)" -- see readingWord, -- get
    the reading word of a tableau
  * "rowEntries(YoungTableau,ZZ)" -- see rowEntries, -- get
    the entries in a row
  * "rowEntries(ZZ,YoungTableau)" -- see rowEntries, -- get
    the entries in a row
  * "rowRange(YoungTableau)" -- see rowRange, -- the range of
    row indices of a tableau
  * "rowStabilizer(YoungTableau)" -- see rowStabilizer, --
    the row stabilizer of a tableau
  * "shape(YoungTableau)" -- see shape, -- the shape of a Young
    tableau
  * "shift(YoungTableau)" -- see shift, -- shift a tableau
  * "shift(YoungTableau,ZZ)" -- see shift, -- shift a tableau
  * size(YoungTableau) -- the number of boxes in
    a tableau
  * "skewShape(YoungTableau)" -- see skewShape, -- the shape
    of a skew tableau
  * "tabloid(YoungTableau)" -- see tabloid, -- constructor for
    type Tabloid
  * tex(YoungTableau) -- LaTeX output for a
    tableau
  * "toIndex(Sequence,YoungTableau)" -- see toIndex, -- get the
    index of a box, given its position
  * "toIndex(YoungTableau,Sequence)" -- see toIndex, -- get the
    index of a box, given its position
  * "toPartitionChain(YoungTableau)" -- see toPartitionChain,
    -- decompose a tableau into a chain of partitions
  * "toPosition(YoungTableau,ZZ)" -- see toPosition, -- get
    the position of a box, given its index
  * "toPosition(ZZ,YoungTableau)" -- see toPosition, -- get
    the position of a box, given its index
  * "unshift(YoungTableau)" -- see unshift, -- unshift a tableau
  * "unshift(YoungTableau,ZZ)" -- see unshift, -- unshift a
    tableau
  * "youngDiagram(YoungTableau)" -- see youngDiagram, -- a
    net of the Young diagram
  * "net(YoungTableau)"
  * YoungTableau ++ YoungTableau -- direct
    sum of tableaux
  * YoungTableau == YoungTableau -- check
    if two Young tableaux are equal
  * YoungTableau ^ ZZ -- get the entries in a row
  * YoungTableau _ Sequence -- get the entry
    at a specific position
  * YoungTableau _ ZZ -- get the entries in a
    column
  * YoungTableau || YoungTableau, --
    vertical concatenation of two tableaux

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

The object YoungTableau, is a type (Macaulay2Doc),
with ancestor classes HashTable (Macaulay2Doc),
< Thing (Macaulay2Doc).

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

The source of this document is in Tableaux/documentation.m2:93:0.

youngTableau -- constructor for type YoungTableau
*************************************************

  * Usage:
        youngTableau(lam, mu, entryList)
        youngTableau((lam,mu),entryList)
        youngTableau(lam, entryList)
  * Inputs:
      * lam, an instance of the type Partition (Macaulay2Doc),
        the outer shape $\lambda$.
      * mu, an instance of the type Partition (Macaulay2Doc),
        the inner shape $\mu$. If not given, then it is assumed to be the $0$
        partition.
      * entryList, a list (Macaulay2Doc), the filling of the boxes.
        If not given, then box entries are assumed to be the empty string "".
  * Outputs:
      * T, an instance of the type YoungTableau, a skew
        Young tableau of shape $\lambda/\mu$ with the given filling.
  * Consequences:
      * The list of entries has length equal to
        $\sum_{i=1}^{\ell(\lambda)}|\lambda_i-\mu_i|$. E.g., if $\lambda=(2)$
        and $\mu=(5)$, then the entry list must have length $3$.
      * None of the entries are null.

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

+---------------------------------------+
|i1 : lam = new Partition from {4,3,2}  |
|                                       |
|o1 = Partition{4, 3, 2}                |
|                                       |
|o1 : Partition                         |
+---------------------------------------+
|i2 : mu = new Partition from {3,1}     |
|                                       |
|o2 = Partition{3, 1}                   |
|                                       |
|o2 : Partition                         |
+---------------------------------------+
|i3 : entryList = {1,2,3,3,9}           |
|                                       |
|o3 = {1, 2, 3, 3, 9}                   |
|                                       |
|o3 : List                              |
+---------------------------------------+
|i4 : T = youngTableau(lam,mu,entryList)|
|                                       |
|                 ┌───┐                 |
|o4 =             │ 1 │                 |
|         ┌───┬───┼───┘                 |
|         │ 2 │ 3 │                     |
|     ┌───┼───┼───┘                     |
|     │ 3 │ 9 │                         |
|     └───┴───┘                         |
|                                       |
|o4 : YoungTableau                      |
+---------------------------------------+

We may construct tableaux with any compositions.

+-----------------------------------------------------------------------------+
|i5 : youngTableau(new Partition from {3,5,1}, new Partition from {0,1},      |
|                                                                             |
|     ┌───┬───┬───┐                                                           |
|o5 = │ 7 │ & │ 4 │                                                           |
|     └───┼───┼───┼───┬───┐                                                   |
|         │ 2 │ g │ u │ 6 │                                                   |
|     ┌───┼───┴───┴───┴───┘                                                   |
|     │ 0 │                                                                   |
|     └───┘                                                                   |
|                                                                             |
|o5 : YoungTableau                                                            |
|-----------------------------------------------------------------------------|
|{7,"&",4,2,"g","u",6,0})                                                     |
+-----------------------------------------------------------------------------+

The shapes may have negative parts. In this case, a vertical line is drawn by
net, to indicate that negative parts are to the left.

+-----------------------------------------------------------------------------+
|i6 : youngTableau(new Partition from {3,-3,-1}, new Partition from           |
|                                                                             |
|             ┌───┬───║───┬───┬───┐                                           |
|o6 =         │   │   ║   │   │   │                                           |
|     ┌───┐   └───┴───║───┴───┴───┘                                           |
|     │   │           ║                                                       |
|     └───┘           ║                                                       |
|                     ║                                                       |
|                     ║                                                       |
|                                                                             |
|o6 : YoungTableau                                                            |
|-----------------------------------------------------------------------------|
|{-2,-4,-1})                                                                  |
+-----------------------------------------------------------------------------+

If any $\lambda_i<\mu_i$, then the boxes in that row are drawn shaded.

+-----------------------------------------------------------------------------+
|i7 : youngTableau(new Partition from {-2,-4,2}, new Partition from {1,-1,-1},|
|                                                                             |
|             ┌───┬───║───┐                                                   |
|o7 =         │░1░│░2░║░3░│                                                   |
|     ┌───┬───┼───┼───║───┘                                                   |
|     │░4░│░5░│░6░│   ║                                                       |
|     └───┴───┴───┼───║───┬───┐                                               |
|                 │ 7 ║ 8 │ 9 │                                               |
|                 └───║───┴───┘                                               |
|                                                                             |
|o7 : YoungTableau                                                            |
|-----------------------------------------------------------------------------|
|{1,2,3,4,5,6,7,8,9})                                                         |
+-----------------------------------------------------------------------------+

The inner shape may be drawn by calling drawInnerShape.

+-----------------------------------------------------------------------------+
|i8 : T'' = youngTableau(new Partition from {5,4,-1}, new Partition from      |
|                                                                             |
|                 ║       ┌───┬───┬───┐                                       |
|o8 =             ║       │   │   │   │                                       |
|                 ║       └───┴───┴───┘                                       |
|                 ║                                                           |
|     ┌───┬───┐   ║                                                           |
|     │   │   │   ║                                                           |
|     └───┴───┘   ║                                                           |
|                                                                             |
|o8 : YoungTableau                                                            |
|-----------------------------------------------------------------------------|
|{2,4,-3})                                                                    |
+-----------------------------------------------------------------------------+
|i9 : drawInnerShape true                                                     |
|                                                                             |
|o9 = true                                                                    |
+-----------------------------------------------------------------------------+
|i10 : T''                                                                    |
|                                                                             |
|                  ║       ┌───┬───┬───┐                                      |
|o10 =             ║ ■   ■ │   │   │   │                                      |
|                  ║       └───┴───┴───┘                                      |
|                  ║ ■   ■   ■   ■                                            |
|      ┌───┬───┐   ║                                                          |
|      │   │   │ ■ ║                                                          |
|      └───┴───┘   ║                                                          |
|                                                                             |
|o10 : YoungTableau                                                           |
+-----------------------------------------------------------------------------+
|i11 : drawInnerShape false                                                   |
|                                                                             |
|o11 = false                                                                  |
+-----------------------------------------------------------------------------+
|i12 : T''                                                                    |
|                                                                             |
|                  ║       ┌───┬───┬───┐                                      |
|o12 =             ║       │   │   │   │                                      |
|                  ║       └───┴───┴───┘                                      |
|                  ║                                                          |
|      ┌───┬───┐   ║                                                          |
|      │   │   │   ║                                                          |
|      └───┴───┘   ║                                                          |
|                                                                             |
|o12 : YoungTableau                                                           |
+-----------------------------------------------------------------------------+

The filling may be of any class (besides null (Macaulay2Doc),
objects), including other tableaux!

+-----------------------------------------------------------------------------+
|i13 : youngTableau(lam,mu,for i from 1 to size T list randomTabloid lam)     |
|                                                                             |
|                                                                  ┌──────────|
|o13 =                                                             │ ┌────────|
|                                                                  │ │ 6   4  |
|                                                                  │ ├────────|
|                                                                  │ │ 2   3  |
|                                                                  │ ├───────┬|
|                                                                  │ │ 5   8 │|
|                                                                  │ └───────┘|
|                          ┌───────────────────┬───────────────────┼──────────|
|                          │ ┌───────────────┐ │ ┌───────────────┐ │          |
|                          │ │ 5   4   1   7 │ │ │ 8   3   4   6 │ │          |
|                          │ ├───────────┬───┘ │ ├───────────┬───┘ │          |
|                          │ │ 3   8   2 │     │ │ 1   5   9 │     │          |
|                          │ ├───────┬───┘     │ ├───────┬───┘     │          |
|                          │ │ 9   6 │         │ │ 2   7 │         │          |
|                          │ └───────┘         │ └───────┘         │          |
|      ┌───────────────────┼───────────────────┼───────────────────┘          |
|      │ ┌───────────────┐ │ ┌───────────────┐ │                              |
|      │ │ 6   4   7   9 │ │ │ 1   2   3   5 │ │                              |
|      │ ├───────────┬───┘ │ ├───────────┬───┘ │                              |
|      │ │ 3   1   8 │     │ │ 9   6   7 │     │                              |
|      │ ├───────┬───┘     │ ├───────┬───┘     │                              |
|      │ │ 5   2 │         │ │ 8   4 │         │                              |
|      │ └───────┘         │ └───────┘         │                              |
|      └───────────────────┴───────────────────┘                              |
|                                                                             |
|o13 : YoungTableau                                                           |
|-----------------------------------------------------------------------------|
|─────────┐                                                                   |
|───────┐ │                                                                   |
| 7   9 │ │                                                                   |
|───┬───┘ │                                                                   |
| 1 │     │                                                                   |
|───┘     │                                                                   |
|         │                                                                   |
|         │                                                                   |
|─────────┘                                                                   |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
+-----------------------------------------------------------------------------+

See also
========

  * YoungTableau -- a type of HashTable representing a
    Young tableau

Ways to use youngTableau:
=========================

  * "youngTableau(Partition)"
  * "youngTableau(Partition,List)"
  * "youngTableau(Partition,Partition)"
  * "youngTableau(Partition,Partition,List)"
  * "youngTableau(Sequence,List)"
  * "youngTableau(Tabloid)"

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

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

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

The source of this document is in Tableaux/documentation.m2:1605:0.

YoungTableau ++ YoungTableau -- direct sum of tableaux
******************************************************

  * Operator: ++ (Macaulay2Doc),
  * Usage:
        T1 ++ T2
  * Inputs:
      * T1, an instance of the type YoungTableau, a
        tableau.
      * T2, an instance of the type YoungTableau, a
        tableau.
  * Outputs:
      * S, an instance of the type YoungTableau, a direct
        sum of T1 and T2.

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

The tableaux are combined into the disconnected components (not sharing an
edge) of a single tableau.

+-----------------------------------------------------------------------------+
|i1 : T1 = youngTableau(new Partition from {5}, new Partition from {2})       |
|                                                                             |
|             ┌───┬───┬───┐                                                   |
|o1 =         │   │   │   │                                                   |
|             └───┴───┴───┘                                                   |
|                                                                             |
|o1 : YoungTableau                                                            |
+-----------------------------------------------------------------------------+
|i2 : T2 = youngTableau(new Partition from {3,2}, new Partition from {1},     |
|                                                                             |
|         ┌───┬───┐                                                           |
|o2 =     │ 1 │ 2 │                                                           |
|     ┌───┼───┼───┘                                                           |
|     │ 3 │ 4 │                                                               |
|     └───┴───┘                                                               |
|                                                                             |
|o2 : YoungTableau                                                            |
|-----------------------------------------------------------------------------|
|{1,2,3,4})                                                                   |
+-----------------------------------------------------------------------------+
|i3 : T1 ++ T2                                                                |
|                                                                             |
|                 ┌───┬───┬───┐                                               |
|o3 =             │   │   │   │                                               |
|         ┌───┬───┼───┴───┴───┘                                               |
|         │ 1 │ 2 │                                                           |
|     ┌───┼───┼───┘                                                           |
|     │ 3 │ 4 │                                                               |
|     └───┴───┘                                                               |
|                                                                             |
|o3 : YoungTableau                                                            |
+-----------------------------------------------------------------------------+
|i4 : T2 ++ T1                                                                |
|                                                                             |
|                             ┌───┬───┐                                       |
|o4 =                         │ 1 │ 2 │                                       |
|                         ┌───┼───┼───┘                                       |
|                         │ 3 │ 4 │                                           |
|             ┌───┬───┬───┼───┴───┘                                           |
|             │   │   │   │                                                   |
|             └───┴───┴───┘                                                   |
|                                                                             |
|o4 : YoungTableau                                                            |
+-----------------------------------------------------------------------------+

See also
========

  * components(YoungTableau) -- get the
    connected components of a tableau
  * YoungTableau || YoungTableau, --
    vertical concatenation of two tableaux

Ways to use this method:
========================

  * YoungTableau ++ YoungTableau -- direct
    sum of tableaux
-------------------------------------------------------------------------------

The source of this document is in Tableaux/documentation.m2:1847:0.

YoungTableau == YoungTableau -- check if two Young tableaux are equal
*********************************************************************

  * Operator: == (Macaulay2Doc),
  * Usage:
        T1 == T2
  * Inputs:
      * T1, an instance of the type YoungTableau, a
        tableau.
      * T2, an instance of the type YoungTableau, a
        tableau.
  * Outputs:
      * b, a Boolean value (Macaulay2Doc), whether the tableaux
        are equal or not.

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

Two tableaux are equal if they have the same shape (ignoring trailing 0s), and
the same filling.

+-----------------------------------------------------------------------------+
|i1 : T1 = youngTableau(new Partition from {5,3,1}, new Partition from {2},   |
|                                                                             |
|             ┌───┬───┬───┐                                                   |
|o1 =         │ 7 │ 2 │ 4 │                                                   |
|     ┌───┬───┼───┼───┴───┘                                                   |
|     │ 1 │ 3 │ 6 │                                                           |
|     ├───┼───┴───┘                                                           |
|     │ 5 │                                                                   |
|     └───┘                                                                   |
|                                                                             |
|o1 : YoungTableau                                                            |
|-----------------------------------------------------------------------------|
|{7,2,4,1,3,6,5})                                                             |
+-----------------------------------------------------------------------------+
|i2 : T2 = youngTableau(new Partition from {5,3,1}, new Partition from {2},   |
|                                                                             |
|             ┌───┬───┬───┐                                                   |
|o2 =         │ 2 │ 7 │ 4 │                                                   |
|     ┌───┬───┼───┼───┴───┘                                                   |
|     │ 3 │ 6 │ 1 │                                                           |
|     ├───┼───┴───┘                                                           |
|     │ 5 │                                                                   |
|     └───┘                                                                   |
|                                                                             |
|o2 : YoungTableau                                                            |
|-----------------------------------------------------------------------------|
|{2,7,4,3,6,1,5})                                                             |
+-----------------------------------------------------------------------------+
|i3 : T1 == T2                                                                |
|                                                                             |
|o3 = false                                                                   |
+-----------------------------------------------------------------------------+

Ways to use this method:
========================

  * YoungTableau == YoungTableau -- check
    if two Young tableaux are equal
-------------------------------------------------------------------------------

The source of this document is in Tableaux/documentation.m2:1871:0.

YoungTableau ^ ZZ -- get the entries in a row
*********************************************

  * Operator: ^ (Macaulay2Doc),
  * Usage:
        T^i
  * Inputs:
      * T, an instance of the type YoungTableau, a
        tableau.
      * i, an integer (Macaulay2Doc), the index of a row.
  * Outputs:
      * l, a list (Macaulay2Doc), the entries in the $i$th row of
        T.

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

Note that the resulting list may contain null (Macaulay2Doc),
entries in places where a box is not present. This means that the notations
(T^i)#j, (T_j)#i, and T_(i,j) are all equivalent for valid positions (i,j).
However, the notation T_(i,j) will raise an error for nonvalid positions,
whereas the other two will return null (Macaulay2Doc).

+-----------------------------------------------------------------------------+
|i1 : T = youngTableau(new Partition from {4,3,1,0}, new Partition from {1,1},|
|                                                                             |
|         ┌───┬───┬───┐                                                       |
|o1 =     │ 1 │ 2 │ 3 │                                                       |
|         ├───┼───┼───┘                                                       |
|         │ 4 │ 5 │                                                           |
|     ┌───┼───┴───┘                                                           |
|     │ 6 │                                                                   |
|     └───┘                                                                   |
|                                                                             |
|o1 : YoungTableau                                                            |
|-----------------------------------------------------------------------------|
|{1,2,3,4,5,6})                                                               |
+-----------------------------------------------------------------------------+
|i2 : for i from 0 to numRows T - 1 do print T^i                              |
|{, 1, 2, 3}                                                                  |
|{, 4, 5, }                                                                   |
|{6, , , }                                                                    |
+-----------------------------------------------------------------------------+
|i3 : (T^0)#1                                                                 |
|                                                                             |
|o3 = 1                                                                       |
+-----------------------------------------------------------------------------+
|i4 : (T_1)#0                                                                 |
|                                                                             |
|o4 = 1                                                                       |
+-----------------------------------------------------------------------------+
|i5 : T_(0,1)                                                                 |
|                                                                             |
|o5 = 1                                                                       |
+-----------------------------------------------------------------------------+

If T has negative rows, then the entries at negative column coordinates are to
the right in the output.

+-----------------------------------------------------------------------------+
|i6 : T' = youngTableau(new Partition from {4,3,1,0}, new Partition from      |
|                                                                             |
|         ║   ┌───┬───┬───┐                                                   |
|o6 =     ║   │ 1 │ 2 │ 3 │                                                   |
|     ┌───║───┼───┼───┼───┘                                                   |
|     │ 4 ║ 5 │ 6 │ 7 │                                                       |
|     └───║───┼───┴───┘                                                       |
|         ║ 8 │                                                               |
|         ║───┘                                                               |
|                                                                             |
|o6 : YoungTableau                                                            |
|-----------------------------------------------------------------------------|
|{1,-1}, {1,2,3,4,5,6,7,8})                                                   |
+-----------------------------------------------------------------------------+
|i7 : for i from 0 to numRows T' - 1 do print T'^i                            |
|{, 1, 2, 3, }                                                                |
|{5, 6, 7, , 4}                                                               |
|{8, , , , }                                                                  |
+-----------------------------------------------------------------------------+
|i8 : T'^1#-1                                                                 |
|                                                                             |
|o8 = 4                                                                       |
+-----------------------------------------------------------------------------+
|i9 : T'_(1,-1)                                                               |
|                                                                             |
|o9 = 4                                                                       |
+-----------------------------------------------------------------------------+

To get the row entries exactly as they appear in the tableau and without extra
null's, use rowEntries.

+-----------------------------------------------------------------------------+
|i10 : T'' = youngTableau(new Partition from {3,4}, new Partition from {-2},  |
|                                                                             |
|      ┌───┬───║───┬───┬───┐                                                  |
|o10 = │ 1 │ 2 ║ 3 │ 4 │ 5 │                                                  |
|      └───┴───║───┼───┼───┼───┐                                              |
|              ║ 6 │ 7 │ 8 │ 9 │                                              |
|              ║───┴───┴───┴───┘                                              |
|                                                                             |
|o10 : YoungTableau                                                           |
|-----------------------------------------------------------------------------|
|{1,2,3,4,5,6,7,8,9})                                                         |
+-----------------------------------------------------------------------------+
|i11 : T''^0                                                                  |
|                                                                             |
|o11 = {3, 4, 5, , 1, 2}                                                      |
|                                                                             |
|o11 : List                                                                   |
+-----------------------------------------------------------------------------+
|i12 : rowEntries(T'',0)                                                      |
|                                                                             |
|o12 = {1, 2, 3, 4, 5}                                                        |
|                                                                             |
|o12 : List                                                                   |
+-----------------------------------------------------------------------------+

See also
========

  * numRows(YoungTableau) -- the number of
    rows in a tableau
  * rowEntries -- get the entries in a row
  * YoungTableau _ Sequence -- get the entry
    at a specific position
  * YoungTableau _ ZZ -- get the entries in a
    column

Ways to use this method:
========================

  * YoungTableau ^ ZZ -- get the entries in a row
-------------------------------------------------------------------------------

The source of this document is in Tableaux/documentation.m2:1917:0.

YoungTableau _ Sequence -- get the entry at a specific position
***************************************************************

  * Operator: _ (Macaulay2Doc),
  * Usage:
        T_seq
        T_(i,j)
  * Inputs:
      * T, an instance of the type YoungTableau, a
        tableau.
      * seq, a sequence (Macaulay2Doc), a pair (i,j) of
        integers in ZZ.
  * Outputs:
      * theBox, a thing (Macaulay2Doc), the entry of T in position
        (i,j).

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

The notations (T^i)#j, (T_j)#i, and T_(i,j) are all equivalent for valid
positions (i,j). However, the notation T_(i,j) will raise an error for nonvalid
positions, whereas the other two will return null (Macaulay2Doc).

+-----------------------------------------------------------------------------+
|i1 : T = youngTableau(new Partition from {4,3,1,0}, new Partition from {1,1},|
|                                                                             |
|         ┌───┬───┬───┐                                                       |
|o1 =     │ 1 │ 2 │ 3 │                                                       |
|         ├───┼───┼───┘                                                       |
|         │ 4 │ 5 │                                                           |
|     ┌───┼───┴───┘                                                           |
|     │ 6 │                                                                   |
|     └───┘                                                                   |
|                                                                             |
|o1 : YoungTableau                                                            |
|-----------------------------------------------------------------------------|
|{1,2,3,4,5,6})                                                               |
+-----------------------------------------------------------------------------+
|i2 : (T^0)#1                                                                 |
|                                                                             |
|o2 = 1                                                                       |
+-----------------------------------------------------------------------------+
|i3 : (T_1)#0                                                                 |
|                                                                             |
|o3 = 1                                                                       |
+-----------------------------------------------------------------------------+
|i4 : T_(0,1)                                                                 |
|                                                                             |
|o4 = 1                                                                       |
+-----------------------------------------------------------------------------+

See also
========

  * YoungTableau _ ZZ -- get the entries in a
    column
  * YoungTableau ^ ZZ -- get the entries in a row

Ways to use this method:
========================

  * YoungTableau _ Sequence -- get the entry
    at a specific position
-------------------------------------------------------------------------------

The source of this document is in Tableaux/documentation.m2:1947:0.

YoungTableau _ ZZ -- get the entries in a column
************************************************

  * Operator: _ (Macaulay2Doc),
  * Usage:
        T_j
  * Inputs:
      * T, an instance of the type YoungTableau, a
        tableau.
      * j, an integer (Macaulay2Doc), the index of a column.
  * Outputs:
      * l, a list (Macaulay2Doc), the entries in the $j$th column
        of T.

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

Note that the resulting list may contain null (Macaulay2Doc),
entries in places where a box is not present. This means that the notations
(T^i)#j, (T_j)#i, and T_(i,j) are all equivalent for valid positions (i,j).
However, the notation T_(i,j) will raise an error for nonvalid positions,
whereas the other two will return null (Macaulay2Doc).

+-----------------------------------------------------------------------------+
|i1 : T = youngTableau(new Partition from {4,3,1,0}, new Partition from {1,1},|
|                                                                             |
|         ┌───┬───┬───┐                                                       |
|o1 =     │ 1 │ 2 │ 3 │                                                       |
|         ├───┼───┼───┘                                                       |
|         │ 4 │ 5 │                                                           |
|     ┌───┼───┴───┘                                                           |
|     │ 6 │                                                                   |
|     └───┘                                                                   |
|                                                                             |
|o1 : YoungTableau                                                            |
|-----------------------------------------------------------------------------|
|{1,2,3,4,5,6})                                                               |
+-----------------------------------------------------------------------------+
|i2 : for i in columnRange T do print T_i                                     |
|{, , 6}                                                                      |
|{1, 4, }                                                                     |
|{2, 5, }                                                                     |
|{3, , }                                                                      |
+-----------------------------------------------------------------------------+
|i3 : (T^0)#1                                                                 |
|                                                                             |
|o3 = 1                                                                       |
+-----------------------------------------------------------------------------+
|i4 : (T_1)#0                                                                 |
|                                                                             |
|o4 = 1                                                                       |
+-----------------------------------------------------------------------------+
|i5 : T_(0,1)                                                                 |
|                                                                             |
|o5 = 1                                                                       |
+-----------------------------------------------------------------------------+

To get the column entries without extra null's, use columnEntries.

+-----------------------------------------------------------------------------+
|i6 : T'' = youngTableau(new Partition from {3,1}, new Partition from         |
|                                                                             |
|     ┌───┬───║───┬───┬───┐                                                   |
|o6 = │ 1 │ 2 ║ 3 │ 4 │ 5 │                                                   |
|     └───┴───║───┼───┴───┘                                                   |
|             ║ 6 │                                                           |
|         ┌───║───┘                                                           |
|         │ 7 ║                                                               |
|         └───║                                                               |
|                                                                             |
|o6 : YoungTableau                                                            |
|-----------------------------------------------------------------------------|
|{-2,0,-1}, {1,2,3,4,5,6,7})                                                  |
+-----------------------------------------------------------------------------+
|i7 : T''_-1                                                                  |
|                                                                             |
|o7 = {2, , 7}                                                                |
|                                                                             |
|o7 : List                                                                    |
+-----------------------------------------------------------------------------+
|i8 : columnEntries(T'',-1)                                                   |
|                                                                             |
|o8 = {2, 7}                                                                  |
|                                                                             |
|o8 : List                                                                    |
+-----------------------------------------------------------------------------+

See also
========

  * numColumns(YoungTableau) -- the number
    of columns in a tableau
  * columnEntries -- get the entries in a column
  * YoungTableau _ Sequence -- get the entry
    at a specific position
  * YoungTableau ^ ZZ -- get the entries in a row

Ways to use this method:
========================

  * YoungTableau _ ZZ -- get the entries in a
    column
-------------------------------------------------------------------------------

The source of this document is in Tableaux/documentation.m2:1986:0.

YoungTableau || YoungTableau -- vertical concatenation of two tableaux
**********************************************************************

  * Operator: || (Macaulay2Doc),
  * Usage:
        T1 || T2
  * Inputs:
      * T1, an instance of the type YoungTableau, a
        tableau.
      * T2, an instance of the type YoungTableau, a
        tableau.
  * Outputs:
      * S, an instance of the type YoungTableau, a single
        tableau with T1 directly above T2.

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

+-----------------------------------------------------------------------------+
|i1 : T1 = youngTableau(new Partition from {5}, new Partition from {2})       |
|                                                                             |
|             ┌───┬───┬───┐                                                   |
|o1 =         │   │   │   │                                                   |
|             └───┴───┴───┘                                                   |
|                                                                             |
|o1 : YoungTableau                                                            |
+-----------------------------------------------------------------------------+
|i2 : T2 = youngTableau(new Partition from {3,2}, new Partition from {1},     |
|                                                                             |
|         ┌───┬───┐                                                           |
|o2 =     │ 1 │ 2 │                                                           |
|     ┌───┼───┼───┘                                                           |
|     │ 3 │ 4 │                                                               |
|     └───┴───┘                                                               |
|                                                                             |
|o2 : YoungTableau                                                            |
|-----------------------------------------------------------------------------|
|{1,2,3,4})                                                                   |
+-----------------------------------------------------------------------------+
|i3 : T1 || T2                                                                |
|                                                                             |
|             ┌───┬───┬───┐                                                   |
|o3 =         │   │   │   │                                                   |
|         ┌───┼───┼───┴───┘                                                   |
|         │ 1 │ 2 │                                                           |
|     ┌───┼───┼───┘                                                           |
|     │ 3 │ 4 │                                                               |
|     └───┴───┘                                                               |
|                                                                             |
|o3 : YoungTableau                                                            |
+-----------------------------------------------------------------------------+
|i4 : T2 || T1                                                                |
|                                                                             |
|         ┌───┬───┐                                                           |
|o4 =     │ 1 │ 2 │                                                           |
|     ┌───┼───┼───┘                                                           |
|     │ 3 │ 4 │                                                               |
|     └───┴───┼───┬───┬───┐                                                   |
|             │   │   │   │                                                   |
|             └───┴───┴───┘                                                   |
|                                                                             |
|o4 : YoungTableau                                                            |
+-----------------------------------------------------------------------------+

See also
========

  * verticalConcatenate -- vertical concatenation
    of a list of tableaux
  * YoungTableau ++ YoungTableau -- direct
    sum of tableaux

Ways to use this method:
========================

  * YoungTableau || YoungTableau, --
    vertical concatenation of two tableaux
-------------------------------------------------------------------------------

The source of this document is in Tableaux/documentation.m2:2012:0.