Strong and weak tableaux

There are two types of \(k\)-tableaux: strong \(k\)-tableaux and weak \(k\)-tableaux. Standard weak \(k\)-tableaux correspond to saturated chains in the weak order, whereas standard strong \(k\)-tableaux correspond to saturated chains in the strong Bruhat order. For semistandard tableaux, the notion of weak and strong horizontal strip is necessary. More information can be found in [LLMS2006] .

Authors:

  • Anne Schilling and Mike Zabrocki (2013): initial version
  • Avi Dalal and Nate Gallup (2013): implementation of \(k\)-charge
sage.combinat.k_tableau.StrongTableau

A (standard) strong \(k\)-tableau is a (saturated) chain in Bruhat order.

Combinatorially, it is a sequence of embedded \(k+1\)-cores (subject to some conditions) together with a set of markings.

A strong cover in terms of cores corresponds to certain translated ribbons. A marking corresponds to the choice of one of the translated ribbons, which is indicated by marking the head (southeast most cell in French notation) of the chosen ribbon. For more information, see [LLMS2006] and [LLMSSZ2013].

In Sage, a strong \(k\)-tableau is created by specifying \(k\), a standard strong tableau together with its markings, and a weight \(\mu\). Here the standard tableau is represented by a sequence of \(k+1\)-cores

\[\lambda^{(0)} \subseteq \lambda^{(1)} \subseteq \cdots \subseteq \lambda^{(m)}\]

where each of the \(\lambda^{(i)}\) is a \(k+1\)-core. The standard tableau is a filling of the diagram for the core \(\lambda^{(m)}/\lambda^{(0)}\) where a strong cover is represented by letters \(\pm i\) in the skew shape \(\lambda^{(i)}/\lambda^{(i-1)}\). Each skew \((k+1)\)-core \(\lambda^{(i)}/\lambda^{(i-1)}\) is a ribbon or multiple copies of the same ribbon which are separated by \(k+1\) diagonals. Precisely one of the copies of the ribbons will be marked in the largest diagonal of the connected component (the ‘head’ of the ribbon). The marked cells are indicated by negative signs.

The strong tableau is stored as a standard strong marked tableau (referred to as the standard part of the strong tableau) and a vector representing the weight.

EXAMPLES:

sage: StrongTableau( [[-1, -2, -3], [3]], 2, [3] )
[[-1, -1, -1], [1]]
sage: StrongTableau([[-1,-2,-4,-7],[-3,6,-6,8],[4,7],[-5,-8]], 3, [2,2,3,1])
[[-1, -1, -2, -3], [-2, 3, -3, 4], [2, 3], [-3, -4]]

Alternatively, the strong \(k\)-tableau can also be entered directly in semistandard format and then the standard tableau and the weight are computed and stored:

sage: T = StrongTableau([[-1,-1,-1],[1]], 2); T
[[-1, -1, -1], [1]]
sage: T.to_standard_list()
[[-1, -2, -3], [3]]
sage: T.weight()
(3,)
sage: T = StrongTableau([[-1, -1, -2, -3], [-2, 3, -3, 4], [2, 3], [-3, -4]], 3); T
[[-1, -1, -2, -3], [-2, 3, -3, 4], [2, 3], [-3, -4]]
sage: T.to_standard_list()
[[-1, -2, -4, -7], [-3, 6, -6, 8], [4, 7], [-5, -8]]
sage: T.weight()
(2, 2, 3, 1)
class sage.combinat.k_tableau.StrongTableaux(k, shape, weight)

Bases: sage.structure.unique_representation.UniqueRepresentation, sage.structure.parent.Parent

Element

A (standard) strong \(k\)-tableau is a (saturated) chain in Bruhat order.

Combinatorially, it is a sequence of embedded \(k+1\)-cores (subject to some conditions) together with a set of markings.

A strong cover in terms of cores corresponds to certain translated ribbons. A marking corresponds to the choice of one of the translated ribbons, which is indicated by marking the head (southeast most cell in French notation) of the chosen ribbon. For more information, see [LLMS2006] and [LLMSSZ2013].

In Sage, a strong \(k\)-tableau is created by specifying \(k\), a standard strong tableau together with its markings, and a weight \(\mu\). Here the standard tableau is represented by a sequence of \(k+1\)-cores

\[\lambda^{(0)} \subseteq \lambda^{(1)} \subseteq \cdots \subseteq \lambda^{(m)}\]

