combinat::tableaux – Young tableaux

The library combinat::tableaux provides functions for counting, generating, and manipulating Young tableaux.

→ Examples

Creating Elements

combinat::tableaux(filling)

Parameters:

filling

the filling of the tableau, given as a list of lists, from the top row to the bottom row.

Superdomain

Dom::BaseDomain

Categories

Cat::CombinatorialClassWith2DBoxedRepresentation, Cat::GradedCombinatorialClass

See Also:

combinat::partitions, combinat::words

Details:

Entries

"domtype"

The MuPAD domain used to represent tableaux: DOM_LIST.

"typeStandard"

The MuPAD type used to represent standard tableaux.

isA – test if an object is a tableau

combinat::tableaux::isA(tableau t)

combinat::tableaux::isA(tableau t, partition shp)

combinat::tableaux::isA(tableau t, nonnegative integer siz)

Returns whether t is a tableau or not.

If the optional argument is present, returns whether t is a tableau of shape shape or of size siz.

isAStandardTableau – test if an object is a standard tableau

combinat::tableaux::isAStandardTableau(tableau t)

combinat::tableaux::isAStandardTableau(tableau t, partition shp)

combinat::tableaux::isAStandardTableau(tableau t, nonnegative integer siz)

Returns whether t is a standard tableau or not.

If the optional argument is present, returns whether t is a standard tableau of shape shape or of size siz.

shape – the shape of a tableau

combinat::tableaux::shape(tableau t)

Returns the shape of the tableau t.

size – the size of a tableau

combinat::tableaux::size(tableau t)

Returns the size of the tableau t.

height – the height of a tableau

combinat::tableaux::height(tableau t)

Returns the height of tableau t.

corners – the corners of a tableau

combinat::tableaux::corners(tableau t)

Returns the list of the corners of tableau t.

heights – the heights of a tableau

combinat::tableaux::heights(tableau t)

Returns the list of the heights of tableau t.

toWord – natural reading of a tableau

combinat::tableaux::toWord(tableau t)

Returns the natural row reading of the tableau t, from top to bottom, and from left to right.

fromWord – tableau from its natural reading

combinat::tableaux::fromWord(word w)

Returns the list of increasing subsequences of w. Beware, if w is a natural reading of a tableau, one recovers the tableau, but if it is not the case, the result is not necessarily a tableau.

fromShapeAndWord – tableau from its shape and natural reading

combinat::tableaux::fromShapeAndWord(partition shape, word w)

Returns the filling of the shape shape whose natural reading is the word w. Beware, the result is not necessarily a tableau.

fromEvaluation – tableau from its given evaluation

combinat::tableaux::fromEvaluation(compositions eva)

combinat::tableaux::fromEvaluation(nonnegative integer size)

Returns the tableau of evaluation eva and natural reading [length(eva),...,length(eva),...,2,..,2,1,..,1].

If the size of the tableau is given, this function returns the tableau of natural reading [size,...,2,1].

count – number of tableaux

combinat::tableaux::count(partition shape)

combinat::tableaux::count(nonnegative integer siz)

combinat::tableaux::count(partition shape, integer vector eva)

combinat::tableaux::count(nonnegative integer siz, integer vector eva)

Returns the number of standard tableaux of shape shape or of size siz. When the second argument eva is given, the function returns the number of tableaux with evaluation eva. This method uses the hook-length formula for the case of standard tableaux and counting the list of tableaux otherwise.

list – list of tableaux

combinat::tableaux::list(partition shape)

combinat::tableaux::list(nonnegative integer siz)

combinat::tableaux::list(partition shape, integer vector eva)

combinat::tableaux::list(nonnegative integer siz, integer vector eva)

Returns the list of the standard tableaux of shape shape or of size siz. When the second argument eva is given, the function returns the list of tableaux with evaluation eva.

generator – generator for tableaux

combinat::tableaux::generator(partition shape)

combinat::tableaux::generator(nonnegative integer siz)

