[Previous] [Next] [Contents]

## `combinat::skewPartitions` -- skew partitions

#### Introduction

The library `combinat::skewPartitions` provides functions for counting, generating, and manipulating skew partitions of fixed size.

#### Details

- A skew partition skp of size n is a pair of two partitions [p1, p2] where p1 is a partition of the integer n1, p2 is a partition of the integer n2, p2 is an inner partition of p1 and n=n1-n2. We say that p1 and p2 are respectively the outer and inner partitions of skp.

- A skew partition is so represented in MuPAD by a list of two partitions:

  `[`outer`, `inner`]`.

- A skew partition can be depicted by a diagram made of rows of boxes, in the same way as a partition. Only the boxes of the outer partition p1 which are not in the inner partition p2 appear in the picture. For example, this is the diagram of the skew partition `[[5,4,3,1],[3,3,1]]`:

      +---+
      |   |
      +---+---+---+
          |   |   |
          +---+---+---+
                  |   |
                  +---+---+
                  |   |   |
                  +---+---+

  And this is not a skew partition:

      +---+
      |   |
      +---+---+---+
          |   |   |
          +---+---+

                  +---+---+
                  |   |   |
                  +---+---+

- A skew partition can be connected, which can be easily described in graphic terms: for each pair of consecutive rows, there are at least two boxes (one in each row) which have a common edge. This is the the diagram of the connected skew partition `[[5,4,3,1],[3,1]]`:

      +---+
      |   |
      +---+---+---+
      |   |   |   |
      +---+---+---+---+
          |   |   |   |
          +---+---+---+---+
                  |   |   |
                  +---+---+

  And our first example of skew partition is not a connected one.

- To apply a reflection w.r.t. the main diagonal to the diagram yields the diagram of the conjugate skew partition, here `[[4,3,3,2,1],[3,2,2]]`:

      +---+
      |   |
      +---+---+
      |   |   |
      +---+---+---+
              |   |
              +---+
              |   |
              +---+---+
                  |   |
                  +---+

  See `combinat::skewPartitions::conjugate`.

- The outer corners of a skew partition are the corners of its outer partition. The inner corners are the internal corners of the outer partition when the inner partition is taken off. See the examples below.

#### Categories

`Cat::CombinatorialClass`

#### Related Domains

`combinat::partitions`

#### Entries

domtype

The MuPAD domain of skew partitions: `DOM_LIST`

typeConnected

The MuPAD type of connected skew partitions.

#### Method isA: test if a object is a skew partition

- `isA(any type skp <, nonnegative integer n> <, Connected>)`

- Tests whether `skp` is a skew partition. The second argument is either Connectedor a non negative integer. In the case it is a non negative integer, it indicates the size of the skew partition and the function tests if `skp` is a skew partition of size `n`, and if it is Connectedthe function tests whether `skp` is a connected skew partition. With three arguments it is possible to tests if `skp` is a connected skew partition of size `n`.

#### Method count: number of skew partitions

- `count(nonnegative integer n <, Connected>)`

- Returns the number of skew partitions of size `n`. The result counts only the connected skew partitions if it is said so.

#### Method generator: generator for skew partitions

- `generator(nonnegative integer n <, Connected>)`

- Returns a generator for the skew partitions of size `n`. The result gives access only to connected skew partitions if it is said so.

#### Method list: list of the skew partitions

- `list(nonnegative integer n <, Connected>)`

- Returns the list of the skew partitions of size `n`. The result is a list of connected skew partitions if it is said so.

#### Method conjugate: conjugate of a skew partition

- `conjugate(skew partition skp)`

- Returns the conjugate (or transposed) of the skew partition `skp`. Geometrically, this operation amounts to a reflection of the diagram of the partition with respect to the main diagonal.

#### Method jacobiTrudy: Jacoby-Trudi formula

- `jacobiTrudy(skew partition skp <, function>)`

- This function compute the Jacobi-Trudy matrix associated to the skew partition `skp`. Its determinant express the skew Schur polynomial associated to `skp` on the basis of homogenous complete symmetric polynomial (see Macdonald I.-G., (1995), "Symmetric Functions and Hall Polynomials", Oxford Science Publication). The default value of the `function` argument is `i -> h[i]`.

#### Method innerCorners: inner corners of a skew partition

- `innerCorners(skew partition skp)`

- Returns the list of coordinates of the inner corner boxes in the diagram of the skew partition.

#### Method outerCorners: outer corners of a skew partition

- `outerCorners(skew partition skp)`

- Returns the list of coordinates of the outer corner boxes in the diagram of the skew partition, i.e. the corners of the outer partition of `skp`.

#### Method printPretty: graphic representation of a skew partition

- `printPretty(skew partition skp)`

- Returns a graphic representation of the skew partition as rows of boxes.

#### Method printCompact: graphic representation of a skew partition

- `printCompact(skew partition skp)`

- Same as above, but in a more compact way, where each box is represented by `#`.

#### Method printPrettyCorners: graphic representation of inner and outer corners of a skew partition

- `printPrettyCorners(skew partition skp)`

- Returns a graphic representation of the skew partition as rows of boxes where inner corners are marked with `x` and outer corners are marked with `*`. A `%` marks a corner which is inner and outer at the same time.

#### Method printCompactCorners: graphic representation of inner and outer corners of a skew partition

- `printCompactCorners(skew partition skp)`

- Same as above, but in a more compact way, where each box is represented by `#`, and `x`, `*`, `%` mark the corners.

#### Example 1

There are 9 skew partitions of size 3:

    >> combinat::skewPartitions::count(3)

                                         9