where each of the \(\lambda^{(i)}\) is a \(k+1\)-core. The standard tableau is a filling of the diagram for the core \(\lambda^{(m)}/\lambda^{(0)}\) where a strong cover is represented by letters \(\pm i\) in the skew shape \(\lambda^{(i)}/\lambda^{(i-1)}\). Each skew \((k+1)\)-core \(\lambda^{(i)}/\lambda^{(i-1)}\) is a ribbon or multiple copies of the same ribbon which are separated by \(k+1\) diagonals. Precisely one of the copies of the ribbons will be marked in the largest diagonal of the connected component (the ‘head’ of the ribbon). The marked cells are indicated by negative signs.

The strong tableau is stored as a standard strong marked tableau (referred to as the standard part of the strong tableau) and a vector representing the weight.

EXAMPLES:

sage: StrongTableau( [[-1, -2, -3], [3]], 2, [3] )
[[-1, -1, -1], [1]]
sage: StrongTableau([[-1,-2,-4,-7],[-3,6,-6,8],[4,7],[-5,-8]], 3, [2,2,3,1])
[[-1, -1, -2, -3], [-2, 3, -3, 4], [2, 3], [-3, -4]]

Alternatively, the strong \(k\)-tableau can also be entered directly in semistandard format and then the standard tableau and the weight are computed and stored:

sage: T = StrongTableau([[-1,-1,-1],[1]], 2); T
[[-1, -1, -1], [1]]
sage: T.to_standard_list()
[[-1, -2, -3], [3]]
sage: T.weight()
(3,)
sage: T = StrongTableau([[-1, -1, -2, -3], [-2, 3, -3, 4], [2, 3], [-3, -4]], 3); T
[[-1, -1, -2, -3], [-2, 3, -3, 4], [2, 3], [-3, -4]]
sage: T.to_standard_list()
[[-1, -2, -4, -7], [-3, 6, -6, 8], [4, 7], [-5, -8]]
sage: T.weight()
(2, 2, 3, 1)
classmethod add_marking(unmarkedT, marking, k, weight)

Add markings to a partially marked strong tableau.

Given an partially marked standard tableau and a list of cells where the marks should be placed along with a weight, return the semi-standard marked strong tableau. The marking should complete the marking so that the result is a strong standard marked tableau.

INPUT:

  • unmarkedT - a list of lists which is a partially marked strong \(k\)-tableau
  • marking - a list of pairs of coordinates where cells are to be marked
  • k - a positive integer
  • weight - a tuple of the weight of the output tableau

OUTPUT:

  • a StrongTableau object

EXAMPLES:

sage: StrongTableaux.add_marking([[None,1,2],[2]], [(0,1), (1,0)], 2, [1,1])
[[None, -1, 2], [-2]]
sage: StrongTableaux.add_marking([[None,1,2],[2]], [(0,1), (1,0)], 2, [2])
Traceback (most recent call last):
...
ValueError: The weight=(2,) and the markings on the standard tableau=[[None, -1, 2], [-2]] do not agree.
sage: StrongTableaux.add_marking([[None,1,2],[2]], [(0,1), (0,2)], 2, [2])
[[None, -1, -1], [1]]
an_element()

Return the first generated element of the class of StrongTableaux.

EXAMPLES:

sage: ST = StrongTableaux(3, [3], weight=[3])
sage: ST.an_element()
[[-1, -1, -1]]
classmethod cells_head_dictionary(T)

Return a dictionary with the locations of the heads of all markings.

Return a dictionary of values and lists of cells where the heads with the values are located in a strong standard unmarked tableau T.

INPUT:

  • T – a strong standard unmarked tableau as a list of lists

OUTPUT:

  • a dictionary with keys the entries in the tableau and values are the coordinates of the heads with those entries

EXAMPLES:

sage: StrongTableaux.cells_head_dictionary([[1,2,4,7],[3,6,6,8],[4,7],[5,8]])
{1: [(0, 0)],
 2: [(0, 1)],
 3: [(1, 0)],
 4: [(2, 0), (0, 2)],
 5: [(3, 0)],
 6: [(1, 2)],
 7: [(2, 1), (0, 3)],
 8: [(3, 1), (1, 3)]}