combinat::tableaux::generator(partition shape, integer vector eva)

combinat::tableaux::generator(nonnegative integer siz, integer vector eva)

Returns a generator for the standard tableaux of shape shape or of size siz. When the second argument eva is given, the function returns a generator for the tableaux with evaluation eva.

printPretty – graphic representation of a filling

combinat::tableaux::printPretty(filling p)

Returns a graphic representation of the filling. This is the default way of printing tableaux. This method is inherited from the category Cat::CombinatorialClassWith2DBoxedRepresentation and returns a MuPAD objects of the domains output::asciiArt.

printCompact – graphic representation of a filling

combinat::tableaux::printCompact(filling p)

Same as above, but in a more compact way.

conjugate – conjugate of a filling

combinat::tableaux::conjugate(filling f)

Returns the conjugate (or transposed) of the filling f. Geometrically, this operation amounts to a reflection of the diagram with respect to the main diagonal.

canonical – canonical standard tableau

combinat::tableaux::canonical(partition shape)

Returns the row-canonical tableau of shape shape obtained by filling consecutive rows starting from the bottom.

columnCanonical – column canonical standard tableau

combinat::tableaux::columnCanonical(partition shape)

Returns the column-canonical tableau of shape shape obtained by filling consecutive columns starting from the left.

rowStabilizer – row stabilizer of a standard filling

combinat::tableaux::rowStabilizer(standard filling t)

Returns the list of permutations of values of t that stabilize the rows of t.

columnStabilizer – column stabilizer of a standard filling

combinat::tableaux::columnStabilizer(standard filling t)

Returns the list of permutations of values of t that stabilize the columns of t.

indexFilling – index filling of a standard tableau

combinat::tableaux::indexFilling(standard tableau t)

Returns the index filling of the tableau t, during the computation of the cocharge.

References: Lascoux. A and Schutzenberger M. P., (1978), "Sur une conjecture de H. O. Foulkes.", C.R. Acad. Sci. Paris (Série 1) 286A, 323-4.

See also : Macdonald I.-G., (1995), "Symmetric Functions and Hall Polynomials", Oxford Science Publication.

charge – charge of a standard tableau

combinat::tableaux::charge(standard tableau t)

Returns the charge of the tableau t.

See references for combinat::tableaux::cocharge for references.

cocharge – cocharge of a standard tableau

combinat::tableaux::cocharge(standard tableau t)

Returns the cocharge of the tableau t.

References: Lascoux. A and Schutzenberger M. P., (1978), "Sur une conjecture de H. O. Foulkes.", C.R. Acad. Sci. Paris (Série 1) 286A, 323-4.

See also : Macdonald I.-G., (1995), "Symmetric Functions and Hall Polynomials", Oxford Science Publication.

kostka – Kostka number

combinat::tableaux::kostka(partition lambda, partition mu)

Returns the Kostka number math, that is the number of semi-standard tableaux of shape lambda and evaluation mu.

Coplactic operations

The coplactic operations are basically the same as the ones in combinat::words. They consist mainly in to apply the operator at the word related to the tableau.

symmetricGroupActionOnValues – action of the symmetric group over a tableau

combinat::tableaux::symmetricGroupActionOnValues(tableau t, permutation p)

Returns the result of the action of the reduced words of p over t.

crystalE – crystal operator e

combinat::tableaux::crystalE(tableau t, any type i)

Returns the result of the action of the crystal operator math over t.

crystalF – crystal operator f

combinat::tableaux::crystalF(tableau t, any type i)

Returns the result of the action of the crystal operator math over t.

Jeu de taquin and Schensted algorithm. Robinson-Schensted correspondence

The jeu de taquin is the name given to a graphical representation of the plactic, or Knuth, congruences by M.-P. Schützenberger, see for example M.-P. Schützenberger, "La correspondance de Robinson", Combinatoire et Représentations du Groupe Symétrique, Strasbourg (1976), Lecture Notes in Mathematics, 579, Springer (1977) pp. 59135.

