[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

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

Method count: number of skew partitions

Method generator: generator for skew partitions

Method list: list of the skew partitions

Method conjugate: conjugate of a skew partition

Method jacobiTrudy: Jacoby-Trudi formula

Method innerCorners: inner corners of a skew partition

Method outerCorners: outer corners of a skew partition

Method printPretty: graphic representation of a skew partition

Method printCompact: graphic representation of a skew partition

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

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

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

[Previous] [Next] [Contents]


MuPAD Combinat, an open source algebraic combinatorics package