sage: StrongTableaux.cells_head_dictionary([[None, 2, 2, 4, 5, 6, 6, 6], [None, 3, 6, 6, 6], [1, 4]])
{1: [(2, 0)],
 2: [(0, 2)],
 3: [(1, 1)],
 4: [(2, 1), (0, 3)],
 5: [(0, 4)],
 6: [(1, 4), (0, 7)]}
classmethod follows_tableau_unsigned_standard(Tlist, k)

Return a list of strong tableaux one longer in length than Tlist.

Return list of all standard strong tableaux obtained from Tlist by extending to a core which follows the shape of Tlist in the strong order. It does not put the markings on the last entry that it adds but it does keep the markings on all entries smaller. The objects returned are not StrongTableau objects (and cannot be) because the last entry will not properly marked.

INPUT:

  • Tlist – a filling of a \(k+1\)-core as a list of lists
  • k - an integer

OUTPUT:

  • a list of strong tableaux which follow Tlist in strong order

EXAMPLES:

sage: StrongTableaux.follows_tableau_unsigned_standard([[-1, -1, -2, -3], [-2, 3, -3, 4], [2, 3], [-3, -4]], 3)
[[[-1, -1, -2, -3, 5, 5, 5], [-2, 3, -3, 4], [2, 3], [-3, -4]],
 [[-1, -1, -2, -3, 5], [-2, 3, -3, 4], [2, 3, 5], [-3, -4], [5]],
 [[-1, -1, -2, -3], [-2, 3, -3, 4], [2, 3], [-3, -4], [5], [5], [5]]]
sage: StrongTableaux.follows_tableau_unsigned_standard([[None,-1],[-2,-3]],3)
[[[None, -1, 4, 4, 4], [-2, -3]], [[None, -1, 4], [-2, -3], [4]],
 [[None, -1], [-2, -3], [4], [4], [4]]]
global_options(*args, **kwds)

Deprecated: Use options() instead. See trac ticket #18555 for details.

inner_shape()

Return the inner shape of the class of strong tableaux.

OUTPUT:

  • a \(k+1\)-core

EXAMPLES:

sage: StrongTableaux( 2, [3,1] ).inner_shape()
[]
sage: type(StrongTableaux( 2, [3,1] ).inner_shape())
<class 'sage.combinat.core.Cores_length_with_category.element_class'>
sage: StrongTableaux( 4, [[2,1], [1]] ).inner_shape()
[1]
classmethod marked_CST_to_transposition_sequence(T, k)

Return a list of transpositions corresponding to T.

Given a strong column strict tableau T returns the list of transpositions which when applied to the left of an empty tableau gives the corresponding strong standard tableau.

INPUT:

  • T – a non-empty column strict tableau as a list of lists
  • k – a positive integer

OUTPUT:

  • a list of pairs of values [i,j] representing the transpositions \(t_{ij}\)

EXAMPLES:

sage: CST_to_trans = StrongTableaux.marked_CST_to_transposition_sequence
sage: CST_to_trans([[-1, -1, -1], [1]], 2)
[[2, 3], [1, 2], [0, 1]]
sage: CST_to_trans([], 2)
[]
sage: CST_to_trans([[-2, -2, -2], [2]], 2)
[[2, 3], [1, 2], [0, 1]]
sage: CST_to_trans([[-1, -2, -2, -2, -2], [-2, 2], [2]], 3)
[[4, 5], [3, 4], [2, 3], [1, 2], [-1, 0], [0, 1]]
sage: CST_to_trans([[-1, -2, -5, 5, -5, 5, -5], [-3, -4, 5, 5], [5]],3)
[[5, 7], [3, 5], [2, 3], [0, 1], [-1, 0], [1, 2], [0, 1]]
sage: CST_to_trans([[-1, -2, -3, 4, -7], [-4, -6], [-5, 6]],3)
[[4, 5], [-1, 1], [-2, -1], [-1, 0], [2, 3], [1, 2], [0, 1]]
classmethod marked_given_unmarked_and_weight_iterator(unmarkedT, k, weight)

An iterator generating strong marked tableaux from an unmarked strong tableau.

Iterator which lists all marked tableaux of weight weight such that the standard unmarked part of the tableau is equal to unmarkedT.

INPUT:

  • unmarkedT - a list of lists representing a strong unmarked tableau
  • k - a positive integer
  • weight - a list of non-negative integers indicating the weight

OUTPUT:

  • an iterator that returns StrongTableau objects

EXAMPLES:

sage: ST = StrongTableaux.marked_given_unmarked_and_weight_iterator([[1,2,3],[3]], 2, [3])
sage: list(ST)
[[[-1, -1, -1], [1]]]
sage: ST = StrongTableaux.marked_given_unmarked_and_weight_iterator([[1,2,3],[3]], 2, [0,3])
sage: list(ST)
[[[-2, -2, -2], [2]]]
sage: ST = StrongTableaux.marked_given_unmarked_and_weight_iterator([[1,2,3],[3]], 2, [1,2])
sage: list(ST)
[[[-1, -2, -2], [2]]]
sage: ST = StrongTableaux.marked_given_unmarked_and_weight_iterator([[1,2,3],[3]], 2, [2,1])
sage: list(ST)
[[[-1, -1, 2], [-2]], [[-1, -1, -2], [2]]]
sage: ST = StrongTableaux.marked_given_unmarked_and_weight_iterator([[None, None, 1, 2, 4], [2, 4], [3]], 3, [3,1])
sage: list(ST)
[]
sage: ST = StrongTableaux.marked_given_unmarked_and_weight_iterator([[None, None, 1, 2, 4], [2, 4], [3]], 3, [2,2])
sage: list(ST)
[[[None, None, -1, -1, 2], [1, -2], [-2]],
 [[None, None, -1, -1, -2], [1, 2], [-2]]]
options(*get_value, **set_value)

Sets the global options for elements of the tableau, skew_tableau, and tableau tuple classes. The defaults are for tableau to be displayed as a list, latexed as a Young diagram using the English convention.