C. Schensted has defined a very beautiful algorithm that inserts a word inside a Young tableau. The insertion is a recursive bumping process that inserts one letter at a time in a tableau. If this letter is greater than the last letter of the first row, then it glues itself at the end of the first row. If it is smaller than it, it replaces the left-most letter of the first row, greater than itself. This replaced letter inserts itself in the next rows of the tableau, recursively. Reference: Schensted. C., (1961), "Longest increasing and decreasing subsequences", Canad. J. Math., 13, 178–191.

The basic step of this bumping algorithm corresponds to the jeu de taquin. One can insert one letter on the right (following rows) or on the left (following colums) of the tableau. It is also possibe to extract a letter by this operation (to the left or to the right). In this case the main interest is when the letter comes from a corner of the tableau.

Following Schensted, one can get more information by memorizing in a second tableau (that will be standard) when each box of the final tableau has been created. With those two tableaux of the same shape, the Schensted algorithm is a bijection, known as the Robinson-Schensted correspondence.

schenstedInsert – insertion of a letter in a tableau

combinat::tableaux::schenstedInsert(tableau t, letter l, direction dir)

Returns the result of the insertion by Schented algorithm of a letter l in t on the direction dir.

insertWord – insertion of a word in a tableau

combinat::tableaux::insertWord(tableau t, word w)

combinat::tableaux::insertWord(tableau t, word w, direction dir)

Returns the result of the insertion by Schented algorithm of w in t, this can be done on the Left or on the Right. The Right direction is the default.

schenstedExtract – extraction of a letter in a tableau

combinat::tableaux::schenstedExtract(tableau t, nonnegative integer row, direction dir)

Returns the result of the extraction by Schented algorithm of a letter in the corner of the row row of t on the direction dir.

Error if the row has no corner.

schensted – Robinson-Schensted correspondence

combinat::tableaux::schensted(word w)

Returns the result of the insertion by the Robinson-Schensted correspondence of w. The result is a pair composed of a semi-standard tableau and a standard tableau.

invSchensted – reverse Robinson-Schensted correspondence

combinat::tableaux::invSchensted(semi-standard tableau t1, standard tableau t2)

Returns the word obtained by the reverse bijection of Robinson-Schented.

Cyclage and cocyclage

The basic cycling operation in a word is to take its first letter and to put it at the end of the word. In tableaux, we cycle letters extract from its corners and insert them in the other direction, both operations use the Schensted algorithm. This provides an order for the tableaux of a fixed evaluation, and we have then the cyclage successors of a tableau. If the directions of extraction and insertion are inverted, we have the cocyclage successors of a tableau.

This operation has restrictions such as "not to cycle the first letter of the alphabet" or "ignore the corner in the last row". See Lascoux A., Leclerc B. and Thibon J-Y., "The Plactic Monoid", in Lothaire (2002) Algebraic Combinatorics on Words. Cambridge University Press for more information.

The iteration of the successor operation provides the cyclage graph, or the cocyclage graph. The functions to generate these graphs have as result a file for the dot program, see http://www.graphviz.org/ for details, and the examples below for more information.

cyclageSucc – successors of a tableau by cyclage

combinat::tableaux::cyclageSucc(tableau t)

combinat::tableaux::cyclageSucc(compositions eva)

combinat::tableaux::cyclageSucc(tableau t, enumeration(NoLastRow, NoFirstLetter) restriction)

combinat::tableaux::cyclageSucc(compositions eva, enumeration(NoLastRow, NoFirstLetter) restriction)

Returns the succesors of the tableau t by the cyclage operation.

If the tableau is given by its evaluation, this function constructs the associated tableau (see combinat::tableaux::fromEvaluation) and then computes its successors.

The restriction argument tells not to cycle the first letter of the alphabet or to ignore the corner in the last row for the cycling operation (which is the default restriction).

cocyclageSucc – successors of a tableau by cocyclage

combinat::tableaux::cocyclageSucc(tableau t)

