There are two types of -tableaux: strong
-tableaux and weak
-tableaux.
Standard weak
-tableaux correspond to saturated chains in the weak order,
whereas standard strong
-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] .
REFERENCES:
[LLMS2006] | (1, 2) T. Lam, L. Lapointe, J. Morse, M. Shimozono, Affine insertion and Pieri rules for the affine Grassmannian, Memoirs of the AMS, 208 (2010), no. 977, Arxiv math.CO/0609110 |
[LLMSSZ2013] | (1, 2, 3, 4, 5, 6) T. Lam, L. Lapointe, J. Morse, A. Schilling, M. Shimozono, M. Zabrocki,
![]() |
Authors:
Bases: sage.structure.list_clone.ClonableList
A (standard) strong -tableau is a (saturated) chain in Bruhat order.
Combinatorially, it is a sequence of embedded -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 -tableau is created by specifying
, a standard strong
tableau together with its markings, and a weight
. Here the standard tableau is
represented by a sequence of
-cores
where each of the is a
-core. The standard tableau is a filling
of the diagram for the core
where a strong cover
is represented by letters
in the skew shape
.
Each skew
-core
is a ribbon or multiple
copies of the same ribbon which are separated by
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 -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)
Return the cell of the highest head of label v in the standard part of self.
Return the cell where the head of the ribbon in the highest row is located
in the underlying standard tableau. If there is no cell with entry v then
the cell returned is where
is the length of the first row.
This cell is calculated by iterating through the diagonals of the tableau.
INPUT:
OUTPUT:
EXAMPLES:
sage: T = StrongTableau([[-1,2,-3],[-2,3],[3]], 1)
sage: [T.cell_of_highest_head(v) for v in range(1,5)]
[(0, 0), (1, 0), (2, 0), (0, 3)]
sage: T = StrongTableau([[None,None,-3,4],[3,-4]],2)
sage: [T.cell_of_highest_head(v) for v in range(1,5)]
[(1, 0), (1, 1), (0, 4), (0, 4)]
TESTS:
sage: StrongTableau([],2).cell_of_highest_head(1)
(0, 0)
Return location of marked head labeled by v in the standard part of self.
Return the coordinates of the v-th marked cell in the strong standard tableau
self. If there is no mark, then the value returned is where
is
the length of the first row.
INPUT:
OUTPUT:
EXAMPLES:
sage: T = StrongTableau([[-1, -3, 4, -5], [-2], [-4]], 3)
sage: [ T.cell_of_marked_head(i) for i in range(1,7)]
[(0, 0), (1, 0), (0, 1), (2, 0), (0, 3), (0, 4)]
sage: T = StrongTableau([[None, None, -1, -2], [None, None], [-1, -2], [1, 2], [-3], [3], [3], [3]], 4)
sage: [ T.cell_of_marked_head(i) for i in range(1,7)]
[(2, 0), (0, 2), (2, 1), (0, 3), (4, 0), (0, 4)]
TESTS:
sage: StrongTableau([],4).cell_of_marked_head(4)
(0, 0)
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.
OUPUT:
EXAMPLES:
sage: T = StrongTableau([[-1,-2,-4,7],[-3,6,-6,8],[4,-7],[-5,-8]], 3)
sage: T.cells_head_dictionary()
{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: T = StrongTableau([[None, 4, -4, -6, -7, 8, 8, -8], [None, -5, 8, 8, 8], [-3, 6]],3)
sage: T.cells_head_dictionary()
{1: [(2, 0)],
2: [(0, 2)],
3: [(1, 1)],
4: [(2, 1), (0, 3)],
5: [(0, 4)],
6: [(1, 4), (0, 7)]}
sage: StrongTableau([[None, None], [None, -1]], 4).cells_head_dictionary()
{1: [(1, 1)]}
TESTS:
sage: StrongTableau([[None, None], [None]], 4).cells_head_dictionary()
{}
sage: StrongTableau([],4).cells_head_dictionary()
{}
Return a list of cells of the heads with label v in the standard part of self.
A list of cells which are heads of the ribbons with label v in the standard part of the tableau self. If there is no cell labelled by v then return the empty list.
INPUT:
OUPUT:
EXAMPLES:
sage: T = StrongTableau([[None, None, -1, -2], [None, None], [-1, -2], [1, 2], [-3], [3], [3], [3]], 4)
sage: T.cells_of_heads(1)
[(2, 0)]
sage: T.cells_of_heads(2)
[(3, 0), (0, 2)]
sage: T.cells_of_heads(3)
[(2, 1)]
sage: T.cells_of_heads(4)
[(3, 1), (0, 3)]
sage: T.cells_of_heads(5)
[(4, 0)]
sage: T.cells_of_heads(6)
[]
TESTS:
sage: StrongTableau([[None, None], [None]], 4).cells_of_heads(1)
[]
sage: StrongTableau([],4).cells_of_heads(1)
[]
Return a list of all cells the marked ribbon labeled by v in the standard part of self.
Return the list of coordinates of the cells which are in the marked ribbon with label v in the standard part of the tableau. Note that the result is independent of the weight of the tableau.
The cells are listed from largest content (where the mark is located) to the smallest. Hence, the first entry in this list will be the marked cell.
INPUT:
OUTPUT:
EXAMPLES:
sage: T = StrongTableau([[-1, -1, -2, -2, 3], [2, -3], [-3]],3)
sage: T.to_standard_list()
[[-1, -2, -3, -4, 6], [4, -6], [-5]]
sage: T.cells_of_marked_ribbon(1)
[(0, 0)]
sage: T.cells_of_marked_ribbon(4)
[(0, 3)]
sage: T = StrongTableau([[-1,-2,-4,-7],[-3,6,-6,8],[4,7],[-5,-8]], 3)
sage: T.cells_of_marked_ribbon(6)
[(1, 2), (1, 1)]
sage: T.cells_of_marked_ribbon(9)
[]
sage: T = StrongTableau([[None, None, -1, -1, 3], [1, -3], [-3]],3)
sage: T.to_standard_list()
[[None, None, -1, -2, 4], [2, -4], [-3]]
sage: T.cells_of_marked_ribbon(1)
[(0, 2)]
TESTS:
sage: StrongTableau([],3).cells_of_marked_ribbon(1)
[]
Check that self is a valid strong -tableau.
This function verifies that the outer and inner shape of the parent class is equal to the outer and inner shape of the tableau, that the tableau portion of self is a valid standard tableau, that the marks are placed correctly and that the size and weight agree.
EXAMPLES:
sage: T = StrongTableau([[-1, -1, -2], [2]], 2)
sage: T.check()
sage: T = StrongTableau([[None, None, 2, -4, -4], [-1, 4], [-2]], 3)
sage: T.check()
TESTS:
sage: ST = StrongTableaux(2, [3,1], [1,1,1,1])
sage: ST([[-1,-2,3],[-3]])
Traceback (most recent call last):
...
ValueError: The size of the tableau [[-1, -2, 3], [-3]] and weight (1, 1, 1, 1) do not match
sage: ST([[-1,-3],[-2],[3]])
Traceback (most recent call last):
...
ValueError: The outer shape of the parent does not agree with the outer shape of the tableau!
sage: StrongTableau([[-1, -2, 2], [1]], 2)
Traceback (most recent call last):
...
ValueError: The marks in [[-1, -2, 2], [1]] are not correctly placed.
sage: StrongTableau([[-1, -2, 3], [3]], 2)
Traceback (most recent call last):
...
ValueError: The marks in [[-1, -2, 3], [3]] are not correctly placed.
sage: StrongTableau([[-1,-2,-4,7],[-3,6,-6,8],[4,-7],[-5,-8]], 3, [2,2,3,1])
Traceback (most recent call last):
...
ValueError: The weight=(2, 2, 3, 1) and the markings on the standard tableau=[[-1, -2, -4, 7], [-3, 6, -6, 8], [4, -7], [-5, -8]] do not agree.
Return the diagonal of the highest head of the cells labeled v in the standard part of self.
Return the content of the cell of the head in the highest row of all ribbons labeled by v of the underlying standard tableau. If there is no cell with entry v then the value returned is the length of the first row.
INPUT:
OUTPUT:
EXAMPLES:
sage: [StrongTableau([[-1,2,-3],[-2,3],[3]], 1).content_of_highest_head(v) for v in range(1,5)]
[0, -1, -2, 3]
TESTS:
sage: StrongTableau([], 4).content_of_highest_head(1)
0
sage: StrongTableau([[-1,-1]], 4).content_of_highest_head(3)
2
Return the diagonal of the marked label v in the standard part of self.
Return the content (the coordinate of the cell) of the v-th marked cell
in the strong standard tableau self. If there is no mark, then the value
returned is the size of first row.
INPUT:
OUTPUT:
EXAMPLES:
sage: [ StrongTableau([[-1, -3, 4, -5], [-2], [-4]], 3).content_of_marked_head(i) for i in range(1,7)]
[0, -1, 1, -2, 3, 4]
sage: T = StrongTableau([[None, None, -1, -2], [None, None], [-1, -2], [1, 2], [-3], [3], [3], [3]], 4)
sage: [ T.content_of_marked_head(i) for i in range(1,7)]
[-2, 2, -1, 3, -4, 4]
TESTS:
sage: StrongTableau([],4).content_of_marked_head(4)
0
A list of contents of the cells which are heads of the ribbons with label v.
If there is no cell labelled by v then return the empty list.
INPUT:
OUPUT:
EXAMPLES:
sage: T = StrongTableau([[None, None, -1, -2], [None, None], [-1, -2], [1, 2], [-3], [3], [3], [3]], 4)
sage: T.contents_of_heads(1)
[-2]
sage: T.contents_of_heads(2)
[-3, 2]
sage: T.contents_of_heads(3)
[-1]
sage: T.contents_of_heads(4)
[-2, 3]
sage: T.contents_of_heads(5)
[-4]
sage: T.contents_of_heads(6)
[]
TESTS:
sage: StrongTableau([[None, None], [None]], 4).contents_of_heads(1)
[]
sage: StrongTableau([],4).contents_of_heads(1)
[]
Return the entries on the diagonal of self.
Return the entries in the tableau that are in the cells with
equal to diag (that is, with content equal to diag).
INPUT:
OUTPUT:
EXAMPLES:
sage: T = StrongTableau([[None, None, -1, -2], [None, None], [-1, -2], [1, 2], [-3], [3], [3], [3]], 4)
sage: T.entries_by_content(0)
[]
sage: T.entries_by_content(1)
[]
sage: T.entries_by_content(2)
[-1]
sage: T.entries_by_content(-2)
[-1, 2]
TESTS:
sage: StrongTableau([[None, None], [None]], 4).entries_by_content(1)
[]
sage: StrongTableau([],4).entries_by_content(1)
[]
Return the entries on the diagonal of the standard part of self.
Return the entries in the tableau that are in the cells with
equal to diag (that is, with content equal to diag) in the
standard tableau.
INPUT:
OUTPUT:
EXAMPLES:
sage: T = StrongTableau([[None, None, -1, -2], [None, None], [-1, -2], [1, 2], [-3], [3], [3], [3]], 4)
sage: T.entries_by_content_standard(0)
[]
sage: T.entries_by_content_standard(1)
[]
sage: T.entries_by_content_standard(2)
[-2]
sage: T.entries_by_content_standard(-2)
[-1, 4]
TESTS:
sage: StrongTableau([[None, None], [None]], 4).entries_by_content_standard(1)
[]
sage: StrongTableau([],4).entries_by_content_standard(1)
[]
Return a list of strong marked tableaux with length one longer than self.
Return list of all strong tableaux obtained from self by extending to a core which follows the shape of self in the strong order.
OUTPUT:
EXAMPLES:
sage: T = StrongTableau([[-1,-2,-4,-7],[-3,6,-6,8],[4,7],[-5,-8]], 3, [2,2,3,1])
sage: T.follows_tableau()
[[[-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, 5], [-2, 3, -3, 4], [2, 3, -5], [-3, -4], [5]],
[[-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: StrongTableau([[-1,-2],[-3,-4]],3).follows_tableau()
[[[-1, -2, 5, 5, -5], [-3, -4]], [[-1, -2, 5], [-3, -4], [-5]],
[[-1, -2, -5], [-3, -4], [5]], [[-1, -2], [-3, -4], [-5], [5], [5]]]
TESTS:
sage: StrongTableau([[None, None], [None]], 4).follows_tableau()
[[[None, None, -1], [None]], [[None, None], [None, -1]], [[None, None], [None], [-1]]]
sage: StrongTableau([],4).follows_tableau()
[[[-1]]]
The number of rows occupied by one of the ribbons with label v.
The number of rows occupied by the marked ribbon with label v (and by consequence the number of rows occupied by any ribbon with the same label) in the standard part of self.
INPUT:
OUTPUT:
EXAMPLES:
sage: T = StrongTableau([[-1, -1, -2, -2, 3], [2, -3], [-3]],3)
sage: T.to_standard_list()
[[-1, -2, -3, -4, 6], [4, -6], [-5]]
sage: T.height_of_ribbon(1)
1
sage: T.height_of_ribbon(4)
1
sage: T = StrongTableau([[None,None,1,-2],[None,-3,4,-5],[-1,3],[-4,5]], 3)
sage: T.height_of_ribbon(3)
2
sage: T.height_of_ribbon(6)
0
TESTS:
sage: StrongTableau([[None, None], [None]], 4).height_of_ribbon(1)
0
sage: StrongTableau([],4).height_of_ribbon(1)
0
Return the inner shape of self.
If self is a strong skew tableau, then this method returns the inner shape (the shape of the cells labelled with None). If self is not skew, then the inner shape is empty.
OUTPUT:
EXAMPLES:
sage: StrongTableau([[None, None, -1, -2], [None, None], [-1, -2], [1, 2], [-3], [3], [3], [3]], 4).inner_shape()
[2, 2]
sage: StrongTableau([[-1,-2,-4,-7],[-3,6,-6,8],[4,7],[-5,-8]], 3, [2,2,3,1]).inner_shape()
[]
TESTS:
sage: StrongTableau([[None, None], [None]], 4).inner_shape()
[2, 1]
sage: StrongTableau([],4).inner_shape()
[]
Return the intermediate shapes of self.
A (skew) tableau with letters can be viewed as a sequence of
shapes, where the
-th shape is given by the shape of the subtableau on letters
.
The output is the list of these shapes. The marked cells are ignored so to recover the strong tableau one would need the intermediate shapes and the content_of_marked_head() for each pair of adjacent shapes in the list.
OUTPUT:
EXAMPLES:
sage: T = StrongTableau([[-1,-2,-4,-7],[-3,6,-6,8],[4,7],[-5,-8]], 3, [2,2,3,1])
sage: T.intermediate_shapes()
[[], [2], [3, 1, 1], [4, 3, 2, 1], [4, 4, 2, 2]]
sage: T = StrongTableau([[None, None, -1, -2], [None, None], [-1, -2], [1, 2], [-3], [3], [3], [3]], 4)
sage: T.intermediate_shapes()
[[2, 2], [3, 2, 1, 1], [4, 2, 2, 2], [4, 2, 2, 2, 1, 1, 1, 1]]
TESTS:
sage: StrongTableau([[None, None], [None]], 4).intermediate_shapes()
[[2, 1]]
sage: StrongTableau([],4).intermediate_shapes()
[[]]
Test if self is a column strict tableau with respect to the weight mu.
INPUT:
OUTPUT:
EXAMPLES:
sage: StrongTableau([[-1, -2, -3], [3]], 2).is_column_strict_with_weight([3])
True
sage: StrongTableau([[-1, -2, 3], [-3]], 2).is_column_strict_with_weight([3])
False
TESTS:
sage: StrongTableau([[None, None, None], [None]], 2).is_column_strict_with_weight([])
True
sage: StrongTableau([], 4).is_column_strict_with_weight([])
True
Action of transposition tij on self by adding marked ribbons.
Computes the left action of the transposition tij on the tableau. If tij acting on the element of the affine grassmannian raises the length by 1, then this function will add a cell to the standard tableau.
INPUT:
OUPUT:
EXAMPLES:
sage: StrongTableau( [[None, -1, -2, -3], [3], [-4]], 3, weight=[1,1,1,1] ).left_action([0,1])
[[None, -1, -2, -3, 5], [3, -5], [-4]]
sage: StrongTableau( [[None, -1, -2, -3], [3], [-4]], 3, weight=[1,1,1,1] ).left_action([4,5])
[[None, -1, -2, -3, -5], [3, 5], [-4]]
sage: T = StrongTableau( [[None, -1, -2, -3], [3], [-4]], 3, weight=[1,1,1,1] )
sage: T.left_action([-3,-2])
[[None, -1, -2, -3], [3], [-4], [-5]]
sage: T = StrongTableau( [[None, -1, -2, -3], [3], [-4]], 3, weight=[3,1] )
sage: T.left_action([-3,-2])
[[None, -1, -1, -1], [1], [-2], [-3]]
sage: T
[[None, -1, -1, -1], [1], [-2]]
sage: T.check()
sage: T.weight()
(3, 1)
TESTS:
sage: StrongTableau([[None, None], [None]], 4).left_action([-2,-1])
[[None, None], [None], [-1]]
sage: StrongTableau([],4).left_action([0,1])
[[-1]]
Number of connected components of ribbons with label v in the standard part.
The number of connected components is calculated by finding the number of cells with label v in the standard part of the tableau and dividing by the number of cells in the ribbon.
INPUT:
OUTPUT:
EXAMPLES:
sage: T = StrongTableau([[-1, -1, -2, -2, 3], [2, -3], [-3]],3)
sage: T.to_standard_list()
[[-1, -2, -3, -4, 6], [4, -6], [-5]]
sage: T.number_of_connected_components(1)
1
sage: T.number_of_connected_components(4)
2
sage: T = StrongTableau([[-1,-2,-4,-7],[-3,6,-6,8],[4,7],[-5,-8]], 3)
sage: T.number_of_connected_components(6)
1
sage: T.number_of_connected_components(9)
0
TESTS:
sage: StrongTableau([[None, None], [None]], 4).number_of_connected_components(1)
0
sage: StrongTableau([],4).number_of_connected_components(1)
0
Return the outer shape of self.
This method returns the outer shape of self as viewed as a Core.
The outer shape of a strong tableau is always a -core.
OUTPUT:
EXAMPLES:
sage: StrongTableau([[None, None, -1, -2], [None, None], [-1, -2], [1, 2], [-3], [3], [3], [3]], 4).outer_shape()
[4, 2, 2, 2, 1, 1, 1, 1]
sage: StrongTableau([[-1,-2,-4,-7],[-3,6,-6,8],[4,7],[-5,-8]], 3, [2,2,3,1]).outer_shape()
[4, 4, 2, 2]
TESTS:
sage: StrongTableau([[None, None], [None]], 4).outer_shape()
[2, 1]
sage: StrongTableau([],4).outer_shape()
[]
Print the strong tableau self in pretty print format.
EXAMPLES:
sage: T = StrongTableau([[-1,-2,-4,-7],[-3,6,-6,8],[4,7],[-5,-8]], 3, [2,2,3,1])
sage: T.pp()
-1 -1 -2 -3
-2 3 -3 4
2 3
-3 -4
sage: T = StrongTableau([[None, None, -1, -2], [None, None], [-1, -2], [1, 2], [-3], [3], [3], [3]], 4)
sage: T.pp()
. . -1 -2
. .
-1 -2
1 2
-3
3
3
3
sage: Tableaux.global_options(convention="French")
sage: T.pp()
3
3
3
-3
1 2
-1 -2
. .
. . -1 -2
sage: Tableaux.global_options(convention="English")
Restrict the standard part of the tableau to the labels .
Return the tableau consisting of the labels of the standard part of self
restricted to the labels of through r. The result is another
StrongTableau object.
INPUT:
OUTPUT:
EXAMPLES:
sage: T = StrongTableau([[None, None, -4, 5, -5], [None, None], [-1, -3], [-2], [2], [2], [3]], 4, weight=[1,1,1,1,1])
sage: T.restrict(3)
[[None, None], [None, None], [-1, -3], [-2], [2], [2], [3]]
sage: TT = T.restrict(0)
sage: TT
[[None, None], [None, None]]
sage: TT == StrongTableau( [[None, None], [None, None]], 4 )
True
sage: T.restrict(5) == T
True
TESTS:
sage: StrongTableau([[None, None], [None]], 4).restrict(1)
[[None, None], [None]]
sage: StrongTableau([],4).restrict(1)
[]
Number of ribbons of label v higher than the marked ribbon in the standard part.
Return the number of copies of the ribbon with label v in the standard part of self which are in a higher row than the marked ribbon. Note that the result is independent of the weight of the tableau.
INPUT:
OUTPUT:
EXAMPLES:
sage: T = StrongTableau([[-1,-2,-4,-7],[-3,6,-6,8],[4,7],[-5,-8]], 3)
sage: T.ribbons_above_marked(4)
1
sage: T.ribbons_above_marked(6)
0
sage: T.ribbons_above_marked(9)
0
sage: StrongTableau([[-1,-2,-3,-4],[2,3,4],[3,4],[4]], 1).ribbons_above_marked(4)
3
TESTS:
sage: StrongTableau([[None, None], [None]], 4).ribbons_above_marked(1)
0
sage: StrongTableau([],4).ribbons_above_marked(1)
0
Sets a new weight mu for self.
This method first tests if the underlying standard tableau is column-strict with respect to the weight mu. If it is, then it changes the weight and returns the tableau; otherwise it raises an error.
INPUT:
EXAMPLES:
sage: StrongTableau( [[-1, -2, -3], [3]], 2 ).set_weight( [3] )
[[-1, -1, -1], [1]]
sage: StrongTableau( [[-1, -2, -3], [3]], 2 ).set_weight( [0,3] )
[[-2, -2, -2], [2]]
sage: StrongTableau( [[-1, -2, 3], [-3]], 2 ).set_weight( [2, 0, 1] )
[[-1, -1, 3], [-3]]
sage: StrongTableau( [[-1, -2, 3], [-3]], 2 ).set_weight( [3] )
Traceback (most recent call last):
...
ValueError: [[-1, -2, 3], [-3]] is not a semistandard strong tableau with respect to the partition [3]
TESTS:
sage: StrongTableau([[None, None], [None]], 4).set_weight([])
[[None, None], [None]]
sage: StrongTableau([],4).set_weight([])
[]
Return the shape of self.
If self is a skew tableau then return a pair of -cores consisting of the
outer and the inner shape. If self is strong tableau with no inner shape then
return a
-core.
INPUT:
OUTPUT:
EXAMPLES:
sage: T = StrongTableau([[None, None, -1, -2], [None, None], [-1, -2], [1, 2], [-3], [3], [3], [3]], 4)
sage: T.shape()
([4, 2, 2, 2, 1, 1, 1, 1], [2, 2])
sage: StrongTableau([[-1, -2, 3], [-3]], 2).shape()
[3, 1]
sage: type(StrongTableau([[-1, -2, 3], [-3]], 2).shape())
<class 'sage.combinat.core.Cores_length_with_category.element_class'>
TESTS:
sage: StrongTableau([[None, None, None], [None]], 2).shape()
([3, 1], [3, 1])
sage: StrongTableau([],4).shape()
[]
Return the size of the strong tableau.
The size of the strong tableau is the sum of the entries in the
weight(). It will also be equal to the length of the
outer shape (as a -core) minus the length of the inner shape.
See also
OUTPUT:
EXAMPLES:
sage: StrongTableau([[-1, -2, -3, 4], [-4], [-5]], 3).size()
5
sage: StrongTableau([[None, None, -1, 2], [-2], [-3]], 3).size()
3
TESTS:
sage: StrongTableau([[None, None], [None]], 4).size()
0
sage: StrongTableau([],4).size()
0
Return the spin statistic of the tableau self.
The spin is an integer statistic on a strong marked tableau. It is
the sum of plus the number of connected components above the
marked one where
is the height of the marked ribbon and
is
the number of connected components.
The -Schur functions with a parameter
can be defined as
where the sum is over all column strict marked strong -tableaux
of shape
and partition content.
OUTPUT:
EXAMPLES:
sage: StrongTableau([[-1,-2,5,6],[-3,-4,-7,8],[-5,-6],[7,-8]], 3, [2,2,3,1]).spin()
1
sage: StrongTableau([[-1,-2,-4,-7],[-3,6,-6,8],[4,7],[-5,-8]], 3, [2,2,3,1]).spin()
2
sage: StrongTableau([[None,None,-1,-3],[-2,3,-3,4],[2,3],[-3,-4]], 3).spin()
2
sage: ks3 = SymmetricFunctions(QQ['t'].fraction_field()).kschur(3)
sage: t = ks3.realization_of().t
sage: m = ks3.ambient().realization_of().m()
sage: myks221 = sum(sum(t**T.spin() for T in StrongTableaux(3,[3,2,1],weight=mu))*m(mu) for mu in Partitions(5, max_part=3))
sage: myks221 == m(ks3[2,2,1])
True
sage: h = ks3.ambient().realization_of().h()
sage: Core([4,4,2,2],4).to_bounded_partition()
[2, 2, 2, 2]
sage: ks3[2,2,2,2].lift().scalar(h[3,3,2]) == sum( t**T.spin() for T in StrongTableaux(3, [4,4,2,2], weight=[3,3,2]) )
True
TESTS:
sage: StrongTableau([[None, None], [None]], 4).spin()
0
sage: StrongTableau([],4).spin()
0
Return the spin of the ribbon with label v in the standard part of self.
The spin of a ribbon is an integer statistic. It is the sum of plus
the number of connected components above the marked one where
is the height
of the marked ribbon and
is the number of connected components.
INPUT:
OUTPUT:
EXAMPLES:
sage: T = StrongTableau([[-1,-2,5,6],[-3,-4,-7,8],[-5,-6],[7,-8]], 3)
sage: [T.spin_of_ribbon(v) for v in range(1,9)]
[0, 0, 0, 0, 0, 0, 1, 0]
sage: T = StrongTableau([[None,None,-1,-3],[-2,3,-3,4],[2,3],[-3,-4]], 3)
sage: [T.spin_of_ribbon(v) for v in range(1,7)]
[0, 1, 0, 0, 1, 0]
TESTS:
sage: StrongTableau([[None, None], [None]], 4).spin_of_ribbon(1)
0
sage: StrongTableau([],4).spin_of_ribbon(1)
0
Return the marked column strict (possibly skew) tableau as a list of lists.
OUTPUT:
EXAMPLES:
sage: StrongTableau([[-1, -2, -3, 4], [-4], [-5]], 3).set_weight([2,1,1,1]).to_list()
[[-1, -1, -2, 3], [-3], [-4]]
sage: StrongTableau([[None, None, -1, -2], [None, None], [-1, -2], [1, 2], [-3], [3], [3], [3]], 4).to_list()
[[None, None, -1, -2], [None, None], [-1, -2], [1, 2], [-3], [3], [3], [3]]
sage: StrongTableau([[-1, -2, -3, 4], [-4], [-5]], 3, [3,1,1]).to_list()
[[-1, -1, -1, 2], [-2], [-3]]
TESTS:
sage: StrongTableau([[None, None], [None]], 4).to_list()
[[None, None], [None]]
sage: StrongTableau([],4).to_list()
[]
Return the underlying standard strong tableau as a list of lists.
Internally, for a strong tableau the standard strong tableau and its weight is stored separately. This method returns the underlying standard part.
OUTPUT:
EXAMPLES:
sage: StrongTableau([[-1, -2, -3, 4], [-4], [-5]], 3, [3,1,1]).to_standard_list()
[[-1, -2, -3, 4], [-4], [-5]]
sage: StrongTableau([[None, None, -1, -2], [None, None], [-1, -2], [1, 2], [-3], [3], [3], [3]], 4).to_standard_list()
[[None, None, -2, -4], [None, None], [-1, -3], [2, 4], [-5], [5], [5], [5]]
TESTS:
sage: StrongTableau([[None, None], [None]], 4).to_standard_list()
[[None, None], [None]]
sage: StrongTableau([],4).to_standard_list()
[]
Return the underlying standard strong tableau as a StrongTableau object.
Internally, for a strong tableau the standard strong tableau and its weight is stored separately. This method returns the underlying standard part as a StrongTableau.
OUTPUT:
EXAMPLES:
sage: T = StrongTableau([[-1, -2, -3, 4], [-4], [-5]], 3, [3,1,1])
sage: T.to_standard_tableau()
[[-1, -2, -3, 4], [-4], [-5]]
sage: T.to_standard_tableau() == T.to_standard_list()
False
sage: StrongTableau([[None, None, -1, -2], [None, None], [-1, -2], [1, 2], [-3], [3], [3], [3]], 4).to_standard_tableau()
[[None, None, -2, -4], [None, None], [-1, -3], [2, 4], [-5], [5], [5], [5]]
TESTS:
sage: StrongTableau([[None, None], [None]], 4).to_standard_tableau()
[[None, None], [None]]
sage: StrongTableau([],4).to_standard_tableau()
[]
Return a list of transpositions corresponding to self.
Given a strong column strict tableau self returns the list of transpositions which when applied to the left of an empty tableau gives the corresponding strong standard tableau.
OUTPUT:
EXAMPLES:
sage: T = StrongTableau([[-1, -1, -1], [1]],2)
sage: T.to_transposition_sequence()
[[2, 3], [1, 2], [0, 1]]
sage: T = StrongTableau([[-1, -1, 2], [-2]],2)
sage: T.to_transposition_sequence()
[[-1, 0], [1, 2], [0, 1]]
sage: T = StrongTableau([[None, -1, 2, -3], [-2, 3]],2)
sage: T.to_transposition_sequence()
[[3, 4], [-1, 0], [1, 2]]
TESTS:
sage: StrongTableau([[None, None], [None]], 4).to_transposition_sequence()
[]
sage: StrongTableau([],4).to_transposition_sequence()
[]
Return the tableau as a list of lists with markings removed.
Return the list of lists of the rows of the tableau where the markings have been removed.
OUTPUT:
EXAMPLES:
sage: T = StrongTableau( [[-1, -2, -3, 4], [-4], [-5]], 3, [3,1,1])
sage: T.to_unmarked_list()
[[1, 1, 1, 2], [2], [3]]
sage: TT = T.set_weight([2,1,1,1])
sage: TT.to_unmarked_list()
[[1, 1, 2, 3], [3], [4]]
sage: StrongTableau( [[None, None, -1, -2], [None, None], [-1, -2], [1, 2], [-3], [3], [3], [3]], 4).to_unmarked_list()
[[None, None, 1, 2], [None, None], [1, 2], [1, 2], [3], [3], [3], [3]]
TESTS:
sage: StrongTableau([[None, None], [None]], 4).to_unmarked_list()
[[None, None], [None]]
sage: StrongTableau([],4).to_unmarked_list()
[]
Return the standard part of the tableau as a list of lists with markings removed.
Return the list of lists of the rows of the tableau where the markings have been removed.
OUTPUT:
EXAMPLES:
sage: StrongTableau( [[-1, -2, -3, 4], [-4], [-5]], 3, [3,1,1]).to_unmarked_standard_list()
[[1, 2, 3, 4], [4], [5]]
sage: StrongTableau( [[None, None, -1, -2], [None, None], [-1, -2], [1, 2], [-3], [3], [3], [3]], 4).to_unmarked_standard_list()
[[None, None, 2, 4], [None, None], [1, 3], [2, 4], [5], [5], [5], [5]]
TESTS:
sage: StrongTableau([[None, None], [None]], 4).to_unmarked_standard_list()
[[None, None], [None]]
sage: StrongTableau([],4).to_unmarked_standard_list()
[]
Return the weight of the tableau.
The weight is a list of non-negative integers indicating the number of 1s, number of 2s, number of 3s, etc.
OUTPUT:
EXAMPLES:
sage: T = StrongTableau([[-1, -2, -3, 4], [-4], [-5]], 3); T.weight()
(1, 1, 1, 1, 1)
sage: T.set_weight([3,1,1]).weight()
(3, 1, 1)
sage: StrongTableau([[-1,-1,-2,-3],[-2,3,-3,4],[2,3],[-3,-4]], 3).weight()
(2, 2, 3, 1)
TESTS:
sage: StrongTableau([[None, None], [None]], 4).weight()
()
sage: StrongTableau([],4).weight()
()
Bases: sage.structure.unique_representation.UniqueRepresentation, sage.structure.parent.Parent
TESTS:
sage: strongT = StrongTableaux(2, [3,1], weight=[2,1])
sage: TestSuite(strongT).run()
sage: strongT = StrongTableaux(0, [2,2], weight=[2,2])
Traceback (most recent call last):
...
ValueError: The input k has to be a positive integer
alias of StrongTableau
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:
OUTPUT:
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]]
TESTS:
sage: StrongTableaux.add_marking([[None,None,None],[None]], [], 2, [])
[[None, None, None], [None]]
sage: StrongTableaux.add_marking([], [], 2, [])
[]
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]]
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:
OUPUT:
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)]}
TESTS:
sage: StrongTableaux.cells_head_dictionary([[None, None, None],[None]])
{}
sage: StrongTableaux.cells_head_dictionary([])
{}
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:
OUTPUT:
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]]]
TESTS:
sage: StrongTableaux.follows_tableau_unsigned_standard([[None, None, None], [None]], 2)
[[[None, None, None, 1], [None, 1]], [[None, None, None], [None], [1]]]
sage: StrongTableaux.follows_tableau_unsigned_standard([], 4)
[[[1]]]
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:
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.global_options(display="array")
sage: T
1 2 3
4 5
sage: Tableaux.global_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.global_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.global_options(ascii_art="normal")
sage: ascii_art(t)
+---+---+
| 4 | 5 |
+---+---+---+
| 1 | 2 | 3 |
+---+---+---+
sage: Tableaux.global_options(ascii_art="compact")
sage: ascii_art(t)
|4|5|
|1|2|3|
sage: Tableaux.global_options.reset()
See GlobalOptions for more features of these options.
Return the inner shape of the class of strong tableaux.
OUTPUT:
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]
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:
OUTPUT:
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]]
TESTS:
sage: StrongTableaux.marked_CST_to_transposition_sequence([[None, None, None], [None]], 2)
[]
sage: StrongTableaux.marked_CST_to_transposition_sequence([], 4)
[]
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:
OUTPUT:
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]]]
TESTS:
sage: list(StrongTableaux.marked_given_unmarked_and_weight_iterator([[None, None, None],[None]], 2, []))
[[[None, None, None], [None]]]
sage: list(StrongTableaux.marked_given_unmarked_and_weight_iterator([], 4, weight=[]))
[[]]
Return the outer shape of the class of strong tableaux.
OUTPUT:
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]
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:
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])
An iterator for generating standard strong marked tableaux.
An iterator which generates all standard marked -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:
OUPUT:
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
TESTS:
sage: list(StrongTableaux.standard_marked_iterator(2,0,inner_shape=[3,1]))
[[[None, None, None], [None]]]
sage: list(StrongTableaux.standard_marked_iterator(4,0))
[[]]
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 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:
OUTPUT:
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
TESTS:
sage: list(StrongTableaux.standard_unmarked_iterator(2,0, outer_shape=[3,1], inner_shape=[3,1]))
[[[None, None, None], [None]]]
sage: list(StrongTableaux.standard_unmarked_iterator(4,0, outer_shape=[]))
[[]]
Return a strong tableau correponding to a sequence of transpositions.
This method returns the action by left multiplication on the empty strong tableau by transpositions specified by transeq.
INPUT:
OUTPUT:
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]]
TESTS:
sage: StrongTableaux.transpositions_to_standard_strong([], 2, [[None, None, None], [None]])
[[None, None, None], [None]]
sage: StrongTableaux.transpositions_to_standard_strong([], 4, [])
[]
This is the dispatcher method for the element class of weak -tableaux.
Standard weak -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
-bounded partitions, and one in terms of factorizations of affine Grassmannian
elements. For semistandard weak
-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:
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 -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
TESTS:
sage: t = WeakTableau([[2,0],[3,2],[1,0]], 3, representation = "bla")
Traceback (most recent call last):
...
NotImplementedError: The representation option needs to be 'core', 'bounded', or 'factorized_permuation'
Bases: sage.structure.list_clone.ClonableList
Abstract class for the various element classes of WeakTableau.
Return the intermediate shapes of self.
A (skew) tableau with letters can be viewed as a sequence of shapes,
where the
-th shape is given by the shape of the subtableau on letters
.
The output is the list of these shapes.
EXAMPLES:
sage: t = WeakTableau([[1, 1, 2, 2, 3], [2, 3], [3]],3)
sage: t.intermediate_shapes()
[[], [2], [4, 1], [5, 2, 1]]
sage: t = WeakTableau([[None, None, 2, 3, 4], [1, 4], [2]], 3)
sage: t.intermediate_shapes()
[[2], [2, 1], [3, 1, 1], [4, 1, 1], [5, 2, 1]]
sage: t = WeakTableau([[1,1,1],[2,2],[3]], 3, representation = 'bounded')
sage: t.intermediate_shapes()
[[], [3], [3, 2], [3, 2, 1]]
sage: t = WeakTableau([[None, None, 1], [2, 4], [3]], 3, representation = 'bounded')
sage: t.intermediate_shapes()
[[2], [3], [3, 1], [3, 1, 1], [3, 2, 1]]
sage: t = WeakTableau([[0],[3],[2],[3]], 3, inner_shape = [2], representation = 'factorized_permutation')
sage: t.intermediate_shapes()
[[2], [2, 1], [3, 1, 1], [4, 1, 1], [5, 2, 1]]
Return a pretty print string of the tableau.
EXAMPLES:
sage: t = WeakTableau([[None, 1, 1, 2, 2], [None, 2], [1]], 3)
sage: t.pp()
. 1 1 2 2
. 2
1
sage: t = WeakTableau([[2,0],[3,2]], 3, inner_shape = [2], representation = 'factorized_permutation')
sage: t.pp()
[s2*s0, s3*s2]
Return the analogue of self in the specified representation.
INPUT:
EXAMPLES:
sage: t = WeakTableau([[1, 1, 2, 3, 4, 4, 5, 5, 6], [2, 3, 5, 5, 6], [3, 4, 7], [5, 6], [6], [7]], 4)
sage: t.parent()._representation
'core'
sage: t.representation('bounded')
[[1, 1, 2, 4], [2, 3, 5], [3, 4], [5, 6], [6], [7]]
sage: t.representation('factorized_permutation')
[s0, s3*s1, s2*s1, s0*s4, s3*s0, s4*s2, s1*s0]
sage: tb = WeakTableau([[1, 1, 2, 4], [2, 3, 5], [3, 4], [5, 6], [6], [7]], 4, representation = 'bounded')
sage: tb.parent()._representation
'bounded'
sage: tb.representation('core') == t
True
sage: tb.representation('factorized_permutation')
[s0, s3*s1, s2*s1, s0*s4, s3*s0, s4*s2, s1*s0]
sage: tp = WeakTableau([[0],[3,1],[2,1],[0,4],[3,0],[4,2],[1,0]], 4, representation = 'factorized_permutation')
sage: tp.parent()._representation
'factorized_permutation'
sage: tp.representation('core') == t
True
sage: tp.representation('bounded') == tb
True
Return the shape of self.
When the tableau is straight, the outer shape is returned. When the tableau is skew, the tuple of the outer and inner shape is returned.
EXAMPLES:
sage: t = WeakTableau([[1, 1, 2, 2, 3], [2, 3], [3]], 3)
sage: t.shape()
[5, 2, 1]
sage: t = WeakTableau([[None, None, 2, 3, 4], [1, 4], [2]], 3)
sage: t.shape()
([5, 2, 1], [2])
sage: t = WeakTableau([[1,1,1],[2,2],[3]], 3, representation = 'bounded')
sage: t.shape()
[3, 2, 1]
sage: t = WeakTableau([[None, None, 1], [2, 4], [3]], 3, representation = 'bounded')
sage: t.shape()
([3, 2, 1], [2])
sage: t = WeakTableau([[2],[0,3],[2,1,0]], 3, representation = 'factorized_permutation')
sage: t.shape()
[5, 2, 1]
sage: t = WeakTableau([[2,0],[3,2]], 3, inner_shape = [2], representation = 'factorized_permutation')
sage: t.shape()
([5, 2, 1], [2])
Return the size of the shape of self.
In the bounded representation, the size of the shape is the number of boxes in the outer shape minus the number of boxes in the inner shape. For the core and factorized permutation representation, the size is the length of the outer shape minus the length of the inner shape.
See also
EXAMPLES:
sage: t = WeakTableau([[None, 1, 1, 2, 2], [None, 2], [1]], 3)
sage: t.shape()
([5, 2, 1], [1, 1])
sage: t.size()
4
sage: t = WeakTableau([[1,1,2],[2,3],[3]], 3, representation="bounded")
sage: t.shape()
[3, 2, 1]
sage: t.size()
6
Return the weight of self.
The weight is a tuple whose -th entry is the number of labels
in the
bounded representation of self.
EXAMPLES:
sage: t = WeakTableau([[1, 1, 2, 2, 3], [2, 3], [3]], 3)
sage: t.weight()
(2, 2, 2)
sage: t = WeakTableau([[None, None, 2, 3, 4], [1, 4], [2]], 3)
sage: t.weight()
(1, 1, 1, 1)
sage: t = WeakTableau([[None,2,3],[3]],2)
sage: t.weight()
(0, 1, 1)
sage: t = WeakTableau([[1,1,1],[2,2],[3]], 3, representation = 'bounded')
sage: t.weight()
(3, 2, 1)
sage: t = WeakTableau([[1,1,2],[2,3],[3]], 3, representation = 'bounded')
sage: t.weight()
(2, 2, 2)
sage: t = WeakTableau([[None, None, 1], [2, 4], [3]], 3, representation = 'bounded')
sage: t.weight()
(1, 1, 1, 1)
sage: t = WeakTableau([[2],[0,3],[2,1,0]], 3, representation = 'factorized_permutation')
sage: t.weight()
(3, 2, 1)
sage: t = WeakTableau([[2,0],[3,2],[1,0]], 3, representation = 'factorized_permutation')
sage: t.weight()
(2, 2, 2)
sage: t = WeakTableau([[2,0],[3,2]], 3, inner_shape = [2], representation = 'factorized_permutation')
sage: t.weight()
(2, 2)
Bases: sage.combinat.k_tableau.WeakTableau_abstract
A (skew) weak -tableau represented in terms of
-bounded partitions.
Check that self is a valid weak -tableau.
EXAMPLES:
sage: t = WeakTableau([[1,1],[2]], 2, representation = 'bounded')
sage: t.check()
sage: t = WeakTableau([[None, None, 1], [2, 4], [3]], 3, representation = 'bounded')
sage: t.check()
TESTS:
sage: t = WeakTableau([[1,1,3],[2,2],[3]], 3, representation = 'bounded')
Traceback (most recent call last):
...
ValueError: This is not a proper weak 3-tableau
sage: T = WeakTableaux(3, [3,1], [2,1], representation = 'bounded')
sage: t = T([[None, 1,1], [2]])
Traceback (most recent call last):
...
ValueError: The inner shape of the parent does not agree with the inner shape of the tableau!
sage: t = WeakTableau([[1,1],[1]], 3, representation = 'bounded')
Traceback (most recent call last):
...
ValueError: The tableaux is not semistandard!
Construct weak -bounded tableau from in
-core tableau.
EXAMPLES:
sage: from sage.combinat.k_tableau import WeakTableau_bounded
sage: WeakTableau_bounded.from_core_tableau([[1, 1, 2, 2, 3], [2, 3], [3]], 3)
[[1, 1, 2], [2, 3], [3]]
sage: WeakTableau_bounded.from_core_tableau([[None, None, 2, 3, 4], [1, 4], [2]], 3)
[[None, None, 3], [1, 4], [2]]
sage: WeakTableau_bounded.from_core_tableau([[None,2,3],[3]], 2)
[[None, 2], [3]]
Return the -charge of self.
INPUT:
OUTPUT:
For the definition of -charge and the various algorithms to compute it see Section 3.3 of [LLMSSZ2013].
EXAMPLES:
sage: t = WeakTableau([[1, 1, 2], [2, 3], [3]], 3, representation = 'bounded')
sage: t.k_charge()
2
sage: t = WeakTableau([[1, 3, 5], [2, 6], [4]], 3, representation = 'bounded')
sage: t.k_charge()
8
sage: t = WeakTableau([[1, 1, 2, 4], [2, 3, 5], [3, 4], [5, 6], [6], [7]], 4, representation = 'bounded')
sage: t.k_charge()
12
Return the shape of self as -bounded partition.
When the tableau is straight, the outer shape is returned as a -bounded
partition. When the tableau is skew, the tuple of the outer and inner shape is
returned as
-bounded partitions.
EXAMPLES:
sage: t = WeakTableau([[1,1,1],[2,2],[3]], 3, representation = 'bounded')
sage: t.shape_bounded()
[3, 2, 1]
sage: t = WeakTableau([[None, None, 1], [2, 4], [3]], 3, representation = 'bounded')
sage: t.shape_bounded()
([3, 2, 1], [2])
Return the shape of self as -core.
When the tableau is straight, the outer shape is returned as a -core.
When the tableau is skew, the tuple of the outer and inner shape is returned as
-cores.
EXAMPLES:
sage: t = WeakTableau([[1,1,1],[2,2],[3]], 3, representation = 'bounded')
sage: t.shape_core()
[5, 2, 1]
sage: t = WeakTableau([[None, None, 1], [2, 4], [3]], 3, representation = 'bounded')
sage: t.shape_core()
([5, 2, 1], [2])
Return the weak -tableau self where the shape of each restricted tableau is a
-core.
EXAMPLES:
sage: t = WeakTableau([[1,1,2,4],[2,3,5],[3,4],[5,6],[6],[7]], 4, representation = 'bounded')
sage: c = t.to_core_tableau(); c
[[1, 1, 2, 3, 4, 4, 5, 5, 6], [2, 3, 5, 5, 6], [3, 4, 7], [5, 6], [6], [7]]
sage: type(c)
<class 'sage.combinat.k_tableau.WeakTableaux_core_with_category.element_class'>
sage: t = WeakTableau([], 4, representation = 'bounded')
sage: t.to_core_tableau()
[]
sage: from sage.combinat.k_tableau import WeakTableau_bounded
sage: t = WeakTableau([[1,1,2],[2,3],[3]], 3, representation = 'bounded')
sage: WeakTableau_bounded.from_core_tableau(t.to_core_tableau(),3)
[[1, 1, 2], [2, 3], [3]]
sage: t == WeakTableau_bounded.from_core_tableau(t.to_core_tableau(),3)
True
sage: t = WeakTableau([[None, None, 1], [2, 4], [3]], 3, representation = 'bounded')
sage: t.to_core_tableau()
[[None, None, 1, 2, 4], [2, 4], [3]]
sage: t == WeakTableau_bounded.from_core_tableau(t.to_core_tableau(),3)
True
Bases: sage.combinat.k_tableau.WeakTableau_abstract
A (skew) weak -tableau represented in terms of
-cores.
Check that self is a valid weak -tableau.
EXAMPLES:
sage: t = WeakTableau([[1, 1, 2], [2]], 2)
sage: t.check()
sage: t = WeakTableau([[None, None, 2, 3, 4], [1, 4], [2]], 3)
sage: t.check()
TESTS:
sage: T = WeakTableaux(2, [3,1], [1,1,1,1])
sage: t = T([[1,2,3],[3]])
Traceback (most recent call last):
...
ValueError: The weight of the parent does not agree with the weight of the tableau!
sage: t = WeakTableau([[1, 2, 2], [1]], 2)
Traceback (most recent call last):
...
ValueError: The tableau is not semistandard!
Return a dictionary assigning to all residues of self with label v a list of cells with the given residue.
INPUT:
OUTPUT:
EXAMPLES:
sage: t = WeakTableau([[1, 1, 2, 2, 3], [2, 3], [3]],3)
sage: t.dictionary_of_coordinates_at_residues(3)
{0: [(0, 4), (1, 1)], 2: [(2, 0)]}
sage: t = WeakTableau([[None, None, 1, 1, 4], [1, 4], [3]], 3)
sage: t.dictionary_of_coordinates_at_residues(1)
{2: [(0, 2)], 3: [(0, 3), (1, 0)]}
sage: t = WeakTableau([], 3)
sage: t.dictionary_of_coordinates_at_residues(1)
{}
Return the -charge of self.
INPUT:
OUTPUT:
For the definition of -charge and the various algorithms to compute it see
Section 3.3 of [LLMSSZ2013].
See also
EXAMPLES:
sage: t = WeakTableau([[1, 1, 2, 2, 3], [2, 3], [3]], 3)
sage: t.k_charge()
2
sage: t = WeakTableau([[1, 3, 4, 5, 6], [2, 6], [4]], 3)
sage: t.k_charge()
8
sage: t = WeakTableau([[1, 1, 2, 3, 4, 4, 5, 5, 6], [2, 3, 5, 5, 6], [3, 4, 7], [5, 6], [6], [7]], 4)
sage: t.k_charge()
12
TESTS:
sage: T = WeakTableaux(4, [13,9,5,3,2,1,1], [4,3,3,2,2,1,1,1])
sage: T.cardinality()
6
sage: all(t.k_charge_I() == t.k_charge_J() for t in T)
True
Return the -charge of self using the
-algorithm.
For the definition of -charge and the
-algorithm see Section 3.3 of [LLMSSZ2013].
OUTPUT:
See also
EXAMPLES:
sage: t = WeakTableau([[1, 1, 2, 2, 3], [2, 3], [3]], 3)
sage: t.k_charge_I()
2
sage: t = WeakTableau([[1, 3, 4, 5, 6], [2, 6], [4]], 3)
sage: t.k_charge_I()
8
sage: t = WeakTableau([[1, 1, 2, 3, 4, 4, 5, 5, 6], [2, 3, 5, 5, 6], [3, 4, 7], [5, 6], [6], [7]], 4)
sage: t.k_charge_I()
12
TESTS:
sage: t = WeakTableau([[None, None, 1, 1, 4], [1, 4], [3]], 3)
sage: t.k_charge_I()
Traceback (most recent call last):
...
ValueError: k-charge is not defined for skew weak tableaux
Return the -charge of self using the
-algorithm.
For the definition of -charge and the
-algorithm see Section 3.3 of [LLMSSZ2013].
OUTPUT:
See also
EXAMPLES:
sage: t = WeakTableau([[1, 1, 2, 2, 3], [2, 3], [3]], 3)
sage: t.k_charge_J()
2
sage: t = WeakTableau([[1, 3, 4, 5, 6], [2, 6], [4]], 3)
sage: t.k_charge_J()
8
sage: t = WeakTableau([[1, 1, 2, 3, 4, 4, 5, 5, 6], [2, 3, 5, 5, 6], [3, 4, 7], [5, 6], [6], [7]], 4)
sage: t.k_charge_J()
12
TESTS:
sage: t = WeakTableau([[None, None, 1, 1, 4], [1, 4], [3]], 3)
sage: t.k_charge_I()
Traceback (most recent call last):
...
ValueError: k-charge is not defined for skew weak tableaux
sage: t = WeakTableau([[1, 1, 2, 3], [2, 4, 4], [3, 6], [5]], 4, representation='bounded')
sage: t.k_charge() == t.k_charge(algorithm = 'J')
True
Return a list of lists of the coordinates of the standard cells of self.
INPUT:
OUTPUT:
Warning
This method currently only works for straight weak tableaux with partition weight.
EXAMPLES:
sage: t = WeakTableau([[1, 1, 2, 2, 3], [2, 3], [3]], 3)
sage: t.list_of_standard_cells()
[[(0, 1), (1, 0), (2, 0)], [(0, 0), (0, 2), (1, 1)]]
sage: t = WeakTableau([[1, 1, 1, 2], [2, 2, 3]], 5)
sage: t.list_of_standard_cells()
[[(0, 2), (1, 1), (1, 2)], [(0, 1), (1, 0)], [(0, 0), (0, 3)]]
sage: t = WeakTableau([[1, 1, 2, 3, 4, 4, 5, 5, 6], [2, 3, 5, 5, 6], [3, 4, 7], [5, 6], [6], [7]], 4)
sage: t.list_of_standard_cells()
[[(0, 1), (1, 0), (2, 0), (0, 5), (3, 0), (4, 0), (5, 0)], [(0, 0), (0, 2), (1, 1), (2, 1), (1, 2), (3, 1)]]
TESTS:
sage: t = WeakTableau([],3)
sage: t.list_of_standard_cells()
[]
sage: t = WeakTableau([[None, None, 2, 3, 4], [1, 4], [2]], 3)
sage: t.list_of_standard_cells()
Traceback (most recent call last):
...
ValueError: This method only works for straight tableaux!
sage: t = WeakTableau([[1,2],[2]], 3)
sage: t.list_of_standard_cells()
Traceback (most recent call last):
...
ValueError: This method only works for weak tableaux with partition weight!
Return a list of residues of cells of weak -tableau self labeled by v.
INPUT:
OUTPUT:
EXAMPLES:
sage: t = WeakTableau([[1, 1, 2, 2, 3], [2, 3], [3]],3)
sage: t.residues_of_entries(1)
[0, 1]
sage: t = WeakTableau([[None, None, 1, 1, 4], [1, 4], [3]], 3)
sage: t.residues_of_entries(1)
[2, 3]
Return the shape of self as a -bounded partition.
When the tableau is straight, the outer shape is returned as a -bounded
partition. When the tableau is skew, the tuple of the outer and inner shape is
returned as
-bounded partitions.
EXAMPLES:
sage: t = WeakTableau([[1, 1, 2, 2, 3], [2, 3], [3]],3)
sage: t.shape_bounded()
[3, 2, 1]
sage: t = WeakTableau([[None, None, 2, 3, 4], [1, 4], [2]], 3)
sage: t.shape_bounded()
([3, 2, 1], [2])
Return the shape of self as a -core.
When the tableau is straight, the outer shape is returned as a core. When the tableau is skew, the tuple of the outer and inner shape is returned as cores.
EXAMPLES:
sage: t = WeakTableau([[1, 1, 2, 2, 3], [2, 3], [3]],3)
sage: t.shape_core()
[5, 2, 1]
sage: t = WeakTableau([[None, None, 2, 3, 4], [1, 4], [2]], 3)
sage: t.shape_core()
([5, 2, 1], [2])
Return the bounded representation of the weak -tableau self.
Each restricted sutableaux of the output is a -bounded partition.
EXAMPLES:
sage: t = WeakTableau([[1, 1, 2, 2, 3], [2, 3], [3]], 3)
sage: c = t.to_bounded_tableau(); c
[[1, 1, 2], [2, 3], [3]]
sage: type(c)
<class 'sage.combinat.k_tableau.WeakTableaux_bounded_with_category.element_class'>
sage: t = WeakTableau([[None, None, 2, 3, 4], [1, 4], [2]], 3)
sage: t.to_bounded_tableau()
[[None, None, 3], [1, 4], [2]]
sage: t.to_bounded_tableau().to_core_tableau() == t
True
Return the factorized permutation representation of the weak -tableau self.
EXAMPLES:
sage: t = WeakTableau([[1, 1, 2, 2, 3], [2, 3], [3]], 3)
sage: c = t.to_factorized_permutation_tableau(); c
[s2*s0, s3*s2, s1*s0]
sage: type(c)
<class 'sage.combinat.k_tableau.WeakTableaux_factorized_permutation_with_category.element_class'>
sage: c.to_core_tableau() == t
True
sage: t = WeakTableau([[None, None, 2, 3, 4], [1, 4], [2]], 3)
sage: c = t.to_factorized_permutation_tableau(); c
[s0, s3, s2, s3]
sage: c._inner_shape
[2]
sage: c.to_core_tableau() == t
True
TESTS:
sage: t = WeakTableau([], 4)
sage: c = t.to_factorized_permutation_tableau(); c
[1]
sage: c._inner_shape
[]
sage: c.to_core_tableau() == t
True
Bases: sage.combinat.k_tableau.WeakTableau_abstract
A weak (skew) -tableau represented in terms of factorizations of affine
permutations into cyclically decreasing elements.
Check that self is a valid weak -tableau.
EXAMPLES:
sage: t = WeakTableau([[2],[0,3],[2,1,0]], 3, representation = 'factorized_permutation')
sage: t.check()
TESTS:
sage: t = WeakTableau([[2,0],[3,2]], 3, representation = 'factorized_permutation')
Traceback (most recent call last):
...
ValueError: Error! this only works on type 'A' affine Grassmannian elements
sage: T = WeakTableaux(3, [4,1], [2,1], representation = 'factorized_permutation')
sage: t = T([[2],[1],[0]])
Traceback (most recent call last):
...
ValueError: The weight of the parent does not agree with the weight of the tableau!
Construct weak factorized affine permutation tableau from a -core tableau.
EXAMPLES:
sage: from sage.combinat.k_tableau import WeakTableau_factorized_permutation
sage: WeakTableau_factorized_permutation.from_core_tableau([[1, 1, 2, 2, 3], [2, 3], [3]],3)
[s2*s0, s3*s2, s1*s0]
sage: WeakTableau_factorized_permutation.from_core_tableau([[1, 1, 2, 3, 4, 4, 5, 5, 6], [2, 3, 5, 5, 6], [3, 4, 7], [5, 6], [6], [7]], 4)
[s0, s3*s1, s2*s1, s0*s4, s3*s0, s4*s2, s1*s0]
sage: WeakTableau_factorized_permutation.from_core_tableau([[None, 1, 1, 2, 2], [None, 2], [1]], 3)
[s0*s3, s2*s1]
Return the -charge of self.
OUTPUT:
EXAMPLES:
sage: t = WeakTableau([[2,0],[3,2],[1,0]], 3, representation = 'factorized_permutation')
sage: t.k_charge()
2
sage: t = WeakTableau([[0],[3],[2],[1],[3],[0]], 3, representation = 'factorized_permutation')
sage: t.k_charge()
8
sage: t = WeakTableau([[0],[3,1],[2,1],[0,4],[3,0],[4,2],[1,0]], 4, representation = 'factorized_permutation')
sage: t.k_charge()
12
Return the shape of self as a -bounded partition.
When the tableau is straight, the outer shape is returned as a -bounded
partition. When the tableau is skew, the tuple of the outer and inner shape is
returned as
-bounded partitions.
EXAMPLES:
sage: t = WeakTableau([[2],[0,3],[2,1,0]], 3, representation = 'factorized_permutation')
sage: t.shape_bounded()
[3, 2, 1]
sage: t = WeakTableau([[2,0],[3,2]], 3, inner_shape = [2], representation = 'factorized_permutation')
sage: t.shape_bounded()
([3, 2, 1], [2])
Return the shape of self as a -core.
When the tableau is straight, the outer shape is returned as a core. When the tableau is skew, the tuple of the outer and inner shape is returned as cores.
EXAMPLES:
sage: t = WeakTableau([[2],[0,3],[2,1,0]], 3, representation = 'factorized_permutation')
sage: t.shape_core()
[5, 2, 1]
sage: t = WeakTableau([[2,0],[3,2]], 3, inner_shape = [2], representation = 'factorized_permutation')
sage: t.shape()
([5, 2, 1], [2])
Straightens input.
INPUT:
EXAMPLES:
sage: from sage.combinat.k_tableau import WeakTableau_factorized_permutation
sage: WeakTableau_factorized_permutation.straighten_input([[2,0],[3,2],[1,0]], 3)
(s2*s0, s3*s2, s1*s0)
sage: W = WeylGroup(['A',4,1])
sage: WeakTableau_factorized_permutation.straighten_input([W.an_element(),W.an_element()], 4)
(s0*s1*s2*s3*s4, s0*s1*s2*s3*s4)
TESTS:
sage: WeakTableau_factorized_permutation.straighten_input([W.an_element(),W.an_element()], 3)
Traceback (most recent call last):
...
ValueError: a matrix from Full MatrixSpace of 5 by 5 dense matrices over Rational Field cannot be converted to a matrix in Full MatrixSpace of 4 by 4 dense matrices over Rational Field!
Return the weak -tableau self where the shape of each restricted tableau is a
-core.
EXAMPLES:
sage: t = WeakTableau([[0], [3,1], [2,1], [0,4], [3,0], [4,2], [1,0]], 4, representation = 'factorized_permutation'); t
[s0, s3*s1, s2*s1, s0*s4, s3*s0, s4*s2, s1*s0]
sage: c = t.to_core_tableau(); c
[[1, 1, 2, 3, 4, 4, 5, 5, 6], [2, 3, 5, 5, 6], [3, 4, 7], [5, 6], [6], [7]]
sage: type(c)
<class 'sage.combinat.k_tableau.WeakTableaux_core_with_category.element_class'>
sage: t = WeakTableau([[]], 4, representation = 'factorized_permutation'); t
[1]
sage: t.to_core_tableau()
[]
sage: from sage.combinat.k_tableau import WeakTableau_factorized_permutation
sage: t = WeakTableau([[2,0],[3,2],[1,0]], 3, representation = 'factorized_permutation')
sage: WeakTableau_factorized_permutation.from_core_tableau(t.to_core_tableau(), 3)
[s2*s0, s3*s2, s1*s0]
sage: t == WeakTableau_factorized_permutation.from_core_tableau(t.to_core_tableau(), 3)
True
sage: t = WeakTableau([[2,0],[3,2]], 3, inner_shape = [2], representation = 'factorized_permutation')
sage: t.to_core_tableau()
[[None, None, 1, 1, 2], [1, 2], [2]]
sage: t == WeakTableau_factorized_permutation.from_core_tableau(t.to_core_tableau(), 3)
True
This is the dispatcher method for the parent class of weak -tableaux.
INPUT:
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]]
Bases: sage.structure.unique_representation.UniqueRepresentation, sage.structure.parent.Parent
Abstract class for the various parent classes of WeakTableaux.
Return the analogue of self in the specified representation.
INPUT:
EXAMPLES:
sage: T = WeakTableaux(3, [5,2,1], [1,1,1,1,1,1])
sage: T._representation
'core'
sage: T.representation('bounded')
Bounded weak 3-Tableaux of (skew) 3-bounded shape [3, 2, 1] and weight (1, 1, 1, 1, 1, 1)
sage: T.representation('factorized_permutation')
Factorized permutation (skew) weak 3-Tableaux of shape [5, 2, 1] and weight (1, 1, 1, 1, 1, 1)
sage: T = WeakTableaux(3, [3,2,1], [1,1,1,1,1,1], representation = 'bounded')
sage: T._representation
'bounded'
sage: T.representation('core')
Core weak 3-Tableaux of (skew) core shape [5, 2, 1] and weight (1, 1, 1, 1, 1, 1)
sage: T.representation('bounded')
Bounded weak 3-Tableaux of (skew) 3-bounded shape [3, 2, 1] and weight (1, 1, 1, 1, 1, 1)
sage: T.representation('bounded') == T
True
sage: T.representation('factorized_permutation')
Factorized permutation (skew) weak 3-Tableaux of shape [5, 2, 1] and weight (1, 1, 1, 1, 1, 1)
sage: T.representation('factorized_permutation') == T
False
sage: T = WeakTableaux(3, [5,2,1], [1,1,1,1,1,1], representation = 'factorized_permutation')
sage: T._representation
'factorized_permutation'
sage: T.representation('core')
Core weak 3-Tableaux of (skew) core shape [5, 2, 1] and weight (1, 1, 1, 1, 1, 1)
sage: T.representation('bounded')
Bounded weak 3-Tableaux of (skew) 3-bounded shape [3, 2, 1] and weight (1, 1, 1, 1, 1, 1)
sage: T.representation('factorized_permutation')
Factorized permutation (skew) weak 3-Tableaux of shape [5, 2, 1] and weight (1, 1, 1, 1, 1, 1)
Return the shape of the tableaux of self.
When self is the class of straight tableaux, the outer shape is returned. When self is the class of skew tableaux, the tuple of the outer and inner shape is returned.
Note that in the ‘core’ and ‘factorized_permutation’ representation, the shapes
are -cores. In the ‘bounded’ representation, the shapes are
-bounded
partitions.
If the user wants to access the skew shape (even if the inner shape is empty), please use self._shape.
EXAMPLES:
sage: T = WeakTableaux(3, [5,2,2], [2,2,2,1])
sage: T.shape()
[5, 2, 2]
sage: T._shape
([5, 2, 2], [])
sage: T = WeakTableaux(3, [[5,2,2], [1]], [2,1,2,1])
sage: T.shape()
([5, 2, 2], [1])
sage: T = WeakTableaux(3, [3,2,2], [2,2,2,1], representation = 'bounded')
sage: T.shape()
[3, 2, 2]
sage: T._shape
([3, 2, 2], [])
sage: T = WeakTableaux(3, [[3,2,2], [1]], [2,1,2,1], representation = 'bounded')
sage: T.shape()
([3, 2, 2], [1])
sage: T = WeakTableaux(3, [4,1], [2,2], representation = 'factorized_permutation')
sage: T.shape()
[4, 1]
sage: T._shape
([4, 1], [])
sage: T = WeakTableaux(4, [[6,2,1], [2]], [2,1,1,1], representation = 'factorized_permutation')
sage: T.shape()
([6, 2, 1], [2])
Return the size of the shape.
In the bounded representation, the size of the shape is the number of boxes in the outer shape minus the number of boxes in the inner shape. For the core and factorized permutation representation, the size is the length of the outer shape minus the length of the inner shape.
EXAMPLES:
sage: T = WeakTableaux(3, [5,2,1], [1,1,1,1,1,1])
sage: T.size()
6
sage: T = WeakTableaux(3, [3,2,1], [1,1,1,1,1,1], representation = 'bounded')
sage: T.size()
6
sage: T = WeakTableaux(4, [[6,2,1], [2]], [2,1,1,1], 'factorized_permutation')
sage: T.size()
5
Bases: sage.combinat.k_tableau.WeakTableaux_abstract
The class of (skew) weak -tableaux in the bounded representation of shape shape
(as
-bounded partition or tuple of
-bounded partitions in the skew case) and
weight weight.
INPUT:
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]]]
alias of WeakTableau_bounded
Bases: sage.combinat.k_tableau.WeakTableaux_abstract
The class of (skew) weak -tableaux in the core representation of shape shape
(as
-core) and weight weight.
INPUT:
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]]]
alias of WeakTableau_core
Return the shortest counterclockwise distance between cr and r modulo .
INPUT:
OUTPUT:
EXAMPLES:
sage: T = WeakTableaux(10, [], [])
sage: T.circular_distance(8, 6)
2
sage: T.circular_distance(8, 8)
0
sage: T.circular_distance(8, 9)
10
Return the number of diagonals strictly between cells c and ha of the same residue as c.
INPUT:
OUTPUT:
EXAMPLES:
sage: T = WeakTableaux(4, [5,2,2], [2,2,2,1])
sage: T.diag((1,2),(4,0))
0
Bases: sage.combinat.k_tableau.WeakTableaux_abstract
The class of (skew) weak -tableaux in the factorized permutation representation of shape shape (as
-core
or tuple of
-cores in the skew case) and weight weight.
INPUT:
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]]
alias of WeakTableau_factorized_permutation
Return the intermediate shapes of tableau t.
A (skew) tableau with letters can be viewed as a sequence of
shapes, where the
-th shape is given by the shape of the subtableau on letters
. The output is the list of these shapes.
OUTPUT:
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]]
Return the absolute value of v or None.
INPUT:
OUTPUT:
EXAMPLES:
sage: from sage.combinat.k_tableau import nabs
sage: nabs(None)
sage: nabs(-3)
3
sage: nabs(None)