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\)-tableaumarking
- a list of pairs of coordinates where cells are to be markedk
- a positive integerweight
- 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 ofTlist
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 notStrongTableau
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 listsk
- 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 listsk
– 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 tounmarkedT
.INPUT:
unmarkedT
- a list of lists representing a strong unmarked tableauk
- a positive integerweight
- 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 tableauxcompact
– minimal length ascii artrepr
– display using the diagram string representationtable
– display as a table
convention
– (default:English
) Sets the convention used for displaying tableaux and partitionsEnglish
– use the English conventionFrench
– use the French convention
display
– (default:list
) Controls the way in which tableaux are printedarray
– alias fordiagram
compact
– minimal length string representationdiagram
– display as Young diagram (similar topp()
ferrers_diagram
– alias fordiagram
list
– print tableaux as listsyoung_diagram
– alias fordiagram
latex
– (default:diagram
) Controls the way in which tableaux are latexedarray
– alias fordiagram
diagram
– as a Young diagramferrers_diagram
– alias fordiagram
list
– as a listyoung_diagram
– alias fordiagram
notation
– alternative name forconvention
Note
Changing the
convention
for tableaux also changes theconvention
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 theconvention
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 inouter_shape
and contain theinner_shape
. Ifouter_shape
isNone
then there is no restriction on the shape of the tableaux which are created.INPUT:
k
- a positive integersize
- a positive integerouter_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 inouter_shape
and containinner_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 inouter_shape
and which contain theinner_shape
.These are built recursively by building all standard marked strong tableaux of size
size
\(-1\) and adding all possible covers.If
outer_shape
isNone
then there is no restriction on the shape of the tableaux which are created.INPUT:
k
,size
- a positive integersouter_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 inouter_shape
and containinner_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 ofNone
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
- for the ‘core’ representation
k
– positive integerinner_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 integershape
– 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 shapeweight
– the weight of the weak \(k\)-tableaux as a list or tuplerepresentation
– ‘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 weightweight
.INPUT:
k
– positive integershape
– 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 partitionweight
– 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 weightweight
.INPUT:
k
– positive integershape
– 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 weightweight
.INPUT:
k
– positive integershape
– 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)\)-coresweight
– 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
orNone
.INPUT:
v
– either an integer orNone
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)