combinat::tableaux::cocyclageSucc(compositions eva)

combinat::tableaux::cocyclageSucc(tableau t, enumeration(NoLastRow, NoFirstLetter) restriction)

combinat::tableaux::cocyclageSucc(compositions eva, enumeration(NoLastRow, NoFirstLetter) restriction)

Returns the succesors of the tableau t by the cocyclage operation.

If the tableau is given by its evaluation, this function constructs the associated tableau (see combinat::tableaux::fromEvaluation) and then computes its successors.

The restriction argument tells not to cycle the first letter of the alphabet or to ignore the corner in the last row for the cycling operation (which is the default restriction).

cyclageGraph – cyclage graph

combinat::tableaux::cyclageGraph(tableau t)

combinat::tableaux::cyclageGraph(compositions eva)

combinat::tableaux::cyclageGraph(nonnegative integer size)

Writes the dot file of the cyclage graph of the tableau t.

If the tableau is given by its evaluation, this function constructs the graph of the cyclage of evaluation eva.

If the tableau is given by its size, this function constructs the cyclage of tableaux of size size. This graph contains all the standard tableaux of size size.

cocyclageGraph – cocyclage graph

combinat::tableaux::cocyclageGraph(tableau t)

combinat::tableaux::cocyclageGraph(compositions eva)

combinat::tableaux::cocyclageGraph(nonnegative integer size)

Writes the dot file of the cocyclage graph of the tableau t.

If the tableau is given by its evaluation, this function constructs the graph of the cocyclage of evaluation eva. This graph contains all the tableaux with this evaluation.

If the tableau is given by its size, this function constructs the cyclage of tableaux of size size. This graph contains all the standard tableaux of size size. This graph almost coincides with the cyclage graph: it has the same nodes, but inverted links.

Example 1:

The following list of lists of integers is a tableau but not a standard tableau:

combinat::tableaux::isA([[4, 4], [1, 2, 4]]);

combinat::tableaux::isAStandardTableau([[4, 4], [1, 2, 4]]);

math

math

It is also a tableau of size math but not of size math:

combinat::tableaux::isA([[4, 4], [1, 2, 4]], 5);

combinat::tableaux::isA([[4, 4], [1, 2, 4]], 6);

math

math

Moreover, this tableau is confirmed to be of shape math, and not of shape math.

combinat::tableaux::isA([[4, 4], [1, 2, 4]],[3,2]);

combinat::tableaux::isA([[4, 4], [1, 2, 4]],[3,1,1]);

math

math

Example 2:

There are math tableaux of shape math:

combinat::tableaux::count([3,2])

math

Here is the list:

combinat::tableaux::list([3,2])

-- +---+---+      +---+---+      +---+---+      +---+---+      +---+---+     --

|  | 4 | 5 |      | 3 | 5 |      | 2 | 5 |      | 3 | 4 |      | 2 | 4 |      |

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

|  | 1 | 2 | 3 |, | 1 | 2 | 4 |, | 1 | 3 | 4 |, | 1 | 2 | 5 |, | 1 | 3 | 5 |  |

-- +---+---+---+  +---+---+---+  +---+---+---+  +---+---+---+  +---+---+---+ --

 

If you want to run through the tableaux of a shape, you can generate them one by one to save memory:

g := combinat::tableaux::generator([3,2]):

g(); g(); g(); g(); g(); g()

+---+---+

| 4 | 5 |

+---+---+---+

| 1 | 2 | 3 |

+---+---+---+

 

+---+---+

| 3 | 5 |

+---+---+---+

| 1 | 2 | 4 |

+---+---+---+

 

+---+---+

| 2 | 5 |

+---+---+---+

| 1 | 3 | 4 |

+---+---+---+

 

+---+---+

| 3 | 4 |

+---+---+---+

| 1 | 2 | 5 |

+---+---+---+

 

+---+---+

| 2 | 4 |

+---+---+---+

| 1 | 3 | 5 |

+---+---+---+

 

math

Typically, this would be used as follows:

g := combinat::tableaux::generator([3,2]):

while (p := g()) <> FAIL do print(p): end:

+---+---+

| 4 | 5 |

+---+---+---+

| 1 | 2 | 3 |

+---+---+---+

 

+---+---+

| 3 | 5 |

+---+---+---+

| 1 | 2 | 4 |

+---+---+---+

 

+---+---+

| 2 | 5 |

+---+---+---+

| 1 | 3 | 4 |

+---+---+---+

 

+---+---+

| 3 | 4 |

+---+---+---+

| 1 | 2 | 5 |

+---+---+---+

 

+---+---+

| 2 | 4 |

+---+---+---+

| 1 | 3 | 5 |

+---+---+---+

 

There are math tableaux of size math:

combinat::tableaux::count(3)

math

Here is the list:

combinat::tableaux::list(3)

--                                      +---+ --

|                                       | 3 |  |

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

|                 | 3 |      | 2 |      | 2 |  |

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

|  | 1 | 2 | 3 |, | 1 | 2 |, | 1 | 3 |, | 1 |  |

-- +---+---+---+  +---+---+  +---+---+  +---+ --

 

They can be printed in a compact way:

map(combinat::tableaux::list(3), combinat::tableaux::printCompact)

--                        |3| --

|           |3|    |2|    |2|  |

-- |1|2|3|, |1|2|, |1|3|, |1| --

 

We can also compute the tableaux of size math and evaluation [1, 2, 1]:

combinat::tableaux::list(4,[1,2,1])

--                                                             +---+     --

|                                                              | 3 |      |

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

|                     | 2 |          | 3 |          | 2 | 3 |  | 2 |      |

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

|  | 1 | 2 | 2 | 3 |, | 1 | 2 | 3 |, | 1 | 2 | 2 |, | 1 | 2 |, | 1 | 2 |  |

-- +---+---+---+---+  +---+---+---+  +---+---+---+  +---+---+  +---+---+ --

 

Example 3:

The tableau [[3, 4], [1, 2, 5]] is of shape:

combinat::tableaux::shape([[3, 4], [1, 2, 5]])

math

Its conjugate is the tableau:

combinat::tableaux::conjugate([[3, 4], [1, 2, 5]])

+---+

| 5 |

+---+---+

| 2 | 4 |

+---+---+

| 1 | 3 |

+---+---+

 

The shape of the conjugate is the conjugate of the shape:

t:=[[7], [3, 4], [1, 2, 5, 6]];

combinat::tableaux::shape(combinat::tableaux::conjugate(t));

combinat::partitions::conjugate(combinat::tableaux::shape(t))

math

math

math

Example 4:

The filling [[3, 4], [1, 2, 5]] corresponds to the word:

combinat::tableaux::toWord([[3, 4], [1, 2, 5]])

math

The tableau can be reconstructed back from the word:

combinat::tableaux::fromWord([3, 4, 1, 2, 5])

+---+---+

| 3 | 4 |

+---+---+---+

| 1 | 2 | 5 |

+---+---+---+

 

Example 5:

The row-canonical and column-canonical tableaux of shape math are:

combinat::tableaux::canonical([3,2]);

combinat::tableaux::columnCanonical([3,2]);

+---+---+

| 4 | 5 |

+---+---+---+

| 1 | 2 | 3 |

+---+---+---+

 

+---+---+

| 2 | 4 |

+---+---+---+

| 1 | 3 | 5 |

+---+---+---+

 

Example 6:

Exchanging the values math and math in the filling T:=[[2,5], [1,3,4]] yields T:=[[5,2], [1,3,4]]: this operation stabilize the rows of T. In general, all the following math permutations stabilize the rows of T:

combinat::tableaux::rowStabilizer([[2, 5], [1, 3, 4]])

math

Similarily, there are 4 permutations which stabilize the columns of t:

combinat::tableaux::columnStabilizer([[2, 5], [1, 3, 4]])

math

Example 7:

