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

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

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

This package provides the classes SkewTableau, and
YoungTableau.

Author
======

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

Version
=======

This documentation describes version 0.5 of Tableaux, released July 22, 2025.

Citation
========

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

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

Exports
=======

  * Types
      * SkewTableau -- a type of HashTable representing a
        skew Young tableau
      * YoungTableau -- a type of HashTable representing a
        (nonskew) Young tableau
  * Functions and commands
      * allSemistandardTableaux -- list all
        semistandard Young tableaux 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.
      * ferrersDiagram -- a net of the Ferrers diagram
      * hookLength -- compute the hook length of a box of a
        tableau
      * isNonnegative -- check if shapes are nonnegative
      * isWeaklyDecreasing -- check if shapes are
        weakly decreasing
      * numSemistandardTableaux -- compute the
        number of semistandard Young tableaux of a given shape
      * positionList -- get the positions of all the boxes
        in a tableau
      * rowEntries -- get the entries in a row.
      * rowRange -- the range of row indices of a tableau.
      * shape -- the shape of a Young tableau
      * shift -- shift a tableau
      * skewShape -- the shape of a skew tableau
      * "standardize" -- see skewShape, -- the shape of a skew
        tableau
      * "drawInnerShape" -- see skewTableau, -- constructor
        for type SkewTableau
      * skewTableau -- constructor for type SkewTableau
      * toIndex -- get the index of a box, given its position.
      * toPosition -- get the position of a box, given its
        index.
      * unshift -- unshift a tableau
      * verticalConcatenate -- vertical
        concatenation of a list of tableaux
      * youngDiagram -- a net of the Young diagram
      * youngTableau -- constructor for type YoungTableau
  * Methods
      * "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
      * "applyEntries(SkewTableau,Function)" -- see applyEntries,
        -- apply a function to all entries in the tableau
      * "applyPositions(SkewTableau,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(SkewTableau,ZZ)" -- see columnEntries,
        -- get the entries in a column.
      * "columnEntries(ZZ,SkewTableau)" -- see columnEntries,
        -- get the entries in a column.
      * "columnRange(SkewTableau)" -- see columnRange, --
        the range of column indices of a tableau.
      * components(SkewTableau) -- get the
        connected components of a tableau
      * conjugate(SkewTableau) -- conjugate
        a tableau
      * entries(SkewTableau) -- the filling of
        a skew tableau
      * "ferrersDiagram(Partition)" -- see ferrersDiagram,
        -- a net of the Ferrers diagram
      * "ferrersDiagram(Partition,Partition)" -- see ferrersDiagram,
        -- a net of the Ferrers diagram
      * "ferrersDiagram(SkewTableau)" -- see ferrersDiagram,
        -- a net of the Ferrers diagram
      * "hookLength(Sequence,SkewTableau)" -- see hookLength,
        -- compute the hook length of a box of a tableau
      * "isNonnegative(Partition)" -- see isNonnegative,
        -- check if shapes are nonnegative
      * "isNonnegative(Partition,Partition)" -- see isNonnegative,
        -- check if shapes are nonnegative
      * "isNonnegative(SkewTableau)" -- see isNonnegative,
        -- check if shapes are nonnegative
      * "isWeaklyDecreasing(Partition)" -- see isWeaklyDecreasing,
        -- check if shapes are weakly decreasing
      * "isWeaklyDecreasing(Partition,Partition)" -- see
        isWeaklyDecreasing, -- check if shapes are weakly
        decreasing
      * "isWeaklyDecreasing(SkewTableau)" -- see isWeaklyDecreasing,
        -- check if shapes are weakly decreasing
      * numColumns(SkewTableau) -- the
        number of columns in a tableau
      * numRows(SkewTableau) -- 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
      * "positionList(SkewTableau)" -- see positionList, --
        get the positions of all the boxes in a tableau
      * "rowEntries(SkewTableau,ZZ)" -- see rowEntries, --
        get the entries in a row.
      * "rowEntries(ZZ,SkewTableau)" -- see rowEntries, --
        get the entries in a row.
      * "rowRange(SkewTableau)" -- see rowRange, -- the range
        of row indices of a tableau.
      * "shape(YoungTableau)" -- see shape, -- the shape of a
        Young tableau
      * "truncate(Partition)" -- see shape, -- the shape of a
        Young tableau
      * "shift(SkewTableau)" -- see shift, -- shift a tableau
      * "shift(SkewTableau,ZZ)" -- see shift, -- shift a tableau
      * size(SkewTableau) -- the number of boxes
        in a skew tableau
      * "pad(Partition,Partition)" -- see skewShape, -- the
        shape of a skew tableau
      * "skewShape(SkewTableau)" -- see skewShape, -- the
        shape of a skew tableau
      * "standardize(Partition,Partition)" -- see skewShape,
        -- the shape of a skew tableau
      * "truncate(Partition,Partition)" -- see skewShape, --
        the shape of a skew tableau
      * "net(SkewTableau)" -- see SkewTableau, -- a type of
        HashTable representing a skew Young tableau
      * "drawInnerShape(Boolean)" -- see skewTableau, --
        constructor for type SkewTableau
      * "skewTableau(Partition)" -- see skewTableau, --
        constructor for type SkewTableau
      * "skewTableau(Partition,List)" -- see skewTableau, --
        constructor for type SkewTableau
      * "skewTableau(Partition,Partition)" -- see skewTableau,
        -- constructor for type SkewTableau
      * "skewTableau(Partition,Partition,List)" -- see skewTableau,
        -- constructor for type SkewTableau
      * "skewTableau(Sequence,List)" -- see skewTableau, --
        constructor for type SkewTableau
      * "skewTableau(YoungTableau)" -- see skewTableau, --
        constructor for type SkewTableau
      * SkewTableau ++ SkewTableau -- direct
        sum of tableaux
      * SkewTableau ^ ZZ -- get the entries in a row.
      * SkewTableau _ Sequence -- get the
        entry at a specific position.
      * SkewTableau _ ZZ -- get the entries in a
        column.
      * SkewTableau || SkewTableau, --
        vertical concatenation of two tableaux
      * tex(SkewTableau) -- LaTeX output for a
        skew tableau
      * "toIndex(Sequence,SkewTableau)" -- see toIndex, -- get
        the index of a box, given its position.
      * "toIndex(SkewTableau,Sequence)" -- see toIndex, -- get
        the index of a box, given its position.
      * "toPosition(SkewTableau,ZZ)" -- see toPosition, --
        get the position of a box, given its index.
      * "toPosition(ZZ,SkewTableau)" -- see toPosition, --
        get the position of a box, given its index.
      * "unshift(SkewTableau)" -- see unshift, -- unshift a
        tableau
      * "unshift(SkewTableau,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(SkewTableau)" -- see youngDiagram, --
        a net of the Young diagram
      * "youngTableau(Partition)" -- see youngTableau, --
        constructor for type YoungTableau
      * "youngTableau(Partition,List)" -- see youngTableau,
        -- constructor for type YoungTableau

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:12:0.

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

  * Usage:
        allSemistandardTableaux(lam,mu,N)
  * 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.
  * 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