OPTIONS:

  • ascii_art – (default: repr) Controls the ascii art output for tableaux
    • compact – minimal length ascii art
    • repr – display using the diagram string representation
    • table – display as a table
  • convention – (default: English) Sets the convention used for displaying tableaux and partitions
    • English – use the English convention
    • French – use the French convention
  • display – (default: list) Controls the way in which tableaux are printed
    • array – alias for diagram
    • compact – minimal length string representation
    • diagram – display as Young diagram (similar to pp()
    • ferrers_diagram – alias for diagram
    • list – print tableaux as lists
    • young_diagram – alias for diagram
  • latex – (default: diagram) Controls the way in which tableaux are latexed
    • array – alias for diagram
    • diagram – as a Young diagram
    • ferrers_diagram – alias for diagram
    • list – as a list
    • young_diagram – alias for diagram
  • notation – alternative name for convention

Note

Changing the convention for tableaux also changes the convention for partitions.

If no parameters are set, then the function returns a copy of the options dictionary.

EXAMPLES:

sage: T = Tableau([[1,2,3],[4,5]])
sage: T
[[1, 2, 3], [4, 5]]
sage: Tableaux.options.display="array"
sage: T
  1  2  3
  4  5
sage: Tableaux.options.convention="french"
sage: T
  4  5
  1  2  3

Changing the convention for tableaux also changes the convention for partitions and vice versa:

sage: P = Partition([3,3,1])
sage: print(P.ferrers_diagram())
*
***
***
sage: Partitions.options.convention="english"
sage: print(P.ferrers_diagram())
***
***
*
sage: T
  1  2  3
  4  5

The ASCII art can also be changed:

sage: t = Tableau([[1,2,3],[4,5]])
sage: ascii_art(t)
  1  2  3
  4  5
sage: Tableaux.options.ascii_art = "table"
sage: ascii_art(t)
+---+---+---+
| 1 | 2 | 3 |
+---+---+---+
| 4 | 5 |
+---+---+
sage: Tableaux.options.ascii_art = "compact"
sage: ascii_art(t)
|1|2|3|
|4|5|
sage: Tableaux.options._reset()

See GlobalOptions for more features of these options.

outer_shape()

Return the outer shape of the class of strong tableaux.

OUTPUT:

  • a \(k+1\)-core

EXAMPLES:

sage: StrongTableaux( 2, [3,1] ).outer_shape()
[3, 1]
sage: type(StrongTableaux( 2, [3,1] ).outer_shape())
<class 'sage.combinat.core.Cores_length_with_category.element_class'>
sage: StrongTableaux( 4, [[2,1], [1]] ).outer_shape()
[2, 1]
shape()

Return the shape of self.

If the self has an inner shape return a pair consisting of an inner and an outer shape. If the inner shape is empty then return only the outer shape.

OUTPUT:

  • a \(k+1\)-core or a pair of \(k+1\)-cores

EXAMPLES:

sage: StrongTableaux( 2, [3,1] ).shape()
[3, 1]
sage: type(StrongTableaux( 2, [3,1] ).shape())
<class 'sage.combinat.core.Cores_length_with_category.element_class'>
sage: StrongTableaux( 4, [[2,1], [1]] ).shape()
([2, 1], [1])
classmethod standard_marked_iterator(k, size, outer_shape=None, inner_shape=[])

An iterator for generating standard strong marked tableaux.

An iterator which generates all standard marked \(k\)-tableaux of a given size which are contained in outer_shape and contain the inner_shape. If outer_shape is None then there is no restriction on the shape of the tableaux which are created.

INPUT:

  • k - a positive integer
  • size - a positive integer
  • outer_shape - a list which is a \(k+1\)-core (default: None)
  • inner_shape - a list which is a \(k+1\)-core (default: [])

OUTPUT:

  • an iterator which returns the standard marked tableaux with size cells and that are contained in outer_shape and contain inner_shape

EXAMPLES:

sage: list(StrongTableaux.standard_marked_iterator(2, 3))
[[[-1, -2, 3], [-3]], [[-1, -2, -3], [3]], [[-1, -2], [-3], [3]], [[-1, 3, -3], [-2]], [[-1, 3], [-2], [-3]], [[-1, -3], [-2], [3]]]
sage: list(StrongTableaux.standard_marked_iterator(2, 1, inner_shape=[1,1]))
[[[None, 1, -1], [None]], [[None, 1], [None], [-1]], [[None, -1], [None], [1]]]
sage: len(list(StrongTableaux.standard_marked_iterator(4,4)))
10
sage: len(list(StrongTableaux.standard_marked_iterator(4,6)))
140
sage: len(list(StrongTableaux.standard_marked_iterator(4,4, inner_shape=[2,2])))
200
sage: len(list(StrongTableaux.standard_marked_iterator(4,4, outer_shape=[5,2,2,1], inner_shape=[2,2])))
24
classmethod standard_unmarked_iterator(k, size, outer_shape=None, inner_shape=[])

An iterator for standard unmarked strong tableaux.

An iterator which generates all unmarked tableaux of a given size which are contained in outer_shape and which contain the inner_shape.

These are built recursively by building all standard marked strong tableaux of size size \(-1\) and adding all possible covers.

If outer_shape is None then there is no restriction on the shape of the tableaux which are created.

INPUT:

  • k, size - a positive integers
  • outer_shape - a list representing a \(k+1\)-core (default: None)
  • inner_shape - a list representing a \(k+1\)-core (default: [])

OUTPUT:

  • an iterator which lists all standard strong unmarked tableaux with size cells and which are contained in outer_shape and contain inner_shape

EXAMPLES:

sage: list(StrongTableaux.standard_unmarked_iterator(2, 3))
[[[1, 2, 3], [3]], [[1, 2], [3], [3]], [[1, 3, 3], [2]], [[1, 3], [2], [3]]]
sage: list(StrongTableaux.standard_unmarked_iterator(2, 1, inner_shape=[1,1]))
[[[None, 1, 1], [None]], [[None, 1], [None], [1]]]
sage: len(list(StrongTableaux.standard_unmarked_iterator(4,4)))
10
sage: len(list(StrongTableaux.standard_unmarked_iterator(4,6)))
98
sage: len(list(StrongTableaux.standard_unmarked_iterator(4,4, inner_shape=[2,2])))
92
sage: len(list(StrongTableaux.standard_unmarked_iterator(4,4, outer_shape=[5,2,2,1], inner_shape=[2,2])))
10
classmethod transpositions_to_standard_strong(transeq, k, emptyTableau=[])

Return a strong tableau corresponding to a sequence of transpositions.

This method returns the action by left multiplication on the empty strong tableau by transpositions specified by transeq.

INPUT:

  • transeq – a sequence of transpositions \(t_{ij}\) (a list of pairs).
  • emptyTableau – (default: []) an empty list or a skew strong tableau possibly consisting of None entries

OUTPUT:

  • a StrongTableau object

EXAMPLES:

sage: StrongTableaux.transpositions_to_standard_strong([[0,1]], 2)
[[-1]]
sage: StrongTableaux.transpositions_to_standard_strong([[-2,-1], [2,3]], 2, [[None, None]])
[[None, None, -1], [1], [-2]]
sage: StrongTableaux.transpositions_to_standard_strong([[2, 3], [1, 2], [0, 1]], 2)
[[-1, -2, -3], [3]]
sage: StrongTableaux.transpositions_to_standard_strong([[-1, 0], [1, 2], [0, 1]], 2)
[[-1, -2, 3], [-3]]
sage: StrongTableaux.transpositions_to_standard_strong([[3, 4], [-1, 0], [1, 2]], 2, [[None]])
[[None, -1, 2, -3], [-2, 3]]
sage.combinat.k_tableau.WeakTableau(t, k, inner_shape=[], representation='core')

This is the dispatcher method for the element class of weak \(k\)-tableaux.

Standard weak \(k\)-tableaux correspond to saturated chains in the weak order. There are three formulations of weak tableaux, one in terms of cores, one in terms of \(k\)-bounded partitions, and one in terms of factorizations of affine Grassmannian elements. For semistandard weak \(k\)-tableaux, all letters of the same value have to satisfy the conditions of a horizontal strip. In the affine Grassmannian formulation this means that all factors are cyclically decreasing elements. For more information, see for example [LLMSSZ2013].

INPUT:

  • t – a weak \(k\)-tableau in the specified representation:
    • for the ‘core’ representation t is a list of lists where each subtableaux should have a \(k+1\)-core shape; None is allowed as an entry for skew weak \(k\)-tableaux
    • for the ‘bounded’ representation t is a list of lists where each subtableaux should have a \(k\)-bounded shape; None is allowed as an entry for skew weak \(k\)-tableaux
    • for the ‘factorized_permutation’ representation t is either a list of cyclically decreasing Weyl group elements or a list of reduced words of cyclically decreasing Weyl group elements; to indicate a skew tableau in this representation, inner_shape should be the inner shape as a \((k+1)\)-core
  • k – positive integer
  • inner_shape – this entry is only relevant for the ‘factorized_permutation’ representation and specifies the inner shape in case the tableau is skew (default: [])
  • representation – ‘core’, ‘bounded’, or ‘factorized_permutation’ (default: ‘core’)

EXAMPLES:

Here is an example of a weak 3-tableau in core representation:

sage: t = WeakTableau([[1, 1, 2, 2, 3], [2, 3], [3]], 3)
sage: t.shape()
[5, 2, 1]
sage: t.weight()
(2, 2, 2)
sage: type(t)
<class 'sage.combinat.k_tableau.WeakTableaux_core_with_category.element_class'>

And now we give a skew weak 3-tableau in core representation:

sage: ts = WeakTableau([[None, 1, 1, 2, 2], [None, 2], [1]], 3)
sage: ts.shape()
([5, 2, 1], [1, 1])
sage: ts.weight()
(2, 2)
sage: type(ts)
<class 'sage.combinat.k_tableau.WeakTableaux_core_with_category.element_class'>

Next we create the analogue of the first example in bounded representation:

sage: tb = WeakTableau([[1,1,2],[2,3],[3]], 3, representation="bounded")
sage: tb.shape()
[3, 2, 1]
sage: tb.weight()
(2, 2, 2)
sage: type(tb)
<class 'sage.combinat.k_tableau.WeakTableaux_bounded_with_category.element_class'>
sage: tb.to_core_tableau()
[[1, 1, 2, 2, 3], [2, 3], [3]]
sage: t == tb.to_core_tableau()
True

And the analogue of the skew example in bounded representation:

sage: tbs = WeakTableau([[None, 1, 2], [None, 2], [1]], 3, representation = "bounded")
sage: tbs.shape()
([3, 2, 1], [1, 1])
sage: tbs.weight()
(2, 2)
sage: tbs.to_core_tableau()
[[None, 1, 1, 2, 2], [None, 2], [1]]
sage: ts.to_bounded_tableau() == tbs
True

Finally we do the same examples for the factorized permutation representation:

sage: tf = WeakTableau([[2,0],[3,2],[1,0]], 3, representation = "factorized_permutation")
sage: tf.shape()
[5, 2, 1]
sage: tf.weight()
(2, 2, 2)
sage: type(tf)
<class 'sage.combinat.k_tableau.WeakTableaux_factorized_permutation_with_category.element_class'>
sage: tf.to_core_tableau() == t
True

sage: tfs = WeakTableau([[0,3],[2,1]], 3, inner_shape = [1,1], representation = 'factorized_permutation')
sage: tfs.shape()
([5, 2, 1], [1, 1])
sage: tfs.weight()
(2, 2)
sage: type(tfs)
<class 'sage.combinat.k_tableau.WeakTableaux_factorized_permutation_with_category.element_class'>
sage: tfs.to_core_tableau()
[[None, 1, 1, 2, 2], [None, 2], [1]]

Another way to pass from one representation to another is as follows:

sage: ts
[[None, 1, 1, 2, 2], [None, 2], [1]]
sage: ts.parent()._representation
'core'
sage: ts.representation('bounded')
[[None, 1, 2], [None, 2], [1]]

To test whether a given semistandard tableau is a weak \(k\)-tableau in the bounded representation, one can ask:

sage: t = Tableau([[1,1,2],[2,3],[3]])
sage: t.is_k_tableau(3)
True
sage: t = SkewTableau([[None, 1, 2], [None, 2], [1]])
sage: t.is_k_tableau(3)
True
sage: t = SkewTableau([[None, 1, 1], [None, 2], [2]])
sage: t.is_k_tableau(3)
False
sage.combinat.k_tableau.WeakTableau_abstract

Abstract class for the various element classes of WeakTableau.

sage.combinat.k_tableau.WeakTableau_bounded

A (skew) weak \(k\)-tableau represented in terms of \(k\)-bounded partitions.

sage.combinat.k_tableau.WeakTableau_core

A (skew) weak \(k\)-tableau represented in terms of \((k+1)\)-cores.

sage.combinat.k_tableau.WeakTableau_factorized_permutation

A weak (skew) \(k\)-tableau represented in terms of factorizations of affine permutations into cyclically decreasing elements.

sage.combinat.k_tableau.WeakTableaux(k, shape, weight, representation='core')

This is the dispatcher method for the parent class of weak \(k\)-tableaux.

INPUT:

  • k – positive integer
  • shape – shape of the weak \(k\)-tableaux; for the ‘core’ and ‘factorized_permutation’ representation, the shape is inputted as a \((k+1)\)-core; for the ‘bounded’ representation, the shape is inputted as a \(k\)-bounded partition; for skew tableaux, the shape is inputted as a tuple of the outer and inner shape
  • weight – the weight of the weak \(k\)-tableaux as a list or tuple
  • representation – ‘core’, ‘bounded’, or ‘factorized_permutation’ (default: ‘core’)

EXAMPLES:

sage: T = WeakTableaux(3, [5,2,1], [1,1,1,1,1,1])
sage: T.list()
[[[1, 3, 4, 5, 6], [2, 6], [4]],
[[1, 2, 4, 5, 6], [3, 6], [4]],
[[1, 2, 3, 4, 6], [4, 6], [5]],
[[1, 2, 3, 4, 5], [4, 5], [6]]]
sage: T.cardinality()
4

sage: T = WeakTableaux(3, [[5,2,1], [2]], [1,1,1,1])
sage: T.list()
[[[None, None, 2, 3, 4], [1, 4], [2]],
[[None, None, 1, 2, 4], [2, 4], [3]],
[[None, None, 1, 2, 3], [2, 3], [4]]]

sage: T = WeakTableaux(3, [3,2,1], [1,1,1,1,1,1], representation = 'bounded')
sage: T.list()
[[[1, 3, 5], [2, 6], [4]],
[[1, 2, 5], [3, 6], [4]],
[[1, 2, 3], [4, 6], [5]],
[[1, 2, 3], [4, 5], [6]]]

sage: T = WeakTableaux(3, [[3,2,1], [2]], [1,1,1,1], representation = 'bounded')
sage: T.list()
[[[None, None, 3], [1, 4], [2]],
[[None, None, 1], [2, 4], [3]],
[[None, None, 1], [2, 3], [4]]]

sage: T = WeakTableaux(3, [5,2,1], [1,1,1,1,1,1], representation = 'factorized_permutation')
sage: T.list()
[[s0, s3, s2, s1, s3, s0],
[s0, s3, s2, s3, s1, s0],
[s0, s2, s3, s2, s1, s0],
[s2, s0, s3, s2, s1, s0]]

sage: T = WeakTableaux(3, [[5,2,1], [2]], [1,1,1,1], representation = 'factorized_permutation')
sage: T.list()
[[s0, s3, s2, s3], [s0, s2, s3, s2], [s2, s0, s3, s2]]
sage.combinat.k_tableau.WeakTableaux_abstract

Abstract class for the various parent classes of WeakTableaux.

sage.combinat.k_tableau.WeakTableaux_bounded

The class of (skew) weak \(k\)-tableaux in the bounded representation of shape shape (as \(k\)-bounded partition or tuple of \(k\)-bounded partitions in the skew case) and weight weight.

INPUT:

  • k – positive integer
  • shape – the shape of the \(k\)-tableaux represented as a \(k\)-bounded partition; if the tableaux are skew, the shape is a tuple of the outer and inner shape each represented as a \(k\)-bounded partition
  • weight – the weight of the \(k\)-tableaux

EXAMPLES:

sage: T = WeakTableaux(3, [3,1], [2,2], representation = 'bounded')
sage: T.list()
[[[1, 1, 2], [2]]]

sage: T = WeakTableaux(3, [[3,2,1], [2]], [1,1,1,1], representation = 'bounded')
sage: T.list()
[[[None, None, 3], [1, 4], [2]],
[[None, None, 1], [2, 4], [3]],
[[None, None, 1], [2, 3], [4]]]
sage.combinat.k_tableau.WeakTableaux_core

The class of (skew) weak \(k\)-tableaux in the core representation of shape shape (as \(k+1\)-core) and weight weight.

INPUT:

  • k – positive integer
  • shape – the shape of the \(k\)-tableaux represented as a \((k+1)\)-core; if the tableaux are skew, the shape is a tuple of the outer and inner shape (both as \((k+1)\)-cores)
  • weight – the weight of the \(k\)-tableaux

EXAMPLES:

sage: T = WeakTableaux(3, [4,1], [2,2])
sage: T.list()
[[[1, 1, 2, 2], [2]]]

sage: T = WeakTableaux(3, [[5,2,1], [2]], [1,1,1,1])
sage: T.list()
[[[None, None, 2, 3, 4], [1, 4], [2]],
[[None, None, 1, 2, 4], [2, 4], [3]],
[[None, None, 1, 2, 3], [2, 3], [4]]]
sage.combinat.k_tableau.WeakTableaux_factorized_permutation

The class of (skew) weak \(k\)-tableaux in the factorized permutation representation of shape shape (as \(k+1\)-core or tuple of \((k+1)\)-cores in the skew case) and weight weight.

INPUT:

  • k – positive integer
  • shape – the shape of the \(k\)-tableaux represented as a \((k+1)\)-core; in the skew case the shape is a tuple of the outer and inner shape both as \((k+1)\)-cores
  • weight – the weight of the \(k\)-tableaux

EXAMPLES:

sage: T = WeakTableaux(3, [4,1], [2,2], representation = 'factorized_permutation')
sage: T.list()
[[s3*s2, s1*s0]]

sage: T = WeakTableaux(4, [[6,2,1], [2]], [2,1,1,1], representation = 'factorized_permutation')
sage: T.list()
[[s0, s4, s3, s4*s2], [s0, s3, s4, s3*s2], [s3, s0, s4, s3*s2]]
sage.combinat.k_tableau.intermediate_shapes(t)

Return the intermediate shapes of tableau t.

A (skew) tableau with letters \(1, 2,\ldots, \ell\) can be viewed as a sequence of shapes, where the \(i\)-th shape is given by the shape of the subtableau on letters \(1, 2, \ldots, i\). The output is the list of these shapes.

OUTPUT:

  • a list of lists representing partitions

EXAMPLES:

sage: from sage.combinat.k_tableau import intermediate_shapes
sage: t = WeakTableau([[1, 1, 2, 2, 3], [2, 3], [3]],3)
sage: intermediate_shapes(t)
[[], [2], [4, 1], [5, 2, 1]]

sage: t = WeakTableau([[None, None, 2, 3, 4], [1, 4], [2]], 3)
sage: intermediate_shapes(t)
[[2], [2, 1], [3, 1, 1], [4, 1, 1], [5, 2, 1]]
sage.combinat.k_tableau.nabs(v)

Return the absolute value of v or None.

INPUT:

  • v – either an integer or None

OUTPUT:

  • either a non-negative integer or None

EXAMPLES:

sage: from sage.combinat.k_tableau import nabs
sage: nabs(None)
sage: nabs(-3)
3
sage: nabs(None)