To compute the cocharge of the tableau [[3, 5], [1, 2, 4]], we compute the indexes:

combinat::tableaux::indexFilling([[3, 5], [1, 2, 4]])

+---+---+

| 1 | 2 |

+---+---+---+

| 0 | 0 | 1 |

+---+---+---+

 

The cocharge is their sum:

combinat::tableaux::cocharge([[3, 5], [1, 2, 4]])

math

Example 8:

To insert a letter in a tableau, we compute:

tab:=combinat::tableaux([[3],[1,2,4]]);

combinat::tableaux::schenstedInsert(tab,5,Right);

combinat::tableaux::schenstedInsert(tab,5,Left);

+---+

| 3 |

+---+---+---+

| 1 | 2 | 4 |

+---+---+---+

 

+---+

| 3 |

+---+---+---+---+

| 1 | 2 | 4 | 5 |

+---+---+---+---+

 

+---+

| 5 |

+---+

| 3 |

+---+---+---+

| 1 | 2 | 4 |

+---+---+---+

 

To insert a word in a tableau, we compute:

combinat::tableaux::insertWord([[3],[1,2,4]],[5,1]);

+---+

| 3 |

+---+

| 2 |

+---+---+---+---+

| 1 | 1 | 4 | 5 |

+---+---+---+---+

 

We can tell the direction as well:

combinat::tableaux::insertWord([[3],[1,2,4]],[5,1],Right);

combinat::tableaux::insertWord([[3],[1,2,4]],[5,1],Left);

+---+

| 3 |

+---+

| 2 |

+---+---+---+---+

| 1 | 1 | 4 | 5 |

+---+---+---+---+

 

+---+

| 5 |

+---+

| 3 |

+---+---+---+---+

| 1 | 1 | 2 | 4 |

+---+---+---+---+

 

To extract a letter in a tableau, we should indicate a corner row:

tab:=combinat::tableaux([[5],[3],[1,2,4]]);

combinat::tableaux::schenstedExtract(tab,1,Right);

combinat::tableaux::schenstedExtract(tab,1,Left);

combinat::tableaux::schenstedExtract(tab,2,Left);

+---+

| 5 |

+---+

| 3 |

+---+---+---+

| 1 | 2 | 4 |

+---+---+---+

 

-- +---+            --

|  | 5 |             |

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

|  | 1 | 3 | 4 |, 2  |

-- +---+---+---+    --

 

-- +---+            --

|  | 3 |             |

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

|  | 1 | 2 | 4 |, 5  |

-- +---+---+---+    --

 

Error: There is no corner in this row [combinat::tableaux::schenstedExtract]

 

To get the two tableaux arising from the insertion of a word in the Robinson-Schensted correspondence, we compute:

combinat::tableaux::schensted([1, 3, 5, 2, 4]);

-- +---+---+      +---+---+     --

|  | 3 | 5 |      | 4 | 5 |      |

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

|  | 1 | 2 | 4 |, | 1 | 2 | 3 |  |

-- +---+---+---+  +---+---+---+ --

 

Conversely, starting from two tableaux, one recovers the word they correspond to, by using:

combinat::tableaux::invSchensted([[3, 5], [1, 2, 4]], [[4, 5], [1, 2, 3]]);

math

Example 9:

To compute the successors of a tableau by cyclage we compute:

tab:=combinat::tableaux([[5],[2,4],[1,3,6]]);

combinat::tableaux::cyclageSucc(tab, NoLastRow);

combinat::tableaux::cyclageSucc(tab, NoFirstLetter);

+---+

| 5 |

+---+---+

| 2 | 4 |

+---+---+---+

| 1 | 3 | 6 |

+---+---+---+

 

--                +---+         --

|                 | 5 |          |

|                 +---+          |

|                 | 4 |          |

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

|  | 2 | 4 | 6 |  | 3 |          |

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

|  | 1 | 3 | 5 |, | 1 | 2 | 6 |  |

-- +---+---+---+  +---+---+---+ --

 