===========

+-----------------------------------------------------------------------------+
|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                                                     |
+--------------------------------------------------------------+

See also
========

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

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

  * "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:1146:0.

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

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

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

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

See also
========

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

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

  * "applyEntries(SkewTableau,Function)"

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

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

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

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

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

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

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

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

See also
========

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

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

  * "applyPositions(SkewTableau,Function)"

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

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

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

The source of this document is in Tableaux/documentation.m2:828: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 = skewTableau(new Partition from {6,6,5,3,1}, new Partition from      |
|                                                                             |
|             ┌───┬───┬───┬───┐                                               |
|o1 =         │   │   │   │   │                                               |
|         ┌───┼───┼───┼───┼───┤                                               |
|         │   │   │   │   │   │                                               |
|         ├───┼───┼───┼───┼───┘                                               |
|         │   │   │   │   │                                                   |
|     ┌───┼───┼───┼───┴───┘                                                   |
|     │   │   │   │                                                           |
|     ├───┼───┴───┘                                                           |
|     │   │                                                                   |
|     └───┘                                                                   |
|                                                                             |
|o1 : SkewTableau                                                             |
|-----------------------------------------------------------------------------|
|{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 : SkewTableau                                                             |
+-----------------------------------------------------------------------------+

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:1054:0.

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

  * Usage:
        columnEntries(T,j)
        columnEntries(j,T)
  * Inputs:
      * T, an instance of the type SkewTableau, 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 = skewTableau(new Partition from {6,3,2}, new Partition from {2},     |
|                                                                             |
|             ┌───┬───┬───┬───┐                                               |
|o1 =         │ 1 │ 2 │ 3 │ 4 │                                               |
|     ┌───┬───┼───┼───┴───┴───┘                                               |
|     │ 5 │ 6 │ 7 │                                                           |
|     ├───┼───┼───┘                                                           |
|     │ 8 │ 9 │                                                               |
|     └───┴───┘                                                               |
|                                                                             |
|o1 : SkewTableau                                                             |
|-----------------------------------------------------------------------------|
|toList(1..9))                                                                |
+-----------------------------------------------------------------------------+
|i2 : columnEntries(T,0)                                                      |
|                                                                             |
|o2 = {5, 8}                                                                  |
|                                                                             |
|o2 : List                                                                    |
+-----------------------------------------------------------------------------+
|i3 : T_0                                                                     |
|                                                                             |
|o3 = {, 5, 8}                                                                |
|                                                                             |
|o3 : List                                                                    |
+-----------------------------------------------------------------------------+

See also
========

  * SkewTableau _ ZZ -- get the entries in a column.

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

  * "columnEntries(SkewTableau,ZZ)"
  * "columnEntries(ZZ,SkewTableau)"

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

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

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

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

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

  * Usage:
        columnRange T
  * Inputs:
      * T, an instance of the type SkewTableau, 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 = skewTableau(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 : SkewTableau                                                             |
|-----------------------------------------------------------------------------|
|{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
========

  * SkewTableau _ 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(SkewTableau)"

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

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

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

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

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

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

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

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

See also
========

  * SkewTableau ++ SkewTableau -- direct sum
    of tableaux

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

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

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

conjugate(SkewTableau) -- conjugate a tableau
*********************************************

  * Function: conjugate (Macaulay2Doc),
  * Usage:
        conjugate T
  * Inputs:
      * T, an instance of the type SkewTableau, a tableau.
  * Outputs:
      * S, an instance of the type SkewTableau, 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 = skewTableau(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 : SkewTableau                                                             |
|-----------------------------------------------------------------------------|
|{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 : SkewTableau                                                             |
+-----------------------------------------------------------------------------+

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

  * conjugate(SkewTableau) -- conjugate a
    tableau
-------------------------------------------------------------------------------

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

entries(SkewTableau) -- the filling of a skew tableau
*****************************************************

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

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

This returns the filling as a list.

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

See also
========

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

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

  * entries(SkewTableau) -- the filling of a
    skew tableau
-------------------------------------------------------------------------------

The source of this document is in Tableaux/documentation.m2:359: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 SkewTableau, a skew
        tableau.
  * Outputs:
      * n, a net (Macaulay2Doc), a representation of the Ferrers
        diagram of shape $\lambda/\mu$.

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

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

See also
========

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

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

  * "ferrersDiagram(Partition)"
  * "ferrersDiagram(Partition,Partition)"
  * "ferrersDiagram(SkewTableau)"

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

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

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

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

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

  * Usage:
        hookLength(thePosition,T)
  * Inputs:
      * thePosition, a sequence (Macaulay2Doc), a pair (i,j) of
        integers.
      * T, an instance of the type SkewTableau, a tableau.
  * Outputs:
      * n, an integer (Macaulay2Doc), the hook length of box (i,j) in
        T.

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 = skewTableau(new Partition from {6,6,5,3,1}, new Partition from      |
|                                                                             |
|             ┌───┬───┬───┬───┐                                               |
|o1 =         │   │   │   │   │                                               |
|         ┌───┼───┼───┼───┼───┤                                               |
|         │   │   │   │   │   │                                               |
|         ├───┼───┼───┼───┼───┘                                               |
|         │   │   │   │   │                                                   |
|     ┌───┼───┼───┼───┴───┘                                                   |
|     │   │   │   │                                                           |
|     ├───┼───┴───┘                                                           |
|     │   │                                                                   |
|     └───┘                                                                   |
|                                                                             |
|o1 : SkewTableau                                                             |
|-----------------------------------------------------------------------------|
|{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 : SkewTableau                                                             |
+-----------------------------------------------------------------------------+

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

  * "hookLength(Sequence,SkewTableau)"

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

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

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

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

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

  * Usage:
        isNonnegative T
        isNonnegative (lam,mu)
        isNonnegative lam
  * Inputs:
      * T, an instance of the type SkewTableau, 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 skewTableau(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(SkewTableau)"

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

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

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

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

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

  * Usage:
        isWeaklyDecreasing T
        isWeaklyDecreasing (lam,mu)
        isWeaklyDecreasing lam
  * Inputs:
      * T, an instance of the type SkewTableau, 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 skewTableau(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(SkewTableau)"

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

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

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

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

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

  * Function: numColumns (Macaulay2Doc),
  * Usage:
        numColumns T
  * Inputs:
      * T, an instance of the type SkewTableau, 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                                                    |
+----------------------------------------------------------------------------+
|i2 : T = skewTableau(new Partition from {4,3,1}, new Partition from {1,1,1})|
|                                                                            |
|         ┌───┬───┬───┐                                                      |
|o2 =   ■ │   │   │   │                                                      |
|         ├───┼───┼───┘                                                      |
|       ■ │   │   │                                                          |
|         └───┴───┘                                                          |
|       ■                                                                    |
|                                                                            |
|                                                                            |
|o2 : SkewTableau                                                            |
+----------------------------------------------------------------------------+
|i3 : numColumns T                                                           |
|                                                                            |
|o3 = 3                                                                      |
+----------------------------------------------------------------------------+

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

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

See also
========

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

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

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

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

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

  * Function: numRows (Macaulay2Doc),
  * Usage:
        numRows T
  * Inputs:
      * T, an instance of the type SkewTableau, 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 = skewTableau(new Partition from {4,3,1,0}, new Partition from        |
|                                                                             |
|         ┌───┬───┬───┐                                                       |
|o1 =     │   │   │   │                                                       |
|         ├───┼───┼───┘                                                       |
|         │   │   │                                                           |
|         ├───┼───┤                                                           |
|         │░░░│░░░│                                                           |
|     ┌───┼───┼───┘                                                           |
|     │░░░│░░░│                                                               |
|     └───┴───┘                                                               |
|                                                                             |
|o1 : SkewTableau                                                             |
|-----------------------------------------------------------------------------|
|{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(SkewTableau) -- the number
    of columns in a tableau

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

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

The source of this document is in Tableaux/documentation.m2:405: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

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:1174:0.

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

  * Usage:
        positionList T
  * Inputs:
      * T, an instance of the type SkewTableau, a tableau.
  * Outputs:
      * l, a list (Macaulay2Doc), the positions (i,j) of boxes in
        T.

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

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

+-----------------------------------------------------------------------------+
|i1 : T = skewTableau(new Partition from {6,3,2}, new Partition from {2},     |
|                                                                             |
|               ┌────┬────┬────┬────┐                                         |
|o1 =           │ 10 │ 11 │ 12 │ 13 │                                         |
|     ┌────┬────┼────┼────┴────┴────┘                                         |
|     │ 14 │ 15 │ 16 │                                                        |
|     ├────┼────┼────┘                                                        |
|     │ 17 │ 18 │                                                             |
|     └────┴────┘                                                             |
|                                                                             |
|o1 : SkewTableau                                                             |
|-----------------------------------------------------------------------------|
|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' = skewTableau(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 : SkewTableau                                                             |
|-----------------------------------------------------------------------------|
|theList)                                                                     |
+-----------------------------------------------------------------------------+

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(SkewTableau)"

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

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

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

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

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

  * Usage:
        rowEntries(T,i)
        rowEntries(i,T)
  * Inputs:
      * T, an instance of the type SkewTableau, 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 = skewTableau(new Partition from {6,3,2}, new Partition from {2},     |
|                                                                             |
|             ┌───┬───┬───┬───┐                                               |
|o1 =         │ 1 │ 2 │ 3 │ 4 │                                               |
|     ┌───┬───┼───┼───┴───┴───┘                                               |
|     │ 5 │ 6 │ 7 │                                                           |
|     ├───┼───┼───┘                                                           |
|     │ 8 │ 9 │                                                               |
|     └───┴───┘                                                               |
|                                                                             |
|o1 : SkewTableau                                                             |
|-----------------------------------------------------------------------------|
|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
========

  * SkewTableau ^ ZZ -- get the entries in a row.

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

  * "rowEntries(SkewTableau,ZZ)"
  * "rowEntries(ZZ,SkewTableau)"

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

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

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

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

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

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

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

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

+-----------------------------------------------------------------------------+
|i1 : T = skewTableau(new Partition from {5,4,2,1,0,0}, new Partition from    |
|                                                                             |
|             ┌───┬───┬───┐                                                   |
|o1 =         │ 1 │ 2 │ 3 │                                                   |
|             ├───┼───┼───┘                                                   |
|             │ 4 │ 5 │                                                       |
|             └───┴───┘                                                       |
|                                                                             |
|     ┌───┐                                                                   |
|     │ 6 │                                                                   |
|     └───┘                                                                   |
|                                                                             |
|o1 : SkewTableau                                                             |
|-----------------------------------------------------------------------------|
|{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
========

  * SkewTableau ^ 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(SkewTableau)"

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

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

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

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

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

  * Usage:
        lam = shape T
  * Inputs:
      * T, an instance of the type SkewTableau, 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
truncate on the partition.

+-----------------------+
|i3 : truncate 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:335:0.

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

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

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

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

See also
========

  * unshift -- unshift a tableau

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

  * "shift(SkewTableau)"
  * "shift(SkewTableau,ZZ)"

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

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

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

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

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

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

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

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

See also
========

  * entries(SkewTableau) -- the filling of a
    skew tableau

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

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

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

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

  * Usage:
        (lam,mu) = skewShape T
  * Inputs:
      * T, an instance of the type SkewTableau, 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 = skewTableau(new Partition from {4,3,1,0}, new Partition from {2,1}, |
|                                                                             |
|             ┌───┬───┐                                                       |
|o1 =         │ 1 │ 2 │                                                       |
|         ┌───┼───┼───┘                                                       |
|         │ 3 │ 4 │                                                           |
|     ┌───┼───┴───┘                                                           |
|     │ 5 │                                                                   |
|     └───┘                                                                   |
|                                                                             |
|o1 : SkewTableau                                                             |
|-----------------------------------------------------------------------------|
|{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
truncate on a sequence of two partitions.

+------------------------------------------+
|i3 : truncate 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

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

  * "skewShape(SkewTableau)"

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

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

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

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

SkewTableau -- a type of HashTable representing a skew Young tableau
********************************************************************

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

An object of type SkewTableau 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 = skewTableau(lam,mu,entryList)|
|                                      |
|                 ┌───┐                |
|o4 =             │ 1 │                |
|         ┌───┬───┼───┘                |
|         │ 2 │ 3 │                    |
|     ┌───┼───┼───┘                    |
|     │ 3 │ 9 │                        |
|     └───┴───┘                        |
|                                      |
|o4 : SkewTableau                      |
+--------------------------------------+

See also
========

  * skewTableau -- constructor for type SkewTableau
  * YoungTableau -- a type of HashTable representing a
    (nonskew) Young tableau

Types of SkewTableau:
=====================

  * YoungTableau -- a type of HashTable representing a
    (nonskew) Young tableau

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

  * applyEntries -- apply a function to all entries in the
    tableau
  * applyPositions -- apply a function to all positions
    of boxes in a tableau
  * shift -- shift a tableau
  * skewTableau -- constructor for type SkewTableau
  * unshift -- unshift a tableau
  * verticalConcatenate -- vertical concatenation
    of a list of tableaux

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

  * "applyEntries(SkewTableau,Function)" -- see applyEntries,
    -- apply a function to all entries in the tableau
  * "applyPositions(SkewTableau,Function)" -- see applyPositions,
    -- apply a function to all positions of boxes in a tableau
  * "columnEntries(SkewTableau,ZZ)" -- see columnEntries,
    -- get the entries in a column.
  * "columnEntries(ZZ,SkewTableau)" -- see columnEntries,
    -- get the entries in a column.
  * "columnRange(SkewTableau)" -- see columnRange, -- the
    range of column indices of a tableau.
  * components(SkewTableau) -- get the
    connected components of a tableau
  * conjugate(SkewTableau) -- conjugate a
    tableau
  * entries(SkewTableau) -- the filling of a
    skew tableau
  * "ferrersDiagram(SkewTableau)" -- see ferrersDiagram,
    -- a net of the Ferrers diagram
  * "hookLength(Sequence,SkewTableau)" -- see hookLength, --
    compute the hook length of a box of a tableau
  * "isNonnegative(SkewTableau)" -- see isNonnegative, --
    check if shapes are nonnegative
  * "isWeaklyDecreasing(SkewTableau)" -- see isWeaklyDecreasing,
    -- check if shapes are weakly decreasing
  * numColumns(SkewTableau) -- the number
    of columns in a tableau
  * numRows(SkewTableau) -- the number of rows
    in a tableau
  * "positionList(SkewTableau)" -- see positionList, -- get
    the positions of all the boxes in a tableau
  * "rowEntries(SkewTableau,ZZ)" -- see rowEntries, -- get
    the entries in a row.
  * "rowEntries(ZZ,SkewTableau)" -- see rowEntries, -- get
    the entries in a row.
  * "rowRange(SkewTableau)" -- see rowRange, -- the range of
    row indices of a tableau.
  * "shift(SkewTableau)" -- see shift, -- shift a tableau
  * "shift(SkewTableau,ZZ)" -- see shift, -- shift a tableau
  * size(SkewTableau) -- the number of boxes in a
    skew tableau
  * "skewShape(SkewTableau)" -- see skewShape, -- the shape of
    a skew tableau
  * "net(SkewTableau)"
  * SkewTableau ++ SkewTableau -- direct sum
    of tableaux
  * SkewTableau ^ ZZ -- get the entries in a row.
  * SkewTableau _ Sequence -- get the entry at
    a specific position.
  * SkewTableau _ ZZ -- get the entries in a column.
  * SkewTableau || SkewTableau -- vertical
    concatenation of two tableaux
  * tex(SkewTableau) -- LaTeX output for a skew
    tableau
  * "toIndex(Sequence,SkewTableau)" -- see toIndex, -- get the
    index of a box, given its position.
  * "toIndex(SkewTableau,Sequence)" -- see toIndex, -- get the
    index of a box, given its position.
  * "toPosition(SkewTableau,ZZ)" -- see toPosition, -- get
    the position of a box, given its index.
  * "toPosition(ZZ,SkewTableau)" -- see toPosition, -- get
    the position of a box, given its index.
  * "unshift(SkewTableau)" -- see unshift, -- unshift a tableau
  * "unshift(SkewTableau,ZZ)" -- see unshift, -- unshift a
    tableau
  * "youngDiagram(SkewTableau)" -- see youngDiagram, -- a
    net of the Young diagram

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

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

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

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

skewTableau -- constructor for type SkewTableau
***********************************************

  * Usage:
        skewTableau(lam, mu, entryList)
        skewTableau((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 SkewTableau, 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 = skewTableau(lam,mu,entryList)|
|                                      |
|                 ┌───┐                |
|o4 =             │ 1 │                |
|         ┌───┬───┼───┘                |
|         │ 2 │ 3 │                    |
|     ┌───┼───┼───┘                    |
|     │ 3 │ 9 │                        |
|     └───┴───┘                        |
|                                      |
|o4 : SkewTableau                      |
+--------------------------------------+

We may construct tableaux with any compositions.

+-----------------------------------------------------------------------------+
|i5 : skewTableau(new Partition from {3,5,1}, new Partition from {0,1},       |
|                                                                             |
|     ┌───┬───┬───┐                                                           |
|o5 = │ 7 │ & │ 4 │                                                           |
|     └───┼───┼───┼───┬───┐                                                   |
|         │ 2 │ g │ u │ 6 │                                                   |
|     ┌───┼───┴───┴───┴───┘                                                   |
|     │ 0 │                                                                   |
|     └───┘                                                                   |
|                                                                             |
|o5 : SkewTableau                                                             |
|-----------------------------------------------------------------------------|
|{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 : skewTableau(new Partition from {3,-3,-1}, new Partition from {-2,-4,-1})|
|                                                                             |
|             ┌───┬───║───┬───┬───┐                                           |
|o6 =         │   │   ║   │   │   │                                           |
|     ┌───┐   └───┴───║───┴───┴───┘                                           |
|     │   │           ║                                                       |
|     └───┘           ║                                                       |
|                     ║                                                       |
|                     ║                                                       |
|                                                                             |
|o6 : SkewTableau                                                             |
+-----------------------------------------------------------------------------+

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

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

We may cast an object of type YoungTableau, to type
SkewTableau.

+--------------------------------------------------+
|i8 : T' = youngTableau(new Partition from {3,1,1})|
|                                                  |
|     ┌───┬───┬───┐                                |
|o8 = │   │   │   │                                |
|     ├───┼───┴───┘                                |
|     │   │                                        |
|     ├───┤                                        |
|     │   │                                        |
|     └───┘                                        |
|                                                  |
|o8 : YoungTableau                                 |
+--------------------------------------------------+
|i9 : skewTableau T'                               |
|                                                  |
|     ┌───┬───┬───┐                                |
|o9 = │   │   │   │                                |
|     ├───┼───┴───┘                                |
|     │   │                                        |
|     ├───┤                                        |
|     │   │                                        |
|     └───┘                                        |
|                                                  |
|o9 : SkewTableau                                  |
+--------------------------------------------------+

The inner shape may be drawn by calling drawInnerShape.

+-----------------------------------------------------------------------------+
|i10 : T'' = skewTableau(new Partition from {5,4,-1}, new Partition from      |
|                                                                             |
|                  ║       ┌───┬───┬───┐                                      |
|o10 =             ║       │   │   │   │                                      |
|                  ║       └───┴───┴───┘                                      |
|                  ║                                                          |
|      ┌───┬───┐   ║                                                          |
|      │   │   │   ║                                                          |
|      └───┴───┘   ║                                                          |
|                                                                             |
|o10 : SkewTableau                                                            |
|-----------------------------------------------------------------------------|
|{2,4,-3})                                                                    |
+-----------------------------------------------------------------------------+
|i11 : drawInnerShape true                                                    |
+-----------------------------------------------------------------------------+
|i12 : T''                                                                    |
|                                                                             |
|                  ║       ┌───┬───┬───┐                                      |
|o12 =             ║ ■   ■ │   │   │   │                                      |
|                  ║       └───┴───┴───┘                                      |
|                  ║ ■   ■   ■   ■                                            |
|      ┌───┬───┐   ║                                                          |
|      │   │   │ ■ ║                                                          |
|      └───┴───┘   ║                                                          |
|                                                                             |
|o12 : SkewTableau                                                            |
+-----------------------------------------------------------------------------+
|i13 : drawInnerShape false                                                   |
+-----------------------------------------------------------------------------+
|i14 : T''                                                                    |
|                                                                             |
|                  ║       ┌───┬───┬───┐                                      |
|o14 =             ║       │   │   │   │                                      |
|                  ║       └───┴───┴───┘                                      |
|                  ║                                                          |
|      ┌───┬───┐   ║                                                          |
|      │   │   │   ║                                                          |
|      └───┴───┘   ║                                                          |
|                                                                             |
|o14 : SkewTableau                                                            |
+-----------------------------------------------------------------------------+

See also
========

  * SkewTableau -- a type of HashTable representing a skew
    Young tableau
  * YoungTableau -- a type of HashTable representing a
    (nonskew) Young tableau
  * youngTableau -- constructor for type YoungTableau

Ways to use skewTableau:
========================

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

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

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

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

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

SkewTableau ++ SkewTableau -- direct sum of tableaux
****************************************************

  * Operator: ++ (Macaulay2Doc),
  * Usage:
        T1 ++ T2
  * Inputs:
      * T1, an instance of the type SkewTableau, a tableau.
      * T2, an instance of the type SkewTableau, a tableau.
  * Outputs:
      * S, an instance of the type SkewTableau, 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 = skewTableau(new Partition from {5}, new Partition from {2})        |
|                                                                             |
|             ┌───┬───┬───┐                                                   |
|o1 =         │   │   │   │                                                   |
|             └───┴───┴───┘                                                   |
|                                                                             |
|o1 : SkewTableau                                                             |
+-----------------------------------------------------------------------------+
|i2 : T2 = skewTableau(new Partition from {3,2}, new Partition from {1},      |
|                                                                             |
|         ┌───┬───┐                                                           |
|o2 =     │ 1 │ 2 │                                                           |
|     ┌───┼───┼───┘                                                           |
|     │ 3 │ 4 │                                                               |
|     └───┴───┘                                                               |
|                                                                             |
|o2 : SkewTableau                                                             |
|-----------------------------------------------------------------------------|
|{1,2,3,4})                                                                   |
+-----------------------------------------------------------------------------+
|i3 : T1 ++ T2                                                                |
|                                                                             |
|                 ┌───┬───┬───┐                                               |
|o3 =             │   │   │   │                                               |
|         ┌───┬───┼───┴───┴───┘                                               |
|         │ 1 │ 2 │                                                           |
|     ┌───┼───┼───┘                                                           |
|     │ 3 │ 4 │                                                               |
|     └───┴───┘                                                               |
|                                                                             |
|o3 : SkewTableau                                                             |
+-----------------------------------------------------------------------------+
|i4 : T2 ++ T1                                                                |
|                                                                             |
|                             ┌───┬───┐                                       |
|o4 =                         │ 1 │ 2 │                                       |
|                         ┌───┼───┼───┘                                       |
|                         │ 3 │ 4 │                                           |
|             ┌───┬───┬───┼───┴───┘                                           |
|             │   │   │   │                                                   |
|             └───┴───┴───┘                                                   |
|                                                                             |
|o4 : SkewTableau                                                             |
+-----------------------------------------------------------------------------+

See also
========

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

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

  * SkewTableau ++ SkewTableau -- direct sum
    of tableaux
-------------------------------------------------------------------------------

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

SkewTableau ^ ZZ -- get the entries in a row.
*********************************************

  * Operator: ^ (Macaulay2Doc),
  * Usage:
        T^i
  * Inputs:
      * T, an instance of the type SkewTableau, 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 = skewTableau(new Partition from {4,3,1,0}, new Partition from {1,1}, |
|                                                                             |
|         ┌───┬───┬───┐                                                       |
|o1 =     │ 1 │ 2 │ 3 │                                                       |
|         ├───┼───┼───┘                                                       |
|         │ 4 │ 5 │                                                           |
|     ┌───┼───┴───┘                                                           |
|     │ 6 │                                                                   |
|     └───┘                                                                   |
|                                                                             |
|o1 : SkewTableau                                                             |
|-----------------------------------------------------------------------------|
|{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' = skewTableau(new Partition from {4,3,1,0}, new Partition from       |
|                                                                             |
|         ║   ┌───┬───┬───┐                                                   |
|o6 =     ║   │ 1 │ 2 │ 3 │                                                   |
|     ┌───║───┼───┼───┼───┘                                                   |
|     │ 4 ║ 5 │ 6 │ 7 │                                                       |
|     └───║───┼───┴───┘                                                       |
|         ║ 8 │                                                               |
|         ║───┘                                                               |
|                                                                             |
|o6 : SkewTableau                                                             |
|-----------------------------------------------------------------------------|
|{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'' = skewTableau(new Partition from {3,4}, new Partition from {-2},   |
|                                                                             |
|      ┌───┬───║───┬───┬───┐                                                  |
|o10 = │ 1 │ 2 ║ 3 │ 4 │ 5 │                                                  |
|      └───┴───║───┼───┼───┼───┐                                              |
|              ║ 6 │ 7 │ 8 │ 9 │                                              |
|              ║───┴───┴───┴───┘                                              |
|                                                                             |
|o10 : SkewTableau                                                            |
|-----------------------------------------------------------------------------|
|{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(SkewTableau) -- the number of rows
    in a tableau
  * rowEntries -- get the entries in a row.
  * SkewTableau _ Sequence -- get the entry at
    a specific position.
  * SkewTableau _ ZZ -- get the entries in a column.

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

  * SkewTableau ^ ZZ -- get the entries in a row.
-------------------------------------------------------------------------------

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

SkewTableau _ Sequence -- get the entry at a specific position.
***************************************************************

  * Operator: _ (Macaulay2Doc),
  * Usage:
        T_seq
        T_(i,j)
  * Inputs:
      * T, an instance of the type SkewTableau, 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 = skewTableau(new Partition from {4,3,1,0}, new Partition from {1,1}, |
|                                                                             |
|         ┌───┬───┬───┐                                                       |
|o1 =     │ 1 │ 2 │ 3 │                                                       |
|         ├───┼───┼───┘                                                       |
|         │ 4 │ 5 │                                                           |
|     ┌───┼───┴───┘                                                           |
|     │ 6 │                                                                   |
|     └───┘                                                                   |
|                                                                             |
|o1 : SkewTableau                                                             |
|-----------------------------------------------------------------------------|
|{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
========

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

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

  * SkewTableau _ Sequence -- get the entry at
    a specific position.
-------------------------------------------------------------------------------

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

SkewTableau _ ZZ -- get the entries in a column.
************************************************

  * Operator: _ (Macaulay2Doc),
  * Usage:
        T_j
  * Inputs:
      * T, an instance of the type SkewTableau, 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 = skewTableau(new Partition from {4,3,1,0}, new Partition from {1,1}, |
|                                                                             |
|         ┌───┬───┬───┐                                                       |
|o1 =     │ 1 │ 2 │ 3 │                                                       |
|         ├───┼───┼───┘                                                       |
|         │ 4 │ 5 │                                                           |
|     ┌───┼───┴───┘                                                           |
|     │ 6 │                                                                   |
|     └───┘                                                                   |
|                                                                             |
|o1 : SkewTableau                                                             |
|-----------------------------------------------------------------------------|
|{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'' = skewTableau(new Partition from {3,1}, new Partition from          |
|                                                                             |
|     ┌───┬───║───┬───┬───┐                                                   |
|o6 = │ 1 │ 2 ║ 3 │ 4 │ 5 │                                                   |
|     └───┴───║───┼───┴───┘                                                   |
|             ║ 6 │                                                           |
|         ┌───║───┘                                                           |
|         │ 7 ║                                                               |
|         └───║                                                               |
|                                                                             |
|o6 : SkewTableau                                                             |
|-----------------------------------------------------------------------------|
|{-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(SkewTableau) -- the number
    of columns in a tableau
  * columnEntries -- get the entries in a column.
  * SkewTableau _ Sequence -- get the entry at
    a specific position.
  * SkewTableau ^ ZZ -- get the entries in a row.

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

  * SkewTableau _ ZZ -- get the entries in a column.
-------------------------------------------------------------------------------

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

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

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

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

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

See also
========

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

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

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

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

tex(SkewTableau) -- LaTeX output for a skew tableau
***************************************************

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

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

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

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

See also
========

  * skewTableau -- constructor for type SkewTableau
  * 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(SkewTableau) -- LaTeX output for a skew
    tableau
-------------------------------------------------------------------------------

The source of this document is in Tableaux/documentation.m2:260: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 SkewTableau, 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 = skewTableau(new Partition from {6,3,2}, new Partition from {2},     |
|                                                                             |
|               ┌────┬────┬────┬────┐                                         |
|o1 =           │ 10 │ 11 │ 12 │ 13 │                                         |
|     ┌────┬────┼────┼────┴────┴────┘                                         |
|     │ 14 │ 15 │ 16 │                                                        |
|     ├────┼────┼────┘                                                        |
|     │ 17 │ 18 │                                                             |
|     └────┴────┘                                                             |
|                                                                             |
|o1 : SkewTableau                                                             |
|-----------------------------------------------------------------------------|
|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 : skewTableau(new Partition from {6,3,2}, new Partition from {2},         |
|                                                                             |
|             ┌───┬───┬───┬───┐                                               |
|o6 =         │ 0 │ 1 │ 2 │ 3 │                                               |
|     ┌───┬───┼───┼───┴───┴───┘                                               |
|     │ 4 │ 5 │ 6 │                                                           |
|     ├───┼───┼───┘                                                           |
|     │ 7 │ 8 │                                                               |
|     └───┴───┘                                                               |
|                                                                             |
|o6 : SkewTableau                                                             |
|-----------------------------------------------------------------------------|
|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 : skewTableau(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 : SkewTableau                                                             |
|-----------------------------------------------------------------------------|
|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,SkewTableau)"
  * "toIndex(SkewTableau,Sequence)"

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

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

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

The source of this document is in Tableaux/documentation.m2:752: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 SkewTableau, 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 = skewTableau(new Partition from {6,3,2}, new Partition from {2},     |
|                                                                             |
|               ┌────┬────┬────┬────┐                                         |
|o1 =           │ 10 │ 11 │ 12 │ 13 │                                         |
|     ┌────┬────┼────┼────┴────┴────┘                                         |
|     │ 14 │ 15 │ 16 │                                                        |
|     ├────┼────┼────┘                                                        |
|     │ 17 │ 18 │                                                             |
|     └────┴────┘                                                             |
|                                                                             |
|o1 : SkewTableau                                                             |
|-----------------------------------------------------------------------------|
|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 : skewTableau(new Partition from {6,3,2}, new Partition from {2},         |
|                                                                             |
|             ┌───┬───┬───┬───┐                                               |
|o4 =         │ 0 │ 1 │ 2 │ 3 │                                               |
|     ┌───┬───┼───┼───┴───┴───┘                                               |
|     │ 4 │ 5 │ 6 │                                                           |
|     ├───┼───┼───┘                                                           |
|     │ 7 │ 8 │                                                               |
|     └───┴───┘                                                               |
|                                                                             |
|o4 : SkewTableau                                                             |
|-----------------------------------------------------------------------------|
|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 : skewTableau(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 : SkewTableau                                                             |
|-----------------------------------------------------------------------------|
|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(SkewTableau,ZZ)"
  * "toPosition(ZZ,SkewTableau)"

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

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

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

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

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

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

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

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

See also
========

  * shift -- shift a tableau

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

  * "unshift(SkewTableau)"
  * "unshift(SkewTableau,ZZ)"

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

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

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

The source of this document is in Tableaux/documentation.m2:981: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 SkewTableau, a single
        tableau with combining those in the list.

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

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

See also
========

  * SkewTableau || SkewTableau -- 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:927: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 SkewTableau, a skew
        tableau.
  * Outputs:
      * n, a net (Macaulay2Doc), a representation of the Young
        diagram of shape $\lambda/\mu$.

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

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

See also
========

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

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

  * "youngDiagram(Partition)"
  * "youngDiagram(Partition,Partition)"
  * "youngDiagram(SkewTableau)"

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

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

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

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

YoungTableau -- a type of HashTable representing a (nonskew) Young tableau
**************************************************************************

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

This is a subclass of SkewTableau. Each object of
YoungTableau is essentially just a skew tableau with inner shape $\mu=0$.

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

See also
========

  * youngTableau -- constructor for type YoungTableau
  * SkewTableau -- a type of HashTable representing a skew
    Young tableau

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

  * youngTableau -- constructor for type YoungTableau

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

  * "shape(YoungTableau)" -- see shape, -- the shape of a Young
    tableau
  * "skewTableau(YoungTableau)" -- see skewTableau, --
    constructor for type SkewTableau

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

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

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

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

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

  * Usage:
        youngTableau(lam, entryList)
  * Inputs:
      * lam, an instance of the type Partition (Macaulay2Doc),
        the shape $\lambda$.
      * 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
        (nonskew) Young tableau of shape $\lambda$ with the given filling.
  * Consequences:
      * The list of entries has length equal to
        $\sum_{i=1}^{\ell(\lambda)}|\lambda_i|$. E.g., if $\lambda=(-2)$, then
        the entry list must have length $2$.
      * None of the entries are null (Macaulay2Doc).

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

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

We may construct tableaux with any compositions.

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

The shape may have negative parts. In this case, a vertical line is drawn by
net, to indicate that negative parts are to the left. If any
$\lambda_i<0$, then the boxes in that row are drawn shaded.

+-----------------------------------------------+
|i5 : youngTableau(new Partition from {-2,-4,2})|
|                                               |
|             ┌───┬───║                         |
|o5 =         │░░░│░░░║                         |
|     ┌───┬───┼───┼───║                         |
|     │░░░│░░░│░░░│░░░║                         |
|     └───┴───┴───┴───║───┬───┐                 |
|                     ║   │   │                 |
|                     ║───┴───┘                 |
|                                               |
|o5 : YoungTableau                              |
+-----------------------------------------------+

We may cast an object of type YoungTableau to type SkewTableau.

+--------------------------------------------------+
|i6 : T' = youngTableau(new Partition from {3,1,1})|
|                                                  |
|     ┌───┬───┬───┐                                |
|o6 = │   │   │   │                                |
|     ├───┼───┴───┘                                |
|     │   │                                        |
|     ├───┤                                        |
|     │   │                                        |
|     └───┘                                        |
|                                                  |
|o6 : YoungTableau                                 |
+--------------------------------------------------+
|i7 : skewTableau T'                               |
|                                                  |
|     ┌───┬───┬───┐                                |
|o7 = │   │   │   │                                |
|     ├───┼───┴───┘                                |
|     │   │                                        |
|     ├───┤                                        |
|     │   │                                        |
|     └───┘                                        |
|                                                  |
|o7 : SkewTableau                                  |
+--------------------------------------------------+

See also
========

  * SkewTableau -- a type of HashTable representing a skew
    Young tableau
  * YoungTableau -- a type of HashTable representing a
    (nonskew) Young tableau
  * skewTableau -- constructor for type SkewTableau

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

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

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

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

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

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