Here is the list:

    >> combinat::skewPartitions::list(3)

          [[[3], []], [[2, 1], []], [[3, 1], [1]], [[2, 2], [1]],

             [[3, 2], [2]], [[1, 1, 1], []], [[2, 2, 1], [1, 1]],

             [[2, 1, 1], [1]], [[3, 2, 1], [2, 1]]]

Here is a graphic representation of the list:

    >> map(combinat::skewPartitions::list(3),
       combinat::skewPartitions::printCompact)

                    --      #   #    ##  ##   #  #   #   #   --
                    |  ###, ##,  ##,  #,   #, #,  #, # ,  #   |
                    --                        #   #   #    # --

There are 4 connected skew partitions of size 3:

    >> combinat::skewPartitions::count(3, Connected)

                                         4

Here is the list:

    >> combinat::skewPartitions::list(3, Connected)

             [[[3], []], [[2, 1], []], [[2, 2], [1]], [[1, 1, 1], []]]

Here is a graphic representation of the list:

    >> map(combinat::skewPartitions::list(3, Connected),
       combinat::skewPartitions::printPretty)

                 --                                      +---+ --
                 |                 +---+      +---+---+  |   |  |
                 |  +---+---+---+  |   |      |   |   |  +---+  |
                 |  |   |   |   |, +---+---+, +---+---+, |   |  |
                 |  +---+---+---+  |   |   |      |   |  +---+  |
                 |                 +---+---+      +---+  |   |  |
                 --                                      +---+ --

When you want to run through the skew partitions of a given size, you can generate them one by one to save memory:

    >> g := combinat::skewPartitions::generator(3):
       g(); g(); g(); g(); g(); g(); g(); g(); g(); g()

                                     [[3], []]

                                   [[2, 1], []]

                                   [[3, 1], [1]]

                                   [[2, 2], [1]]

                                   [[3, 2], [2]]

                                  [[1, 1, 1], []]

                                [[2, 2, 1], [1, 1]]

                                 [[2, 1, 1], [1]]

                                [[3, 2, 1], [2, 1]]

                                       FAIL

It is also possible to generate connected skew partitions of a given size:

    >> g := combinat::skewPartitions::generator(3, Connected):
       g(); g(); g(); g(); g()

                                     [[3], []]

                                   [[2, 1], []]

                                   [[2, 2], [1]]

                                  [[1, 1, 1], []]

                                       FAIL

Typically, this would be used as follows:

    >> g := combinat::skewPartitions::generator(3, Connected):
       while (p := g()) <> FAIL do print(p): end:

                                     [[3], []]

                                   [[2, 1], []]

                                   [[2, 2], [1]]

                                  [[1, 1, 1], []]

#### Example 2

This is the conjugate of the skew partition `[[4, 3, 1], [2]]`:

    >> combinat::skewPartitions::conjugate([[4, 3, 1], [2]])

                              [[3, 2, 2, 1], [1, 1]]

Geometrically, we just applied a reflection with respect to the main diagonal on the diagram of the partition. Of course, this operation is an involution:

    >> combinat::skewPartitions::conjugate([[3, 2, 2, 1], [1, 1]])

                                 [[4, 3, 1], [2]]

#### Example 3

The `"jacobiTrudy"` function compute the Jacobi-Trudy matrix, see Macdonald I.-G., (1995), "Symmetric Functions and Hall Polynomials", Oxford Science Publication.

    >> combinat::skewPartitions::jacobiTrudy([[4, 3, 1], [2]])

                              +-                  -+
                              |  h[2], h[0],   0   |
                              |                    |
                              |  h[5], h[3], h[0]  |
                              |                    |
                              |  h[6], h[4], h[1]  |
                              +-                  -+

    >> combinat::skewPartitions::jacobiTrudy([[4, 3, 1], [2]], T)

                              +-                  -+
                              |  T(2), T(0),   0   |
                              |                    |
                              |  T(5), T(3), T(0)  |
                              |                    |
                              |  T(6), T(4), T(1)  |
                              +-                  -+

#### Example 4

This example shows how to compute the corners of a skew partition.

    >> combinat::skewPartitions::innerCorners([[4, 3, 1], [2]])

                                 [[1, 3], [2, 1]]

    >> combinat::skewPartitions::outerCorners([[4, 3, 1], [2]])

                             [[1, 4], [2, 3], [3, 1]]

The inner and outer corners can be represented graphically:

    >> combinat::skewPartitions::printPrettyCorners([[4, 3, 1], [2]])

                                 +---+
                                 | * |
                                 +---+---+---+
                                 | x |   | * |
                                 +---+---+---+---+
                                         | x | * |
                                         +---+---+

Sometimes inner and outer corners coincide:

    >> combinat::skewPartitions::printPrettyCorners([[4, 3, 1], [3]])

                                 +---+
                                 | * |
                                 +---+---+---+
                                 | x |   | * |
                                 +---+---+---+---+
                                             | % |
                                             +---+

Or we can prefer a more compact representation:

    >> combinat::skewPartitions::printPrettyCorners(
       [[9, 8, 4, 3, 1], [6, 4, 3, 1]])

                       +---+
                       | % |
                       +---+---+---+
                           | x | * |
                           +---+---+---+
                                   | % |
                                   +---+---+---+---+---+
                                       | x |   |   | * |
                                       +---+---+---+---+---+
                                               | x |   | * |
                                               +---+---+---+

    >> combinat::skewPartitions::printCompactCorners(
       [[9, 8, 4, 3, 1], [6, 4, 3, 1]])

                                     %
                                      x*
                                        %
                                         x##*
                                           x#*

#### Super-Domain

`Dom::BaseDomain`

#### Axioms

`Ax::systemRep`

#### Changes

- `combinat::skewPartitions` is a new library

[Previous] [Next] [Contents]

MuPAD Combinat, an open source algebraic combinatorics package