--                +---+          +---+     --

|                 | 5 |          | 5 |      |

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

|                 | 4 |          | 4 |      |

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

|  | 2 | 4 | 6 |  | 3 |          | 3 | 6 |  |

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

|  | 1 | 3 | 5 |, | 1 | 2 | 6 |, | 1 | 2 |  |

-- +---+---+---+  +---+---+---+  +---+---+ --

 

The cyclage operation considers a corner of the tableau, say [1,1], and extracts on the left the letter math in this case. Using Schensted's algorithm, the letter is inserted on the right of the resulting tableau, which gives the tableau:

combinat::tableaux::schenstedInsert([[2,4],[1,3,6]],5,Right)

+---+---+---+

| 2 | 4 | 6 |

+---+---+---+

| 1 | 3 | 5 |

+---+---+---+

 

With the option NoLastRow, the corner [3,3] is ignored for the cyclage operation. But for the option NoFirstLetter, this corner is considered. As the extracted letter on the left is math, the cycling is completed and math is inserted on the right of the resulting tableau, which gives:

tab:=combinat::tableaux([[5],[2,4],[1,3,6]]):

combinat::tableaux::schenstedExtract(tab,3, Left);

combinat::tableaux::schenstedInsert([[5],[4,6],[1,3]],2, Right);

-- +---+        --

|  | 5 |         |

|  +---+---+     |

|  | 4 | 6 |     |

|  +---+---+     |

|  | 1 | 3 |, 2  |

-- +---+---+    --

 

+---+

| 5 |

+---+

| 4 |

+---+---+

| 3 | 6 |

+---+---+

| 1 | 2 |

+---+---+

 

These are the successors of a tableau by cocyclage:

tab:=combinat::tableaux([[5],[2,4],[1,3,6]]);

combinat::tableaux::cocyclageSucc(tab, NoLastRow);

combinat::tableaux::cocyclageSucc(tab, NoFirstLetter);

+---+

| 5 |   

+---+---+           

| 2 | 4 |            

+---+---+---+        

| 1 | 3 | 6 |        

+---+---+---+

 

-- +---+          +---+         --

|  | 3 |          | 3 |          |

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

|  | 2 | 5 |      | 2 | 5 |      |

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

|  | 1 | 4 | 6 |, | 1 | 4 | 6 |  |

-- +---+---+---+  +---+---+---+ --

 

--                               +---+     --

|                                | 6 |      |

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

|  | 3 |          | 3 |          | 5 |      |

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

|  | 2 | 5 |      | 2 | 5 |      | 2 | 4 |  |

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

|  | 1 | 4 | 6 |, | 1 | 4 | 6 |, | 1 | 3 |  |

-- +---+---+---+  +---+---+---+  +---+---+ --

 

In the cocyclage operation, the extraction is on the right, and the insertion is on the left. It may happen that we get the same result for the extraction operation when considering two different corners.

Example 10:

This is the command to generate a cyclage graph for tableaux of evaluation [3,1,2]:

combinat::tableaux::cyclageGraph([3,1,2])

 

This command generate a text file with source code for the dot program, which consists basically in the graph structure and a description in what to write on nodes and links. This file has a random name beginning with cyclage (even for cocyclage graphs), but the user can provide another name.

The first line of the cyclage file contains the dot command to generate a corresponding postscript file, which is easily modified to generate .png files or other formats, see http://www.graphviz.org/ for more information. Colors are also customizable, either in the dot file or in the MuPAD command.

Here is the graph generated by the last MuPAD command: 1 

Graph of the cyclage of tableaux with evaluation [3,1,2]

 

And this is the cocyclage of the tableaux with evaluation [3,1,2]:

combinat::tableaux::cocyclageGraph([3,1,2])

 

which generates the graph: 1 

Graph of the cocyclage of tableaux with evaluation [3,1,2]

 

Both commands combinat::tableaux::cyclageGraph and combinat::tableaux::cocyclageGraph have the option NoFirstLetter as the default one.