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
- class sage.combinat.k_tableau.StrongTableau(parent, T)[source]¶
Bases:
ClonableListA (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]]
>>> from sage.all import * >>> StrongTableau( [[-Integer(1), -Integer(2), -Integer(3)], [Integer(3)]], Integer(2), [Integer(3)] ) [[-1, -1, -1], [1]] >>> StrongTableau([[-Integer(1),-Integer(2),-Integer(4),-Integer(7)],[-Integer(3),Integer(6),-Integer(6),Integer(8)],[Integer(4),Integer(7)],[-Integer(5),-Integer(8)]], Integer(3), [Integer(2),Integer(2),Integer(3),Integer(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)
>>> from sage.all import * >>> T = StrongTableau([[-Integer(1),-Integer(1),-Integer(1)],[Integer(1)]], Integer(2)); T [[-1, -1, -1], [1]] >>> T.to_standard_list() [[-1, -2, -3], [3]] >>> T.weight() (3,) >>> T = StrongTableau([[-Integer(1), -Integer(1), -Integer(2), -Integer(3)], [-Integer(2), Integer(3), -Integer(3), Integer(4)], [Integer(2), Integer(3)], [-Integer(3), -Integer(4)]], Integer(3)); T [[-1, -1, -2, -3], [-2, 3, -3, 4], [2, 3], [-3, -4]] >>> T.to_standard_list() [[-1, -2, -4, -7], [-3, 6, -6, 8], [4, 7], [-5, -8]] >>> T.weight() (2, 2, 3, 1)
- cell_of_highest_head(v)[source]¶
Return the cell of the highest head of label
vin the standard part ofself.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
vthen the cell returned is \((0, r)\) where \(r\) is the length of the first row.This cell is calculated by iterating through the diagonals of the tableau.
INPUT:
v– integer indicating the label in the standard tableau
OUTPUT: a pair of integers indicating the coordinates of the head of the highest ribbon with label
vEXAMPLES:
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)]
>>> from sage.all import * >>> T = StrongTableau([[-Integer(1),Integer(2),-Integer(3)],[-Integer(2),Integer(3)],[Integer(3)]], Integer(1)) >>> [T.cell_of_highest_head(v) for v in range(Integer(1),Integer(5))] [(0, 0), (1, 0), (2, 0), (0, 3)] >>> T = StrongTableau([[None,None,-Integer(3),Integer(4)],[Integer(3),-Integer(4)]],Integer(2)) >>> [T.cell_of_highest_head(v) for v in range(Integer(1),Integer(5))] [(1, 0), (1, 1), (0, 4), (0, 4)]
- cell_of_marked_head(v)[source]¶
Return location of marked head labeled by
vin the standard part ofself.Return the coordinates of the
v-th marked cell in the strong standard tableauself. If there is no mark, then the value returned is \((0, r)\) where \(r\) is the length of the first row.INPUT:
v– integer representing the label in the standard tableau
OUTPUT: a pair of the coordinates of the marked cell with entry
vEXAMPLES:
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)]
>>> from sage.all import * >>> T = StrongTableau([[-Integer(1), -Integer(3), Integer(4), -Integer(5)], [-Integer(2)], [-Integer(4)]], Integer(3)) >>> [ T.cell_of_marked_head(i) for i in range(Integer(1),Integer(7))] [(0, 0), (1, 0), (0, 1), (2, 0), (0, 3), (0, 4)] >>> T = StrongTableau([[None, None, -Integer(1), -Integer(2)], [None, None], [-Integer(1), -Integer(2)], [Integer(1), Integer(2)], [-Integer(3)], [Integer(3)], [Integer(3)], [Integer(3)]], Integer(4)) >>> [ T.cell_of_marked_head(i) for i in range(Integer(1),Integer(7))] [(2, 0), (0, 2), (2, 1), (0, 3), (4, 0), (0, 4)]
- cells_head_dictionary()[source]¶
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.
OUTPUT:
a dictionary with keys the entries in the tableau and values are the coordinates of the heads with those entries
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)]}
>>> from sage.all import * >>> T = StrongTableau([[-Integer(1),-Integer(2),-Integer(4),Integer(7)],[-Integer(3),Integer(6),-Integer(6),Integer(8)],[Integer(4),-Integer(7)],[-Integer(5),-Integer(8)]], Integer(3)) >>> 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)]} >>> T = StrongTableau([[None, Integer(4), -Integer(4), -Integer(6), -Integer(7), Integer(8), Integer(8), -Integer(8)], [None, -Integer(5), Integer(8), Integer(8), Integer(8)], [-Integer(3), Integer(6)]],Integer(3)) >>> 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)]} >>> StrongTableau([[None, None], [None, -Integer(1)]], Integer(4)).cells_head_dictionary() {1: [(1, 1)]}
- cells_of_heads(v)[source]¶
Return a list of cells of the heads with label
vin the standard part ofself.A list of cells which are heads of the ribbons with label
vin the standard part of the tableauself. If there is no cell labelled byvthen return the empty list.INPUT:
v– integer label
OUTPUT: a list of pairs of integers of the coordinates of the heads of the ribbons with label
vEXAMPLES:
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) []
>>> from sage.all import * >>> T = StrongTableau([[None, None, -Integer(1), -Integer(2)], [None, None], [-Integer(1), -Integer(2)], [Integer(1), Integer(2)], [-Integer(3)], [Integer(3)], [Integer(3)], [Integer(3)]], Integer(4)) >>> T.cells_of_heads(Integer(1)) [(2, 0)] >>> T.cells_of_heads(Integer(2)) [(3, 0), (0, 2)] >>> T.cells_of_heads(Integer(3)) [(2, 1)] >>> T.cells_of_heads(Integer(4)) [(3, 1), (0, 3)] >>> T.cells_of_heads(Integer(5)) [(4, 0)] >>> T.cells_of_heads(Integer(6)) []
- cells_of_marked_ribbon(v)[source]¶
Return a list of all cells the marked ribbon labeled by
vin the standard part ofself.Return the list of coordinates of the cells which are in the marked ribbon with label
vin 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:
v– the entry of the standard tableau
OUTPUT:
a list of pairs representing the coordinates of the cells of the marked ribbon
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)]
>>> from sage.all import * >>> T = StrongTableau([[-Integer(1), -Integer(1), -Integer(2), -Integer(2), Integer(3)], [Integer(2), -Integer(3)], [-Integer(3)]],Integer(3)) >>> T.to_standard_list() [[-1, -2, -3, -4, 6], [4, -6], [-5]] >>> T.cells_of_marked_ribbon(Integer(1)) [(0, 0)] >>> T.cells_of_marked_ribbon(Integer(4)) [(0, 3)] >>> T = StrongTableau([[-Integer(1),-Integer(2),-Integer(4),-Integer(7)],[-Integer(3),Integer(6),-Integer(6),Integer(8)],[Integer(4),Integer(7)],[-Integer(5),-Integer(8)]], Integer(3)) >>> T.cells_of_marked_ribbon(Integer(6)) [(1, 2), (1, 1)] >>> T.cells_of_marked_ribbon(Integer(9)) [] >>> T = StrongTableau([[None, None, -Integer(1), -Integer(1), Integer(3)], [Integer(1), -Integer(3)], [-Integer(3)]],Integer(3)) >>> T.to_standard_list() [[None, None, -1, -2, 4], [2, -4], [-3]] >>> T.cells_of_marked_ribbon(Integer(1)) [(0, 2)]
- check()[source]¶
Check that
selfis a valid strong \(k\)-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
selfis 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()
>>> from sage.all import * >>> T = StrongTableau([[-Integer(1), -Integer(1), -Integer(2)], [Integer(2)]], Integer(2)) >>> T.check() >>> T = StrongTableau([[None, None, Integer(2), -Integer(4), -Integer(4)], [-Integer(1), Integer(4)], [-Integer(2)]], Integer(3)) >>> T.check()
- content_of_highest_head(v)[source]¶
Return the diagonal of the highest head of the cells labeled
vin the standard part ofself.Return the content of the cell of the head in the highest row of all ribbons labeled by
vof the underlying standard tableau. If there is no cell with entryvthen the value returned is the length of the first row.INPUT:
v– integer representing the label in the standard tableau
OUTPUT: an integer representing the content of the head of the highest ribbon with label
vEXAMPLES:
sage: [StrongTableau([[-1,2,-3],[-2,3],[3]], 1).content_of_highest_head(v) for v in range(1,5)] [0, -1, -2, 3]
>>> from sage.all import * >>> [StrongTableau([[-Integer(1),Integer(2),-Integer(3)],[-Integer(2),Integer(3)],[Integer(3)]], Integer(1)).content_of_highest_head(v) for v in range(Integer(1),Integer(5))] [0, -1, -2, 3]
- content_of_marked_head(v)[source]¶
Return the diagonal of the marked label
vin the standard part ofself.Return the content (the \(j-i\) coordinate of the cell) of the
v-th marked cell in the strong standard tableauself. If there is no mark, then the value returned is the size of first row.INPUT:
v– integer representing the label in the standard tableau
OUTPUT: integer representing the residue of the location of the mark
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]
>>> from sage.all import * >>> [ StrongTableau([[-Integer(1), -Integer(3), Integer(4), -Integer(5)], [-Integer(2)], [-Integer(4)]], Integer(3)).content_of_marked_head(i) for i in range(Integer(1),Integer(7))] [0, -1, 1, -2, 3, 4] >>> T = StrongTableau([[None, None, -Integer(1), -Integer(2)], [None, None], [-Integer(1), -Integer(2)], [Integer(1), Integer(2)], [-Integer(3)], [Integer(3)], [Integer(3)], [Integer(3)]], Integer(4)) >>> [ T.content_of_marked_head(i) for i in range(Integer(1),Integer(7))] [-2, 2, -1, 3, -4, 4]
- contents_of_heads(v)[source]¶
A list of contents of the cells which are heads of the ribbons with label
v.If there is no cell labelled by
vthen return the empty list.INPUT:
v– integer label
OUTPUT: list of integers of the content of the heads of the ribbons with label
vEXAMPLES:
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) []
>>> from sage.all import * >>> T = StrongTableau([[None, None, -Integer(1), -Integer(2)], [None, None], [-Integer(1), -Integer(2)], [Integer(1), Integer(2)], [-Integer(3)], [Integer(3)], [Integer(3)], [Integer(3)]], Integer(4)) >>> T.contents_of_heads(Integer(1)) [-2] >>> T.contents_of_heads(Integer(2)) [-3, 2] >>> T.contents_of_heads(Integer(3)) [-1] >>> T.contents_of_heads(Integer(4)) [-2, 3] >>> T.contents_of_heads(Integer(5)) [-4] >>> T.contents_of_heads(Integer(6)) []
- entries_by_content(diag)[source]¶
Return the entries on the diagonal of
self.Return the entries in the tableau that are in the cells \((i,j)\) with \(j-i\) equal to
diag(that is, with content equal todiag).INPUT:
diag– integer indicating the diagonal
OUTPUT: list (perhaps empty) of labels on the diagonal
diagEXAMPLES:
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]
>>> from sage.all import * >>> T = StrongTableau([[None, None, -Integer(1), -Integer(2)], [None, None], [-Integer(1), -Integer(2)], [Integer(1), Integer(2)], [-Integer(3)], [Integer(3)], [Integer(3)], [Integer(3)]], Integer(4)) >>> T.entries_by_content(Integer(0)) [] >>> T.entries_by_content(Integer(1)) [] >>> T.entries_by_content(Integer(2)) [-1] >>> T.entries_by_content(-Integer(2)) [-1, 2]
- entries_by_content_standard(diag)[source]¶
Return the entries on the diagonal of the standard part of
self.Return the entries in the tableau that are in the cells \((i,j)\) with \(j-i\) equal to
diag(that is, with content equal todiag) in the standard tableau.INPUT:
diag– integer indicating the diagonal
OUTPUT: list (perhaps empty) of labels on the diagonal
diagEXAMPLES:
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]
>>> from sage.all import * >>> T = StrongTableau([[None, None, -Integer(1), -Integer(2)], [None, None], [-Integer(1), -Integer(2)], [Integer(1), Integer(2)], [-Integer(3)], [Integer(3)], [Integer(3)], [Integer(3)]], Integer(4)) >>> T.entries_by_content_standard(Integer(0)) [] >>> T.entries_by_content_standard(Integer(1)) [] >>> T.entries_by_content_standard(Integer(2)) [-2] >>> T.entries_by_content_standard(-Integer(2)) [-1, 4]
- follows_tableau()[source]¶
Return a list of strong marked tableaux with length one longer than
self.Return list of all strong tableaux obtained from
selfby extending to a core which follows the shape ofselfin the strong order.OUTPUT: list of strong tableaux which follow
selfin strong orderEXAMPLES:
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]]]
>>> from sage.all import * >>> T = StrongTableau([[-Integer(1),-Integer(2),-Integer(4),-Integer(7)],[-Integer(3),Integer(6),-Integer(6),Integer(8)],[Integer(4),Integer(7)],[-Integer(5),-Integer(8)]], Integer(3), [Integer(2),Integer(2),Integer(3),Integer(1)]) >>> 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]]] >>> StrongTableau([[-Integer(1),-Integer(2)],[-Integer(3),-Integer(4)]],Integer(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]]]
- height_of_ribbon(v)[source]¶
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 ofself.INPUT:
v– the label of the standard marked tableau
OUTPUT: nonnegative integer representing the number of rows occupied by the ribbon which is marked
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
>>> from sage.all import * >>> T = StrongTableau([[-Integer(1), -Integer(1), -Integer(2), -Integer(2), Integer(3)], [Integer(2), -Integer(3)], [-Integer(3)]],Integer(3)) >>> T.to_standard_list() [[-1, -2, -3, -4, 6], [4, -6], [-5]] >>> T.height_of_ribbon(Integer(1)) 1 >>> T.height_of_ribbon(Integer(4)) 1 >>> T = StrongTableau([[None,None,Integer(1),-Integer(2)],[None,-Integer(3),Integer(4),-Integer(5)],[-Integer(1),Integer(3)],[-Integer(4),Integer(5)]], Integer(3)) >>> T.height_of_ribbon(Integer(3)) 2 >>> T.height_of_ribbon(Integer(6)) 0
- inner_shape()[source]¶
Return the inner shape of
self.If
selfis a strong skew tableau, then this method returns the inner shape (the shape of the cells labelled withNone). Ifselfis not skew, then the inner shape is empty.OUTPUT:
a \((k+1)\)-core
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() []
>>> from sage.all import * >>> StrongTableau([[None, None, -Integer(1), -Integer(2)], [None, None], [-Integer(1), -Integer(2)], [Integer(1), Integer(2)], [-Integer(3)], [Integer(3)], [Integer(3)], [Integer(3)]], Integer(4)).inner_shape() [2, 2] >>> StrongTableau([[-Integer(1),-Integer(2),-Integer(4),-Integer(7)],[-Integer(3),Integer(6),-Integer(6),Integer(8)],[Integer(4),Integer(7)],[-Integer(5),-Integer(8)]], Integer(3), [Integer(2),Integer(2),Integer(3),Integer(1)]).inner_shape() []
- intermediate_shapes()[source]¶
Return the intermediate shapes of
self.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. 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: list of lists of integers representing \(k+1\)-cores
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]]
>>> from sage.all import * >>> T = StrongTableau([[-Integer(1),-Integer(2),-Integer(4),-Integer(7)],[-Integer(3),Integer(6),-Integer(6),Integer(8)],[Integer(4),Integer(7)],[-Integer(5),-Integer(8)]], Integer(3), [Integer(2),Integer(2),Integer(3),Integer(1)]) >>> T.intermediate_shapes() [[], [2], [3, 1, 1], [4, 3, 2, 1], [4, 4, 2, 2]] >>> T = StrongTableau([[None, None, -Integer(1), -Integer(2)], [None, None], [-Integer(1), -Integer(2)], [Integer(1), Integer(2)], [-Integer(3)], [Integer(3)], [Integer(3)], [Integer(3)]], Integer(4)) >>> T.intermediate_shapes() [[2, 2], [3, 2, 1, 1], [4, 2, 2, 2], [4, 2, 2, 2, 1, 1, 1, 1]]
- is_column_strict_with_weight(mu)[source]¶
Test if
selfis a column strict tableau with respect to the weightmu.INPUT:
mu– a vector of weights
OUTPUT: boolean;
Truemeans the underlying column strict strong marked tableau is validEXAMPLES:
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
>>> from sage.all import * >>> StrongTableau([[-Integer(1), -Integer(2), -Integer(3)], [Integer(3)]], Integer(2)).is_column_strict_with_weight([Integer(3)]) True >>> StrongTableau([[-Integer(1), -Integer(2), Integer(3)], [-Integer(3)]], Integer(2)).is_column_strict_with_weight([Integer(3)]) False
- left_action(tij)[source]¶
Action of transposition
tijonselfby adding marked ribbons.Computes the left action of the transposition
tijon the tableau. Iftijacting on the element of the affine Grassmannian raises the length by 1, then this function will add a cell to the standard tableau.INPUT:
tij– a transposition represented as a pair \((i, j)\)
OUTPUT:
selfafter it has been modified by the action of the transpositiontijEXAMPLES:
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)
>>> from sage.all import * >>> StrongTableau( [[None, -Integer(1), -Integer(2), -Integer(3)], [Integer(3)], [-Integer(4)]], Integer(3), weight=[Integer(1),Integer(1),Integer(1),Integer(1)] ).left_action([Integer(0),Integer(1)]) [[None, -1, -2, -3, 5], [3, -5], [-4]] >>> StrongTableau( [[None, -Integer(1), -Integer(2), -Integer(3)], [Integer(3)], [-Integer(4)]], Integer(3), weight=[Integer(1),Integer(1),Integer(1),Integer(1)] ).left_action([Integer(4),Integer(5)]) [[None, -1, -2, -3, -5], [3, 5], [-4]] >>> T = StrongTableau( [[None, -Integer(1), -Integer(2), -Integer(3)], [Integer(3)], [-Integer(4)]], Integer(3), weight=[Integer(1),Integer(1),Integer(1),Integer(1)] ) >>> T.left_action([-Integer(3),-Integer(2)]) [[None, -1, -2, -3], [3], [-4], [-5]] >>> T = StrongTableau( [[None, -Integer(1), -Integer(2), -Integer(3)], [Integer(3)], [-Integer(4)]], Integer(3), weight=[Integer(3),Integer(1)] ) >>> T.left_action([-Integer(3),-Integer(2)]) [[None, -1, -1, -1], [1], [-2], [-3]] >>> T [[None, -1, -1, -1], [1], [-2]] >>> T.check() >>> T.weight() (3, 1)
- number_of_connected_components(v)[source]¶
Number of connected components of ribbons with label
vin the standard part.The number of connected components is calculated by finding the number of cells with label
vin the standard part of the tableau and dividing by the number of cells in the ribbon.INPUT:
v– the label of the standard marked tableau
OUTPUT: nonnegative integer representing the number of connected components
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
>>> from sage.all import * >>> T = StrongTableau([[-Integer(1), -Integer(1), -Integer(2), -Integer(2), Integer(3)], [Integer(2), -Integer(3)], [-Integer(3)]],Integer(3)) >>> T.to_standard_list() [[-1, -2, -3, -4, 6], [4, -6], [-5]] >>> T.number_of_connected_components(Integer(1)) 1 >>> T.number_of_connected_components(Integer(4)) 2 >>> T = StrongTableau([[-Integer(1),-Integer(2),-Integer(4),-Integer(7)],[-Integer(3),Integer(6),-Integer(6),Integer(8)],[Integer(4),Integer(7)],[-Integer(5),-Integer(8)]], Integer(3)) >>> T.number_of_connected_components(Integer(6)) 1 >>> T.number_of_connected_components(Integer(9)) 0
- outer_shape()[source]¶
Return the outer shape of
self.This method returns the outer shape of
selfas viewed as aCore. The outer shape of a strong tableau is always a \((k+1)\)-core.OUTPUT:
a \((k+1)\)-core
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]
>>> from sage.all import * >>> StrongTableau([[None, None, -Integer(1), -Integer(2)], [None, None], [-Integer(1), -Integer(2)], [Integer(1), Integer(2)], [-Integer(3)], [Integer(3)], [Integer(3)], [Integer(3)]], Integer(4)).outer_shape() [4, 2, 2, 2, 1, 1, 1, 1] >>> StrongTableau([[-Integer(1),-Integer(2),-Integer(4),-Integer(7)],[-Integer(3),Integer(6),-Integer(6),Integer(8)],[Integer(4),Integer(7)],[-Integer(5),-Integer(8)]], Integer(3), [Integer(2),Integer(2),Integer(3),Integer(1)]).outer_shape() [4, 4, 2, 2]
- pp()[source]¶
Print the strong tableau
selfin 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.options(convention='French') sage: T.pp() 3 3 3 -3 1 2 -1 -2 . . . . -1 -2 sage: Tableaux.options(convention='English')
>>> from sage.all import * >>> T = StrongTableau([[-Integer(1),-Integer(2),-Integer(4),-Integer(7)],[-Integer(3),Integer(6),-Integer(6),Integer(8)],[Integer(4),Integer(7)],[-Integer(5),-Integer(8)]], Integer(3), [Integer(2),Integer(2),Integer(3),Integer(1)]) >>> T.pp() -1 -1 -2 -3 -2 3 -3 4 2 3 -3 -4 >>> T = StrongTableau([[None, None, -Integer(1), -Integer(2)], [None, None], [-Integer(1), -Integer(2)], [Integer(1), Integer(2)], [-Integer(3)], [Integer(3)], [Integer(3)], [Integer(3)]], Integer(4)) >>> T.pp() . . -1 -2 . . -1 -2 1 2 -3 3 3 3 >>> Tableaux.options(convention='French') >>> T.pp() 3 3 3 -3 1 2 -1 -2 . . . . -1 -2 >>> Tableaux.options(convention='English')
- restrict(r)[source]¶
Restrict the standard part of the tableau to the labels \(1, 2, \ldots, r\).
Return the tableau consisting of the labels of the standard part of
selfrestricted to the labels of \(1\) throughr. The result is anotherStrongTableauobject.INPUT:
r– integer
OUTPUT: a strong tableau
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
>>> from sage.all import * >>> T = StrongTableau([[None, None, -Integer(4), Integer(5), -Integer(5)], [None, None], [-Integer(1), -Integer(3)], [-Integer(2)], [Integer(2)], [Integer(2)], [Integer(3)]], Integer(4), weight=[Integer(1),Integer(1),Integer(1),Integer(1),Integer(1)]) >>> T.restrict(Integer(3)) [[None, None], [None, None], [-1, -3], [-2], [2], [2], [3]] >>> TT = T.restrict(Integer(0)) >>> TT [[None, None], [None, None]] >>> TT == StrongTableau( [[None, None], [None, None]], Integer(4) ) True >>> T.restrict(Integer(5)) == T True
- ribbons_above_marked(v)[source]¶
Number of ribbons of label
vhigher than the marked ribbon in the standard part.Return the number of copies of the ribbon with label
vin the standard part ofselfwhich are in a higher row than the marked ribbon. Note that the result is independent of the weight of the tableau.INPUT:
v– the entry of the standard tableau
OUTPUT:
an integer representing the number of copies of the ribbon above the marked ribbon
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
>>> from sage.all import * >>> T = StrongTableau([[-Integer(1),-Integer(2),-Integer(4),-Integer(7)],[-Integer(3),Integer(6),-Integer(6),Integer(8)],[Integer(4),Integer(7)],[-Integer(5),-Integer(8)]], Integer(3)) >>> T.ribbons_above_marked(Integer(4)) 1 >>> T.ribbons_above_marked(Integer(6)) 0 >>> T.ribbons_above_marked(Integer(9)) 0 >>> StrongTableau([[-Integer(1),-Integer(2),-Integer(3),-Integer(4)],[Integer(2),Integer(3),Integer(4)],[Integer(3),Integer(4)],[Integer(4)]], Integer(1)).ribbons_above_marked(Integer(4)) 3
- set_weight(mu)[source]¶
Set a new weight
muforself.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:
mu– list of nonnegative integers representing the new weight
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]
>>> from sage.all import * >>> StrongTableau( [[-Integer(1), -Integer(2), -Integer(3)], [Integer(3)]], Integer(2) ).set_weight( [Integer(3)] ) [[-1, -1, -1], [1]] >>> StrongTableau( [[-Integer(1), -Integer(2), -Integer(3)], [Integer(3)]], Integer(2) ).set_weight( [Integer(0),Integer(3)] ) [[-2, -2, -2], [2]] >>> StrongTableau( [[-Integer(1), -Integer(2), Integer(3)], [-Integer(3)]], Integer(2) ).set_weight( [Integer(2), Integer(0), Integer(1)] ) [[-1, -1, 3], [-3]] >>> StrongTableau( [[-Integer(1), -Integer(2), Integer(3)], [-Integer(3)]], Integer(2) ).set_weight( [Integer(3)] ) Traceback (most recent call last): ... ValueError: [[-1, -2, 3], [-3]] is not a semistandard strong tableau with respect to the partition [3]
- shape()[source]¶
Return the shape of
self.If
selfis a skew tableau then return a pair of \(k+1\)-cores consisting of the outer and the inner shape. Ifselfis strong tableau with no inner shape then return a \(k+1\)-core.INPUT:
form– argument to indicate'inner','outer'or'skew'(default:'outer')
OUTPUT: a \(k+1\)-core or a pair of \(k+1\)-cores if form is not
'inner'or'outer'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'>
>>> from sage.all import * >>> T = StrongTableau([[None, None, -Integer(1), -Integer(2)], [None, None], [-Integer(1), -Integer(2)], [Integer(1), Integer(2)], [-Integer(3)], [Integer(3)], [Integer(3)], [Integer(3)]], Integer(4)) >>> T.shape() ([4, 2, 2, 2, 1, 1, 1, 1], [2, 2]) >>> StrongTableau([[-Integer(1), -Integer(2), Integer(3)], [-Integer(3)]], Integer(2)).shape() [3, 1] >>> type(StrongTableau([[-Integer(1), -Integer(2), Integer(3)], [-Integer(3)]], Integer(2)).shape()) <class 'sage.combinat.core.Cores_length_with_category.element_class'>
- size()[source]¶
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 \(k+1\)-core) minus the length of the inner shape.See also
OUTPUT: nonnegative integer
EXAMPLES:
sage: StrongTableau([[-1, -2, -3, 4], [-4], [-5]], 3).size() 5 sage: StrongTableau([[None, None, -1, 2], [-2], [-3]], 3).size() 3
>>> from sage.all import * >>> StrongTableau([[-Integer(1), -Integer(2), -Integer(3), Integer(4)], [-Integer(4)], [-Integer(5)]], Integer(3)).size() 5 >>> StrongTableau([[None, None, -Integer(1), Integer(2)], [-Integer(2)], [-Integer(3)]], Integer(3)).size() 3
- spin()[source]¶
Return the spin statistic of the tableau
self.The spin is an integer statistic on a strong marked tableau. It is the sum of \((h-1) r\) plus the number of connected components above the marked one where \(h\) is the height of the marked ribbon and \(r\) is the number of connected components.
The \(k\)-Schur functions with a parameter \(t\) can be defined as
\[s^{(k)}_\lambda[X; t] = \sum_T t^{spin(T)} m_{weight(T)}[X]\]where the sum is over all column strict marked strong \(k\)-tableaux of shape \(\lambda\) and partition content.
OUTPUT: integer value representing the spin
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
>>> from sage.all import * >>> StrongTableau([[-Integer(1),-Integer(2),Integer(5),Integer(6)],[-Integer(3),-Integer(4),-Integer(7),Integer(8)],[-Integer(5),-Integer(6)],[Integer(7),-Integer(8)]], Integer(3), [Integer(2),Integer(2),Integer(3),Integer(1)]).spin() 1 >>> StrongTableau([[-Integer(1),-Integer(2),-Integer(4),-Integer(7)],[-Integer(3),Integer(6),-Integer(6),Integer(8)],[Integer(4),Integer(7)],[-Integer(5),-Integer(8)]], Integer(3), [Integer(2),Integer(2),Integer(3),Integer(1)]).spin() 2 >>> StrongTableau([[None,None,-Integer(1),-Integer(3)],[-Integer(2),Integer(3),-Integer(3),Integer(4)],[Integer(2),Integer(3)],[-Integer(3),-Integer(4)]], Integer(3)).spin() 2 >>> ks3 = SymmetricFunctions(QQ['t'].fraction_field()).kschur(Integer(3)) >>> t = ks3.realization_of().t >>> m = ks3.ambient().realization_of().m() >>> myks221 = sum(sum(t**T.spin() for T in StrongTableaux(Integer(3),[Integer(3),Integer(2),Integer(1)],weight=mu))*m(mu) for mu in Partitions(Integer(5), max_part=Integer(3))) >>> myks221 == m(ks3[Integer(2),Integer(2),Integer(1)]) True >>> h = ks3.ambient().realization_of().h() >>> Core([Integer(4),Integer(4),Integer(2),Integer(2)],Integer(4)).to_bounded_partition() [2, 2, 2, 2] >>> ks3[Integer(2),Integer(2),Integer(2),Integer(2)].lift().scalar(h[Integer(3),Integer(3),Integer(2)]) == sum( t**T.spin() for T in StrongTableaux(Integer(3), [Integer(4),Integer(4),Integer(2),Integer(2)], weight=[Integer(3),Integer(3),Integer(2)]) ) True
- spin_of_ribbon(v)[source]¶
Return the spin of the ribbon with label
vin the standard part ofself.The spin of a ribbon is an integer statistic. It is the sum of \((h-1) r\) plus the number of connected components above the marked one where \(h\) is the height of the marked ribbon and \(r\) is the number of connected components.
INPUT:
v– a label of the standard part of the tableau
OUTPUT: integer value representing the spin of the ribbon with label
vEXAMPLES:
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]
>>> from sage.all import * >>> T = StrongTableau([[-Integer(1),-Integer(2),Integer(5),Integer(6)],[-Integer(3),-Integer(4),-Integer(7),Integer(8)],[-Integer(5),-Integer(6)],[Integer(7),-Integer(8)]], Integer(3)) >>> [T.spin_of_ribbon(v) for v in range(Integer(1),Integer(9))] [0, 0, 0, 0, 0, 0, 1, 0] >>> T = StrongTableau([[None,None,-Integer(1),-Integer(3)],[-Integer(2),Integer(3),-Integer(3),Integer(4)],[Integer(2),Integer(3)],[-Integer(3),-Integer(4)]], Integer(3)) >>> [T.spin_of_ribbon(v) for v in range(Integer(1),Integer(7))] [0, 1, 0, 0, 1, 0]
- to_list()[source]¶
Return the marked column strict (possibly skew) tableau as a list of lists.
OUTPUT: list of lists of integers or
NoneEXAMPLES:
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]]
>>> from sage.all import * >>> StrongTableau([[-Integer(1), -Integer(2), -Integer(3), Integer(4)], [-Integer(4)], [-Integer(5)]], Integer(3)).set_weight([Integer(2),Integer(1),Integer(1),Integer(1)]).to_list() [[-1, -1, -2, 3], [-3], [-4]] >>> StrongTableau([[None, None, -Integer(1), -Integer(2)], [None, None], [-Integer(1), -Integer(2)], [Integer(1), Integer(2)], [-Integer(3)], [Integer(3)], [Integer(3)], [Integer(3)]], Integer(4)).to_list() [[None, None, -1, -2], [None, None], [-1, -2], [1, 2], [-3], [3], [3], [3]] >>> StrongTableau([[-Integer(1), -Integer(2), -Integer(3), Integer(4)], [-Integer(4)], [-Integer(5)]], Integer(3), [Integer(3),Integer(1),Integer(1)]).to_list() [[-1, -1, -1, 2], [-2], [-3]]
- to_standard_list()[source]¶
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: list of lists of integers or
NoneEXAMPLES:
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]]
>>> from sage.all import * >>> StrongTableau([[-Integer(1), -Integer(2), -Integer(3), Integer(4)], [-Integer(4)], [-Integer(5)]], Integer(3), [Integer(3),Integer(1),Integer(1)]).to_standard_list() [[-1, -2, -3, 4], [-4], [-5]] >>> StrongTableau([[None, None, -Integer(1), -Integer(2)], [None, None], [-Integer(1), -Integer(2)], [Integer(1), Integer(2)], [-Integer(3)], [Integer(3)], [Integer(3)], [Integer(3)]], Integer(4)).to_standard_list() [[None, None, -2, -4], [None, None], [-1, -3], [2, 4], [-5], [5], [5], [5]]
- to_standard_tableau()[source]¶
Return the underlying standard strong tableau as a
StrongTableauobject.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: a strong tableau with standard weight
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]]
>>> from sage.all import * >>> T = StrongTableau([[-Integer(1), -Integer(2), -Integer(3), Integer(4)], [-Integer(4)], [-Integer(5)]], Integer(3), [Integer(3),Integer(1),Integer(1)]) >>> T.to_standard_tableau() [[-1, -2, -3, 4], [-4], [-5]] >>> T.to_standard_tableau() == T.to_standard_list() False >>> StrongTableau([[None, None, -Integer(1), -Integer(2)], [None, None], [-Integer(1), -Integer(2)], [Integer(1), Integer(2)], [-Integer(3)], [Integer(3)], [Integer(3)], [Integer(3)]], Integer(4)).to_standard_tableau() [[None, None, -2, -4], [None, None], [-1, -3], [2, 4], [-5], [5], [5], [5]]
- to_transposition_sequence()[source]¶
Return a list of transpositions corresponding to
self.Given a strong column strict tableau
selfreturns the list of transpositions which when applied to the left of an empty tableau gives the corresponding strong standard tableau.OUTPUT: list of pairs of values
[i,j]representing the transpositions \(t_{ij}\)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]]
>>> from sage.all import * >>> T = StrongTableau([[-Integer(1), -Integer(1), -Integer(1)], [Integer(1)]],Integer(2)) >>> T.to_transposition_sequence() [[2, 3], [1, 2], [0, 1]] >>> T = StrongTableau([[-Integer(1), -Integer(1), Integer(2)], [-Integer(2)]],Integer(2)) >>> T.to_transposition_sequence() [[-1, 0], [1, 2], [0, 1]] >>> T = StrongTableau([[None, -Integer(1), Integer(2), -Integer(3)], [-Integer(2), Integer(3)]],Integer(2)) >>> T.to_transposition_sequence() [[3, 4], [-1, 0], [1, 2]]
- to_unmarked_list()[source]¶
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: list of lists of integers or
NoneEXAMPLES:
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]]
>>> from sage.all import * >>> T = StrongTableau( [[-Integer(1), -Integer(2), -Integer(3), Integer(4)], [-Integer(4)], [-Integer(5)]], Integer(3), [Integer(3),Integer(1),Integer(1)]) >>> T.to_unmarked_list() [[1, 1, 1, 2], [2], [3]] >>> TT = T.set_weight([Integer(2),Integer(1),Integer(1),Integer(1)]) >>> TT.to_unmarked_list() [[1, 1, 2, 3], [3], [4]] >>> StrongTableau( [[None, None, -Integer(1), -Integer(2)], [None, None], [-Integer(1), -Integer(2)], [Integer(1), Integer(2)], [-Integer(3)], [Integer(3)], [Integer(3)], [Integer(3)]], Integer(4)).to_unmarked_list() [[None, None, 1, 2], [None, None], [1, 2], [1, 2], [3], [3], [3], [3]]
- to_unmarked_standard_list()[source]¶
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: list of lists of integers or
NoneEXAMPLES:
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]]
>>> from sage.all import * >>> StrongTableau( [[-Integer(1), -Integer(2), -Integer(3), Integer(4)], [-Integer(4)], [-Integer(5)]], Integer(3), [Integer(3),Integer(1),Integer(1)]).to_unmarked_standard_list() [[1, 2, 3, 4], [4], [5]] >>> StrongTableau( [[None, None, -Integer(1), -Integer(2)], [None, None], [-Integer(1), -Integer(2)], [Integer(1), Integer(2)], [-Integer(3)], [Integer(3)], [Integer(3)], [Integer(3)]], Integer(4)).to_unmarked_standard_list() [[None, None, 2, 4], [None, None], [1, 3], [2, 4], [5], [5], [5], [5]]
- weight()[source]¶
Return the weight of the tableau.
The weight is a list of nonnegative integers indicating the number of 1s, number of 2s, number of 3s, etc.
OUTPUT: list of nonnegative integers
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)
>>> from sage.all import * >>> T = StrongTableau([[-Integer(1), -Integer(2), -Integer(3), Integer(4)], [-Integer(4)], [-Integer(5)]], Integer(3)); T.weight() (1, 1, 1, 1, 1) >>> T.set_weight([Integer(3),Integer(1),Integer(1)]).weight() (3, 1, 1) >>> StrongTableau([[-Integer(1),-Integer(1),-Integer(2),-Integer(3)],[-Integer(2),Integer(3),-Integer(3),Integer(4)],[Integer(2),Integer(3)],[-Integer(3),-Integer(4)]], Integer(3)).weight() (2, 2, 3, 1)
- class sage.combinat.k_tableau.StrongTableaux(k, shape, weight)[source]¶
Bases:
UniqueRepresentation,Parent- Element[source]¶
alias of
StrongTableau
- classmethod add_marking(unmarkedT, marking, k, weight)[source]¶
Add markings to a partially marked strong tableau.
Given a 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– list of lists which is a partially marked strong \(k\)-tableaumarking– list of pairs of coordinates where cells are to be markedk– positive integerweight– tuple of the weight of the output tableau
OUTPUT: a
StrongTableauobjectEXAMPLES:
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]]
>>> from sage.all import * >>> StrongTableaux.add_marking([[None,Integer(1),Integer(2)],[Integer(2)]], [(Integer(0),Integer(1)), (Integer(1),Integer(0))], Integer(2), [Integer(1),Integer(1)]) [[None, -1, 2], [-2]] >>> StrongTableaux.add_marking([[None,Integer(1),Integer(2)],[Integer(2)]], [(Integer(0),Integer(1)), (Integer(1),Integer(0))], Integer(2), [Integer(2)]) Traceback (most recent call last): ... ValueError: The weight=(2,) and the markings on the standard tableau=[[None, -1, 2], [-2]] do not agree. >>> StrongTableaux.add_marking([[None,Integer(1),Integer(2)],[Integer(2)]], [(Integer(0),Integer(1)), (Integer(0),Integer(2))], Integer(2), [Integer(2)]) [[None, -1, -1], [1]]
- an_element()[source]¶
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]]
>>> from sage.all import * >>> ST = StrongTableaux(Integer(3), [Integer(3)], weight=[Integer(3)]) >>> ST.an_element() [[-1, -1, -1]]
- classmethod cells_head_dictionary(T)[source]¶
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)]}
>>> from sage.all import * >>> StrongTableaux.cells_head_dictionary([[Integer(1),Integer(2),Integer(4),Integer(7)],[Integer(3),Integer(6),Integer(6),Integer(8)],[Integer(4),Integer(7)],[Integer(5),Integer(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)]} >>> StrongTableaux.cells_head_dictionary([[None, Integer(2), Integer(2), Integer(4), Integer(5), Integer(6), Integer(6), Integer(6)], [None, Integer(3), Integer(6), Integer(6), Integer(6)], [Integer(1), Integer(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)[source]¶
Return a list of strong tableaux one longer in length than
Tlist.Return list of all standard strong tableaux obtained from
Tlistby extending to a core which follows the shape ofTlistin 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 notStrongTableauobjects (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– integer
OUTPUT: list of strong tableaux which follow
Tlistin strong orderEXAMPLES:
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]]]
>>> from sage.all import * >>> StrongTableaux.follows_tableau_unsigned_standard([[-Integer(1), -Integer(1), -Integer(2), -Integer(3)], [-Integer(2), Integer(3), -Integer(3), Integer(4)], [Integer(2), Integer(3)], [-Integer(3), -Integer(4)]], Integer(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]]] >>> StrongTableaux.follows_tableau_unsigned_standard([[None,-Integer(1)],[-Integer(2),-Integer(3)]],Integer(3)) [[[None, -1, 4, 4, 4], [-2, -3]], [[None, -1, 4], [-2, -3], [4]], [[None, -1], [-2, -3], [4], [4], [4]]]
- inner_shape()[source]¶
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]
>>> from sage.all import * >>> StrongTableaux( Integer(2), [Integer(3),Integer(1)] ).inner_shape() [] >>> type(StrongTableaux( Integer(2), [Integer(3),Integer(1)] ).inner_shape()) <class 'sage.combinat.core.Cores_length_with_category.element_class'> >>> StrongTableaux( Integer(4), [[Integer(2),Integer(1)], [Integer(1)]] ).inner_shape() [1]
- classmethod marked_CST_to_transposition_sequence(T, k)[source]¶
Return a list of transpositions corresponding to
T.Given a strong column strict tableau
Treturns 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– positive integer
OUTPUT: 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]]
>>> from sage.all import * >>> CST_to_trans = StrongTableaux.marked_CST_to_transposition_sequence >>> CST_to_trans([[-Integer(1), -Integer(1), -Integer(1)], [Integer(1)]], Integer(2)) [[2, 3], [1, 2], [0, 1]] >>> CST_to_trans([], Integer(2)) [] >>> CST_to_trans([[-Integer(2), -Integer(2), -Integer(2)], [Integer(2)]], Integer(2)) [[2, 3], [1, 2], [0, 1]] >>> CST_to_trans([[-Integer(1), -Integer(2), -Integer(2), -Integer(2), -Integer(2)], [-Integer(2), Integer(2)], [Integer(2)]], Integer(3)) [[4, 5], [3, 4], [2, 3], [1, 2], [-1, 0], [0, 1]] >>> CST_to_trans([[-Integer(1), -Integer(2), -Integer(5), Integer(5), -Integer(5), Integer(5), -Integer(5)], [-Integer(3), -Integer(4), Integer(5), Integer(5)], [Integer(5)]],Integer(3)) [[5, 7], [3, 5], [2, 3], [0, 1], [-1, 0], [1, 2], [0, 1]] >>> CST_to_trans([[-Integer(1), -Integer(2), -Integer(3), Integer(4), -Integer(7)], [-Integer(4), -Integer(6)], [-Integer(5), Integer(6)]],Integer(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)[source]¶
An iterator generating strong marked tableaux from an unmarked strong tableau.
Iterator which lists all marked tableaux of weight
weightsuch that the standard unmarked part of the tableau is equal tounmarkedT.INPUT:
unmarkedT– list of lists representing a strong unmarked tableauk– positive integerweight– list of nonnegative integers indicating the weight
OUTPUT: an iterator that returns
StrongTableauobjectsEXAMPLES:
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]]]
>>> from sage.all import * >>> ST = StrongTableaux.marked_given_unmarked_and_weight_iterator([[Integer(1),Integer(2),Integer(3)],[Integer(3)]], Integer(2), [Integer(3)]) >>> list(ST) [[[-1, -1, -1], [1]]] >>> ST = StrongTableaux.marked_given_unmarked_and_weight_iterator([[Integer(1),Integer(2),Integer(3)],[Integer(3)]], Integer(2), [Integer(0),Integer(3)]) >>> list(ST) [[[-2, -2, -2], [2]]] >>> ST = StrongTableaux.marked_given_unmarked_and_weight_iterator([[Integer(1),Integer(2),Integer(3)],[Integer(3)]], Integer(2), [Integer(1),Integer(2)]) >>> list(ST) [[[-1, -2, -2], [2]]] >>> ST = StrongTableaux.marked_given_unmarked_and_weight_iterator([[Integer(1),Integer(2),Integer(3)],[Integer(3)]], Integer(2), [Integer(2),Integer(1)]) >>> list(ST) [[[-1, -1, 2], [-2]], [[-1, -1, -2], [2]]] >>> ST = StrongTableaux.marked_given_unmarked_and_weight_iterator([[None, None, Integer(1), Integer(2), Integer(4)], [Integer(2), Integer(4)], [Integer(3)]], Integer(3), [Integer(3),Integer(1)]) >>> list(ST) [] >>> ST = StrongTableaux.marked_given_unmarked_and_weight_iterator([[None, None, Integer(1), Integer(2), Integer(4)], [Integer(2), Integer(4)], [Integer(3)]], Integer(3), [Integer(2),Integer(2)]) >>> list(ST) [[[None, None, -1, -1, 2], [1, -2], [-2]], [[None, None, -1, -1, -2], [1, 2], [-2]]]
- options = Current options for Tableaux - ascii_art: repr - convention: English - display: list - latex: diagram[source]¶
- outer_shape()[source]¶
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]
>>> from sage.all import * >>> StrongTableaux( Integer(2), [Integer(3),Integer(1)] ).outer_shape() [3, 1] >>> type(StrongTableaux( Integer(2), [Integer(3),Integer(1)] ).outer_shape()) <class 'sage.combinat.core.Cores_length_with_category.element_class'> >>> StrongTableaux( Integer(4), [[Integer(2),Integer(1)], [Integer(1)]] ).outer_shape() [2, 1]
- shape()[source]¶
Return the shape of
self.If the
selfhas 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])
>>> from sage.all import * >>> StrongTableaux( Integer(2), [Integer(3),Integer(1)] ).shape() [3, 1] >>> type(StrongTableaux( Integer(2), [Integer(3),Integer(1)] ).shape()) <class 'sage.combinat.core.Cores_length_with_category.element_class'> >>> StrongTableaux( Integer(4), [[Integer(2),Integer(1)], [Integer(1)]] ).shape() ([2, 1], [1])
- classmethod standard_marked_iterator(k, size, outer_shape=None, inner_shape=[])[source]¶
An iterator for generating standard strong marked tableaux.
An iterator which generates all standard marked \(k\)-tableaux of a given
sizewhich are contained inouter_shapeand contain theinner_shape. Ifouter_shapeisNonethen there is no restriction on the shape of the tableaux which are created.INPUT:
k– positive integersize– positive integerouter_shape– list which is a \(k+1\)-core (default:None)inner_shape– list which is a \(k+1\)-core (default:[])
OUTPUT:
an iterator which returns the standard marked tableaux with
sizecells and that are contained inouter_shapeand 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
>>> from sage.all import * >>> list(StrongTableaux.standard_marked_iterator(Integer(2), Integer(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]]] >>> list(StrongTableaux.standard_marked_iterator(Integer(2), Integer(1), inner_shape=[Integer(1),Integer(1)])) [[[None, 1, -1], [None]], [[None, 1], [None], [-1]], [[None, -1], [None], [1]]] >>> len(list(StrongTableaux.standard_marked_iterator(Integer(4),Integer(4)))) 10 >>> len(list(StrongTableaux.standard_marked_iterator(Integer(4),Integer(6)))) 140 >>> len(list(StrongTableaux.standard_marked_iterator(Integer(4),Integer(4), inner_shape=[Integer(2),Integer(2)]))) 200 >>> len(list(StrongTableaux.standard_marked_iterator(Integer(4),Integer(4), outer_shape=[Integer(5),Integer(2),Integer(2),Integer(1)], inner_shape=[Integer(2),Integer(2)]))) 24
- classmethod standard_unmarked_iterator(k, size, outer_shape=None, inner_shape=[])[source]¶
An iterator for standard unmarked strong tableaux.
An iterator which generates all unmarked tableaux of a given
sizewhich are contained inouter_shapeand 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_shapeisNonethen there is no restriction on the shape of the tableaux which are created.INPUT:
k,size– positive integersouter_shape– list representing a \(k+1\)-core (default:None)inner_shape– list representing a \(k+1\)-core (default:[])
OUTPUT:
an iterator which lists all standard strong unmarked tableaux with
sizecells and which are contained inouter_shapeand 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
>>> from sage.all import * >>> list(StrongTableaux.standard_unmarked_iterator(Integer(2), Integer(3))) [[[1, 2, 3], [3]], [[1, 2], [3], [3]], [[1, 3, 3], [2]], [[1, 3], [2], [3]]] >>> list(StrongTableaux.standard_unmarked_iterator(Integer(2), Integer(1), inner_shape=[Integer(1),Integer(1)])) [[[None, 1, 1], [None]], [[None, 1], [None], [1]]] >>> len(list(StrongTableaux.standard_unmarked_iterator(Integer(4),Integer(4)))) 10 >>> len(list(StrongTableaux.standard_unmarked_iterator(Integer(4),Integer(6)))) 98 >>> len(list(StrongTableaux.standard_unmarked_iterator(Integer(4),Integer(4), inner_shape=[Integer(2),Integer(2)]))) 92 >>> len(list(StrongTableaux.standard_unmarked_iterator(Integer(4),Integer(4), outer_shape=[Integer(5),Integer(2),Integer(2),Integer(1)], inner_shape=[Integer(2),Integer(2)]))) 10
- classmethod transpositions_to_standard_strong(transeq, k, emptyTableau=[])[source]¶
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 ofNoneentries
OUTPUT: a
StrongTableauobjectEXAMPLES:
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]]
>>> from sage.all import * >>> StrongTableaux.transpositions_to_standard_strong([[Integer(0),Integer(1)]], Integer(2)) [[-1]] >>> StrongTableaux.transpositions_to_standard_strong([[-Integer(2),-Integer(1)], [Integer(2),Integer(3)]], Integer(2), [[None, None]]) [[None, None, -1], [1], [-2]] >>> StrongTableaux.transpositions_to_standard_strong([[Integer(2), Integer(3)], [Integer(1), Integer(2)], [Integer(0), Integer(1)]], Integer(2)) [[-1, -2, -3], [3]] >>> StrongTableaux.transpositions_to_standard_strong([[-Integer(1), Integer(0)], [Integer(1), Integer(2)], [Integer(0), Integer(1)]], Integer(2)) [[-1, -2, 3], [-3]] >>> StrongTableaux.transpositions_to_standard_strong([[Integer(3), Integer(4)], [-Integer(1), Integer(0)], [Integer(1), Integer(2)]], Integer(2), [[None]]) [[None, -1, 2, -3], [-2, 3]]
- sage.combinat.k_tableau.WeakTableau(t, k, inner_shape=[], representation='core')[source]¶
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
tis a list of lists where each subtableaux should have a \(k+1\)-core shape;Noneis allowed as an entry for skew weak \(k\)-tableauxfor the ‘bounded’ representation
tis a list of lists where each subtableaux should have a \(k\)-bounded shape;Noneis allowed as an entry for skew weak \(k\)-tableauxfor the ‘factorized_permutation’ representation
tis 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_shapeshould be the inner shape as a \((k+1)\)-core
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'>
>>> from sage.all import * >>> t = WeakTableau([[Integer(1), Integer(1), Integer(2), Integer(2), Integer(3)], [Integer(2), Integer(3)], [Integer(3)]], Integer(3)) >>> t.shape() [5, 2, 1] >>> t.weight() (2, 2, 2) >>> 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'>
>>> from sage.all import * >>> ts = WeakTableau([[None, Integer(1), Integer(1), Integer(2), Integer(2)], [None, Integer(2)], [Integer(1)]], Integer(3)) >>> ts.shape() ([5, 2, 1], [1, 1]) >>> ts.weight() (2, 2) >>> 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
>>> from sage.all import * >>> tb = WeakTableau([[Integer(1),Integer(1),Integer(2)],[Integer(2),Integer(3)],[Integer(3)]], Integer(3), representation='bounded') >>> tb.shape() [3, 2, 1] >>> tb.weight() (2, 2, 2) >>> type(tb) <class 'sage.combinat.k_tableau.WeakTableaux_bounded_with_category.element_class'> >>> tb.to_core_tableau() [[1, 1, 2, 2, 3], [2, 3], [3]] >>> 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
>>> from sage.all import * >>> tbs = WeakTableau([[None, Integer(1), Integer(2)], [None, Integer(2)], [Integer(1)]], Integer(3), representation = "bounded") >>> tbs.shape() ([3, 2, 1], [1, 1]) >>> tbs.weight() (2, 2) >>> tbs.to_core_tableau() [[None, 1, 1, 2, 2], [None, 2], [1]] >>> 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]]
>>> from sage.all import * >>> tf = WeakTableau([[Integer(2),Integer(0)],[Integer(3),Integer(2)],[Integer(1),Integer(0)]], Integer(3), representation = "factorized_permutation") >>> tf.shape() [5, 2, 1] >>> tf.weight() (2, 2, 2) >>> type(tf) <class 'sage.combinat.k_tableau.WeakTableaux_factorized_permutation_with_category.element_class'> >>> tf.to_core_tableau() == t True >>> tfs = WeakTableau([[Integer(0),Integer(3)],[Integer(2),Integer(1)]], Integer(3), inner_shape = [Integer(1),Integer(1)], representation = 'factorized_permutation') >>> tfs.shape() ([5, 2, 1], [1, 1]) >>> tfs.weight() (2, 2) >>> type(tfs) <class 'sage.combinat.k_tableau.WeakTableaux_factorized_permutation_with_category.element_class'> >>> 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]]
>>> from sage.all import * >>> ts [[None, 1, 1, 2, 2], [None, 2], [1]] >>> ts.parent()._representation 'core' >>> 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
>>> from sage.all import * >>> t = Tableau([[Integer(1),Integer(1),Integer(2)],[Integer(2),Integer(3)],[Integer(3)]]) >>> t.is_k_tableau(Integer(3)) True >>> t = SkewTableau([[None, Integer(1), Integer(2)], [None, Integer(2)], [Integer(1)]]) >>> t.is_k_tableau(Integer(3)) True >>> t = SkewTableau([[None, Integer(1), Integer(1)], [None, Integer(2)], [Integer(2)]]) >>> t.is_k_tableau(Integer(3)) False
- class sage.combinat.k_tableau.WeakTableau_abstract[source]¶
Bases:
ClonableListAbstract class for the various element classes of WeakTableau.
- intermediate_shapes()[source]¶
Return the intermediate shapes of
self.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.
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]]
>>> from sage.all import * >>> t = WeakTableau([[Integer(1), Integer(1), Integer(2), Integer(2), Integer(3)], [Integer(2), Integer(3)], [Integer(3)]],Integer(3)) >>> t.intermediate_shapes() [[], [2], [4, 1], [5, 2, 1]] >>> t = WeakTableau([[None, None, Integer(2), Integer(3), Integer(4)], [Integer(1), Integer(4)], [Integer(2)]], Integer(3)) >>> t.intermediate_shapes() [[2], [2, 1], [3, 1, 1], [4, 1, 1], [5, 2, 1]] >>> t = WeakTableau([[Integer(1),Integer(1),Integer(1)],[Integer(2),Integer(2)],[Integer(3)]], Integer(3), representation = 'bounded') >>> t.intermediate_shapes() [[], [3], [3, 2], [3, 2, 1]] >>> t = WeakTableau([[None, None, Integer(1)], [Integer(2), Integer(4)], [Integer(3)]], Integer(3), representation = 'bounded') >>> t.intermediate_shapes() [[2], [3], [3, 1], [3, 1, 1], [3, 2, 1]] >>> t = WeakTableau([[Integer(0)],[Integer(3)],[Integer(2)],[Integer(3)]], Integer(3), inner_shape = [Integer(2)], representation = 'factorized_permutation') >>> t.intermediate_shapes() [[2], [2, 1], [3, 1, 1], [4, 1, 1], [5, 2, 1]]
- pp()[source]¶
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]
>>> from sage.all import * >>> t = WeakTableau([[None, Integer(1), Integer(1), Integer(2), Integer(2)], [None, Integer(2)], [Integer(1)]], Integer(3)) >>> t.pp() . 1 1 2 2 . 2 1 >>> t = WeakTableau([[Integer(2),Integer(0)],[Integer(3),Integer(2)]], Integer(3), inner_shape = [Integer(2)], representation = 'factorized_permutation') >>> t.pp() [s2*s0, s3*s2]
- representation(representation='core')[source]¶
Return the analogue of
selfin the specified representation.INPUT:
representation– ‘core’, ‘bounded’, or ‘factorized_permutation’ (default:'core')
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
>>> from sage.all import * >>> t = WeakTableau([[Integer(1), Integer(1), Integer(2), Integer(3), Integer(4), Integer(4), Integer(5), Integer(5), Integer(6)], [Integer(2), Integer(3), Integer(5), Integer(5), Integer(6)], [Integer(3), Integer(4), Integer(7)], [Integer(5), Integer(6)], [Integer(6)], [Integer(7)]], Integer(4)) >>> t.parent()._representation 'core' >>> t.representation('bounded') [[1, 1, 2, 4], [2, 3, 5], [3, 4], [5, 6], [6], [7]] >>> t.representation('factorized_permutation') [s0, s3*s1, s2*s1, s0*s4, s3*s0, s4*s2, s1*s0] >>> tb = WeakTableau([[Integer(1), Integer(1), Integer(2), Integer(4)], [Integer(2), Integer(3), Integer(5)], [Integer(3), Integer(4)], [Integer(5), Integer(6)], [Integer(6)], [Integer(7)]], Integer(4), representation = 'bounded') >>> tb.parent()._representation 'bounded' >>> tb.representation('core') == t True >>> tb.representation('factorized_permutation') [s0, s3*s1, s2*s1, s0*s4, s3*s0, s4*s2, s1*s0] >>> tp = WeakTableau([[Integer(0)],[Integer(3),Integer(1)],[Integer(2),Integer(1)],[Integer(0),Integer(4)],[Integer(3),Integer(0)],[Integer(4),Integer(2)],[Integer(1),Integer(0)]], Integer(4), representation = 'factorized_permutation') >>> tp.parent()._representation 'factorized_permutation' >>> tp.representation('core') == t True >>> tp.representation('bounded') == tb True
- shape()[source]¶
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])
>>> from sage.all import * >>> t = WeakTableau([[Integer(1), Integer(1), Integer(2), Integer(2), Integer(3)], [Integer(2), Integer(3)], [Integer(3)]], Integer(3)) >>> t.shape() [5, 2, 1] >>> t = WeakTableau([[None, None, Integer(2), Integer(3), Integer(4)], [Integer(1), Integer(4)], [Integer(2)]], Integer(3)) >>> t.shape() ([5, 2, 1], [2]) >>> t = WeakTableau([[Integer(1),Integer(1),Integer(1)],[Integer(2),Integer(2)],[Integer(3)]], Integer(3), representation = 'bounded') >>> t.shape() [3, 2, 1] >>> t = WeakTableau([[None, None, Integer(1)], [Integer(2), Integer(4)], [Integer(3)]], Integer(3), representation = 'bounded') >>> t.shape() ([3, 2, 1], [2]) >>> t = WeakTableau([[Integer(2)],[Integer(0),Integer(3)],[Integer(2),Integer(1),Integer(0)]], Integer(3), representation = 'factorized_permutation') >>> t.shape() [5, 2, 1] >>> t = WeakTableau([[Integer(2),Integer(0)],[Integer(3),Integer(2)]], Integer(3), inner_shape = [Integer(2)], representation = 'factorized_permutation') >>> t.shape() ([5, 2, 1], [2])
- size()[source]¶
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
>>> from sage.all import * >>> t = WeakTableau([[None, Integer(1), Integer(1), Integer(2), Integer(2)], [None, Integer(2)], [Integer(1)]], Integer(3)) >>> t.shape() ([5, 2, 1], [1, 1]) >>> t.size() 4 >>> t = WeakTableau([[Integer(1),Integer(1),Integer(2)],[Integer(2),Integer(3)],[Integer(3)]], Integer(3), representation='bounded') >>> t.shape() [3, 2, 1] >>> t.size() 6
- weight()[source]¶
Return the weight of
self.The weight is a tuple whose \(i\)-th entry is the number of labels \(i\) 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)
>>> from sage.all import * >>> t = WeakTableau([[Integer(1), Integer(1), Integer(2), Integer(2), Integer(3)], [Integer(2), Integer(3)], [Integer(3)]], Integer(3)) >>> t.weight() (2, 2, 2) >>> t = WeakTableau([[None, None, Integer(2), Integer(3), Integer(4)], [Integer(1), Integer(4)], [Integer(2)]], Integer(3)) >>> t.weight() (1, 1, 1, 1) >>> t = WeakTableau([[None,Integer(2),Integer(3)],[Integer(3)]],Integer(2)) >>> t.weight() (0, 1, 1) >>> t = WeakTableau([[Integer(1),Integer(1),Integer(1)],[Integer(2),Integer(2)],[Integer(3)]], Integer(3), representation = 'bounded') >>> t.weight() (3, 2, 1) >>> t = WeakTableau([[Integer(1),Integer(1),Integer(2)],[Integer(2),Integer(3)],[Integer(3)]], Integer(3), representation = 'bounded') >>> t.weight() (2, 2, 2) >>> t = WeakTableau([[None, None, Integer(1)], [Integer(2), Integer(4)], [Integer(3)]], Integer(3), representation = 'bounded') >>> t.weight() (1, 1, 1, 1) >>> t = WeakTableau([[Integer(2)],[Integer(0),Integer(3)],[Integer(2),Integer(1),Integer(0)]], Integer(3), representation = 'factorized_permutation') >>> t.weight() (3, 2, 1) >>> t = WeakTableau([[Integer(2),Integer(0)],[Integer(3),Integer(2)],[Integer(1),Integer(0)]], Integer(3), representation = 'factorized_permutation') >>> t.weight() (2, 2, 2) >>> t = WeakTableau([[Integer(2),Integer(0)],[Integer(3),Integer(2)]], Integer(3), inner_shape = [Integer(2)], representation = 'factorized_permutation') >>> t.weight() (2, 2)
- class sage.combinat.k_tableau.WeakTableau_bounded(parent, t)[source]¶
Bases:
WeakTableau_abstractA (skew) weak \(k\)-tableau represented in terms of \(k\)-bounded partitions.
- check()[source]¶
Check that
selfis a valid weak \(k\)-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()
>>> from sage.all import * >>> t = WeakTableau([[Integer(1),Integer(1)],[Integer(2)]], Integer(2), representation = 'bounded') >>> t.check() >>> t = WeakTableau([[None, None, Integer(1)], [Integer(2), Integer(4)], [Integer(3)]], Integer(3), representation = 'bounded') >>> t.check()
- classmethod from_core_tableau(t, k)[source]¶
Construct weak \(k\)-bounded tableau from in \(k\)-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]]
>>> from sage.all import * >>> from sage.combinat.k_tableau import WeakTableau_bounded >>> WeakTableau_bounded.from_core_tableau([[Integer(1), Integer(1), Integer(2), Integer(2), Integer(3)], [Integer(2), Integer(3)], [Integer(3)]], Integer(3)) [[1, 1, 2], [2, 3], [3]] >>> WeakTableau_bounded.from_core_tableau([[None, None, Integer(2), Integer(3), Integer(4)], [Integer(1), Integer(4)], [Integer(2)]], Integer(3)) [[None, None, 3], [1, 4], [2]] >>> WeakTableau_bounded.from_core_tableau([[None,Integer(2),Integer(3)],[Integer(3)]], Integer(2)) [[None, 2], [3]]
- k_charge(algorithm='I')[source]¶
Return the \(k\)-charge of
self.INPUT:
algorithm– (default:'I') if “I”, computes \(k\)-charge using the \(I\) algorithm, otherwise uses the \(J\)-algorithm
OUTPUT: nonnegative integer
For the definition of \(k\)-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
>>> from sage.all import * >>> t = WeakTableau([[Integer(1), Integer(1), Integer(2)], [Integer(2), Integer(3)], [Integer(3)]], Integer(3), representation = 'bounded') >>> t.k_charge() 2 >>> t = WeakTableau([[Integer(1), Integer(3), Integer(5)], [Integer(2), Integer(6)], [Integer(4)]], Integer(3), representation = 'bounded') >>> t.k_charge() 8 >>> t = WeakTableau([[Integer(1), Integer(1), Integer(2), Integer(4)], [Integer(2), Integer(3), Integer(5)], [Integer(3), Integer(4)], [Integer(5), Integer(6)], [Integer(6)], [Integer(7)]], Integer(4), representation = 'bounded') >>> t.k_charge() 12
- shape_bounded()[source]¶
Return the shape of
selfas \(k\)-bounded partition.When the tableau is straight, the outer shape is returned as a \(k\)-bounded partition. When the tableau is skew, the tuple of the outer and inner shape is returned as \(k\)-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])
>>> from sage.all import * >>> t = WeakTableau([[Integer(1),Integer(1),Integer(1)],[Integer(2),Integer(2)],[Integer(3)]], Integer(3), representation = 'bounded') >>> t.shape_bounded() [3, 2, 1] >>> t = WeakTableau([[None, None, Integer(1)], [Integer(2), Integer(4)], [Integer(3)]], Integer(3), representation = 'bounded') >>> t.shape_bounded() ([3, 2, 1], [2])
- shape_core()[source]¶
Return the shape of
selfas \((k+1)\)-core.When the tableau is straight, the outer shape is returned as a \((k+1)\)-core. When the tableau is skew, the tuple of the outer and inner shape is returned as \((k+1)\)-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])
>>> from sage.all import * >>> t = WeakTableau([[Integer(1),Integer(1),Integer(1)],[Integer(2),Integer(2)],[Integer(3)]], Integer(3), representation = 'bounded') >>> t.shape_core() [5, 2, 1] >>> t = WeakTableau([[None, None, Integer(1)], [Integer(2), Integer(4)], [Integer(3)]], Integer(3), representation = 'bounded') >>> t.shape_core() ([5, 2, 1], [2])
- to_core_tableau()[source]¶
Return the weak \(k\)-tableau
selfwhere the shape of each restricted tableau is a \((k+1)\)-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
>>> from sage.all import * >>> t = WeakTableau([[Integer(1),Integer(1),Integer(2),Integer(4)],[Integer(2),Integer(3),Integer(5)],[Integer(3),Integer(4)],[Integer(5),Integer(6)],[Integer(6)],[Integer(7)]], Integer(4), representation = 'bounded') >>> 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]] >>> type(c) <class 'sage.combinat.k_tableau.WeakTableaux_core_with_category.element_class'> >>> t = WeakTableau([], Integer(4), representation = 'bounded') >>> t.to_core_tableau() [] >>> from sage.combinat.k_tableau import WeakTableau_bounded >>> t = WeakTableau([[Integer(1),Integer(1),Integer(2)],[Integer(2),Integer(3)],[Integer(3)]], Integer(3), representation = 'bounded') >>> WeakTableau_bounded.from_core_tableau(t.to_core_tableau(),Integer(3)) [[1, 1, 2], [2, 3], [3]] >>> t == WeakTableau_bounded.from_core_tableau(t.to_core_tableau(),Integer(3)) True >>> t = WeakTableau([[None, None, Integer(1)], [Integer(2), Integer(4)], [Integer(3)]], Integer(3), representation = 'bounded') >>> t.to_core_tableau() [[None, None, 1, 2, 4], [2, 4], [3]] >>> t == WeakTableau_bounded.from_core_tableau(t.to_core_tableau(),Integer(3)) True
- class sage.combinat.k_tableau.WeakTableau_core(parent, t)[source]¶
Bases:
WeakTableau_abstractA (skew) weak \(k\)-tableau represented in terms of \((k+1)\)-cores.
- check()[source]¶
Check that
selfis a valid weak \(k\)-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()
>>> from sage.all import * >>> t = WeakTableau([[Integer(1), Integer(1), Integer(2)], [Integer(2)]], Integer(2)) >>> t.check() >>> t = WeakTableau([[None, None, Integer(2), Integer(3), Integer(4)], [Integer(1), Integer(4)], [Integer(2)]], Integer(3)) >>> t.check()
- dictionary_of_coordinates_at_residues(v)[source]¶
Return a dictionary assigning to all residues of
selfwith labelva list of cells with the given residue.INPUT:
v– a label of a cell inself
OUTPUT: dictionary assigning coordinates in
selfto residuesEXAMPLES:
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) {}
>>> from sage.all import * >>> t = WeakTableau([[Integer(1), Integer(1), Integer(2), Integer(2), Integer(3)], [Integer(2), Integer(3)], [Integer(3)]],Integer(3)) >>> t.dictionary_of_coordinates_at_residues(Integer(3)) {0: [(0, 4), (1, 1)], 2: [(2, 0)]} >>> t = WeakTableau([[None, None, Integer(1), Integer(1), Integer(4)], [Integer(1), Integer(4)], [Integer(3)]], Integer(3)) >>> t.dictionary_of_coordinates_at_residues(Integer(1)) {2: [(0, 2)], 3: [(0, 3), (1, 0)]} >>> t = WeakTableau([], Integer(3)) >>> t.dictionary_of_coordinates_at_residues(Integer(1)) {}
- k_charge(algorithm='I')[source]¶
Return the \(k\)-charge of
self.INPUT:
algorithm– (default:'I') if “I”, computes \(k\)-charge using the \(I\) algorithm, otherwise uses the \(J\)-algorithm
OUTPUT: nonnegative integer
For the definition of \(k\)-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
>>> from sage.all import * >>> t = WeakTableau([[Integer(1), Integer(1), Integer(2), Integer(2), Integer(3)], [Integer(2), Integer(3)], [Integer(3)]], Integer(3)) >>> t.k_charge() 2 >>> t = WeakTableau([[Integer(1), Integer(3), Integer(4), Integer(5), Integer(6)], [Integer(2), Integer(6)], [Integer(4)]], Integer(3)) >>> t.k_charge() 8 >>> t = WeakTableau([[Integer(1), Integer(1), Integer(2), Integer(3), Integer(4), Integer(4), Integer(5), Integer(5), Integer(6)], [Integer(2), Integer(3), Integer(5), Integer(5), Integer(6)], [Integer(3), Integer(4), Integer(7)], [Integer(5), Integer(6)], [Integer(6)], [Integer(7)]], Integer(4)) >>> t.k_charge() 12
- k_charge_I()[source]¶
Return the \(k\)-charge of
selfusing the \(I\)-algorithm.For the definition of \(k\)-charge and the \(I\)-algorithm see Section 3.3 of [LLMSSZ2013].
OUTPUT: nonnegative integer
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
>>> from sage.all import * >>> t = WeakTableau([[Integer(1), Integer(1), Integer(2), Integer(2), Integer(3)], [Integer(2), Integer(3)], [Integer(3)]], Integer(3)) >>> t.k_charge_I() 2 >>> t = WeakTableau([[Integer(1), Integer(3), Integer(4), Integer(5), Integer(6)], [Integer(2), Integer(6)], [Integer(4)]], Integer(3)) >>> t.k_charge_I() 8 >>> t = WeakTableau([[Integer(1), Integer(1), Integer(2), Integer(3), Integer(4), Integer(4), Integer(5), Integer(5), Integer(6)], [Integer(2), Integer(3), Integer(5), Integer(5), Integer(6)], [Integer(3), Integer(4), Integer(7)], [Integer(5), Integer(6)], [Integer(6)], [Integer(7)]], Integer(4)) >>> t.k_charge_I() 12
- k_charge_J()[source]¶
Return the \(k\)-charge of
selfusing the \(J\)-algorithm.For the definition of \(k\)-charge and the \(J\)-algorithm see Section 3.3 of [LLMSSZ2013].
OUTPUT: nonnegative integer
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
>>> from sage.all import * >>> t = WeakTableau([[Integer(1), Integer(1), Integer(2), Integer(2), Integer(3)], [Integer(2), Integer(3)], [Integer(3)]], Integer(3)) >>> t.k_charge_J() 2 >>> t = WeakTableau([[Integer(1), Integer(3), Integer(4), Integer(5), Integer(6)], [Integer(2), Integer(6)], [Integer(4)]], Integer(3)) >>> t.k_charge_J() 8 >>> t = WeakTableau([[Integer(1), Integer(1), Integer(2), Integer(3), Integer(4), Integer(4), Integer(5), Integer(5), Integer(6)], [Integer(2), Integer(3), Integer(5), Integer(5), Integer(6)], [Integer(3), Integer(4), Integer(7)], [Integer(5), Integer(6)], [Integer(6)], [Integer(7)]], Integer(4)) >>> t.k_charge_J() 12
- list_of_standard_cells()[source]¶
Return a list of lists of the coordinates of the standard cells of
self.INPUT:
self– a weak \(k\)-tableau in core representation with partition weight
OUTPUT: list of lists of coordinates
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)]]
>>> from sage.all import * >>> t = WeakTableau([[Integer(1), Integer(1), Integer(2), Integer(2), Integer(3)], [Integer(2), Integer(3)], [Integer(3)]], Integer(3)) >>> t.list_of_standard_cells() [[(0, 1), (1, 0), (2, 0)], [(0, 0), (0, 2), (1, 1)]] >>> t = WeakTableau([[Integer(1), Integer(1), Integer(1), Integer(2)], [Integer(2), Integer(2), Integer(3)]], Integer(5)) >>> t.list_of_standard_cells() [[(0, 2), (1, 1), (1, 2)], [(0, 1), (1, 0)], [(0, 0), (0, 3)]] >>> t = WeakTableau([[Integer(1), Integer(1), Integer(2), Integer(3), Integer(4), Integer(4), Integer(5), Integer(5), Integer(6)], [Integer(2), Integer(3), Integer(5), Integer(5), Integer(6)], [Integer(3), Integer(4), Integer(7)], [Integer(5), Integer(6)], [Integer(6)], [Integer(7)]], Integer(4)) >>> 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)]]
- residues_of_entries(v)[source]¶
Return a list of residues of cells of weak \(k\)-tableau
selflabeled byv.INPUT:
v– a label of a cell inself
OUTPUT: list of residues
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]
>>> from sage.all import * >>> t = WeakTableau([[Integer(1), Integer(1), Integer(2), Integer(2), Integer(3)], [Integer(2), Integer(3)], [Integer(3)]],Integer(3)) >>> t.residues_of_entries(Integer(1)) [0, 1] >>> t = WeakTableau([[None, None, Integer(1), Integer(1), Integer(4)], [Integer(1), Integer(4)], [Integer(3)]], Integer(3)) >>> t.residues_of_entries(Integer(1)) [2, 3]
- shape_bounded()[source]¶
Return the shape of
selfas a \(k\)-bounded partition.When the tableau is straight, the outer shape is returned as a \(k\)-bounded partition. When the tableau is skew, the tuple of the outer and inner shape is returned as \(k\)-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])
>>> from sage.all import * >>> t = WeakTableau([[Integer(1), Integer(1), Integer(2), Integer(2), Integer(3)], [Integer(2), Integer(3)], [Integer(3)]],Integer(3)) >>> t.shape_bounded() [3, 2, 1] >>> t = WeakTableau([[None, None, Integer(2), Integer(3), Integer(4)], [Integer(1), Integer(4)], [Integer(2)]], Integer(3)) >>> t.shape_bounded() ([3, 2, 1], [2])
- shape_core()[source]¶
Return the shape of
selfas a \((k+1)\)-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])
>>> from sage.all import * >>> t = WeakTableau([[Integer(1), Integer(1), Integer(2), Integer(2), Integer(3)], [Integer(2), Integer(3)], [Integer(3)]],Integer(3)) >>> t.shape_core() [5, 2, 1] >>> t = WeakTableau([[None, None, Integer(2), Integer(3), Integer(4)], [Integer(1), Integer(4)], [Integer(2)]], Integer(3)) >>> t.shape_core() ([5, 2, 1], [2])
- to_bounded_tableau()[source]¶
Return the bounded representation of the weak \(k\)-tableau
self.Each restricted subtableau of the output is a \(k\)-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
>>> from sage.all import * >>> t = WeakTableau([[Integer(1), Integer(1), Integer(2), Integer(2), Integer(3)], [Integer(2), Integer(3)], [Integer(3)]], Integer(3)) >>> c = t.to_bounded_tableau(); c [[1, 1, 2], [2, 3], [3]] >>> type(c) <class 'sage.combinat.k_tableau.WeakTableaux_bounded_with_category.element_class'> >>> t = WeakTableau([[None, None, Integer(2), Integer(3), Integer(4)], [Integer(1), Integer(4)], [Integer(2)]], Integer(3)) >>> t.to_bounded_tableau() [[None, None, 3], [1, 4], [2]] >>> t.to_bounded_tableau().to_core_tableau() == t True
- to_factorized_permutation_tableau()[source]¶
Return the factorized permutation representation of the weak \(k\)-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
>>> from sage.all import * >>> t = WeakTableau([[Integer(1), Integer(1), Integer(2), Integer(2), Integer(3)], [Integer(2), Integer(3)], [Integer(3)]], Integer(3)) >>> c = t.to_factorized_permutation_tableau(); c [s2*s0, s3*s2, s1*s0] >>> type(c) <class 'sage.combinat.k_tableau.WeakTableaux_factorized_permutation_with_category.element_class'> >>> c.to_core_tableau() == t True >>> t = WeakTableau([[None, None, Integer(2), Integer(3), Integer(4)], [Integer(1), Integer(4)], [Integer(2)]], Integer(3)) >>> c = t.to_factorized_permutation_tableau(); c [s0, s3, s2, s3] >>> c._inner_shape [2] >>> c.to_core_tableau() == t True
- class sage.combinat.k_tableau.WeakTableau_factorized_permutation(parent, t)[source]¶
Bases:
WeakTableau_abstractA weak (skew) \(k\)-tableau represented in terms of factorizations of affine permutations into cyclically decreasing elements.
- check()[source]¶
Check that
selfis a valid weak \(k\)-tableau.EXAMPLES:
sage: t = WeakTableau([[2],[0,3],[2,1,0]], 3, representation = 'factorized_permutation') sage: t.check()
>>> from sage.all import * >>> t = WeakTableau([[Integer(2)],[Integer(0),Integer(3)],[Integer(2),Integer(1),Integer(0)]], Integer(3), representation = 'factorized_permutation') >>> t.check()
- classmethod from_core_tableau(t, k)[source]¶
Construct weak factorized affine permutation tableau from a \(k\)-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]
>>> from sage.all import * >>> from sage.combinat.k_tableau import WeakTableau_factorized_permutation >>> WeakTableau_factorized_permutation.from_core_tableau([[Integer(1), Integer(1), Integer(2), Integer(2), Integer(3)], [Integer(2), Integer(3)], [Integer(3)]],Integer(3)) [s2*s0, s3*s2, s1*s0] >>> WeakTableau_factorized_permutation.from_core_tableau([[Integer(1), Integer(1), Integer(2), Integer(3), Integer(4), Integer(4), Integer(5), Integer(5), Integer(6)], [Integer(2), Integer(3), Integer(5), Integer(5), Integer(6)], [Integer(3), Integer(4), Integer(7)], [Integer(5), Integer(6)], [Integer(6)], [Integer(7)]], Integer(4)) [s0, s3*s1, s2*s1, s0*s4, s3*s0, s4*s2, s1*s0] >>> WeakTableau_factorized_permutation.from_core_tableau([[None, Integer(1), Integer(1), Integer(2), Integer(2)], [None, Integer(2)], [Integer(1)]], Integer(3)) [s0*s3, s2*s1]
- k_charge(algorithm='I')[source]¶
Return the \(k\)-charge of
self.OUTPUT: nonnegative integer
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
>>> from sage.all import * >>> t = WeakTableau([[Integer(2),Integer(0)],[Integer(3),Integer(2)],[Integer(1),Integer(0)]], Integer(3), representation = 'factorized_permutation') >>> t.k_charge() 2 >>> t = WeakTableau([[Integer(0)],[Integer(3)],[Integer(2)],[Integer(1)],[Integer(3)],[Integer(0)]], Integer(3), representation = 'factorized_permutation') >>> t.k_charge() 8 >>> t = WeakTableau([[Integer(0)],[Integer(3),Integer(1)],[Integer(2),Integer(1)],[Integer(0),Integer(4)],[Integer(3),Integer(0)],[Integer(4),Integer(2)],[Integer(1),Integer(0)]], Integer(4), representation = 'factorized_permutation') >>> t.k_charge() 12
- shape_bounded()[source]¶
Return the shape of
selfas a \(k\)-bounded partition.When the tableau is straight, the outer shape is returned as a \(k\)-bounded partition. When the tableau is skew, the tuple of the outer and inner shape is returned as \(k\)-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])
>>> from sage.all import * >>> t = WeakTableau([[Integer(2)],[Integer(0),Integer(3)],[Integer(2),Integer(1),Integer(0)]], Integer(3), representation = 'factorized_permutation') >>> t.shape_bounded() [3, 2, 1] >>> t = WeakTableau([[Integer(2),Integer(0)],[Integer(3),Integer(2)]], Integer(3), inner_shape = [Integer(2)], representation = 'factorized_permutation') >>> t.shape_bounded() ([3, 2, 1], [2])
- shape_core()[source]¶
Return the shape of
selfas a \((k+1)\)-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])
>>> from sage.all import * >>> t = WeakTableau([[Integer(2)],[Integer(0),Integer(3)],[Integer(2),Integer(1),Integer(0)]], Integer(3), representation = 'factorized_permutation') >>> t.shape_core() [5, 2, 1] >>> t = WeakTableau([[Integer(2),Integer(0)],[Integer(3),Integer(2)]], Integer(3), inner_shape = [Integer(2)], representation = 'factorized_permutation') >>> t.shape() ([5, 2, 1], [2])
- static straighten_input(t, k)[source]¶
Straightens input.
INPUT:
t– list of reduced words or a list of elements in the Weyl group of type \(A_k^{(1)}\)k– positive integer
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)
>>> from sage.all import * >>> from sage.combinat.k_tableau import WeakTableau_factorized_permutation >>> WeakTableau_factorized_permutation.straighten_input([[Integer(2),Integer(0)],[Integer(3),Integer(2)],[Integer(1),Integer(0)]], Integer(3)) (s2*s0, s3*s2, s1*s0) >>> W = WeylGroup(['A',Integer(4),Integer(1)]) >>> WeakTableau_factorized_permutation.straighten_input([W.an_element(),W.an_element()], Integer(4)) (s0*s1*s2*s3*s4, s0*s1*s2*s3*s4)
- to_core_tableau()[source]¶
Return the weak \(k\)-tableau
selfwhere the shape of each restricted tableau is a \((k+1)\)-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
>>> from sage.all import * >>> t = WeakTableau([[Integer(0)], [Integer(3),Integer(1)], [Integer(2),Integer(1)], [Integer(0),Integer(4)], [Integer(3),Integer(0)], [Integer(4),Integer(2)], [Integer(1),Integer(0)]], Integer(4), representation = 'factorized_permutation'); t [s0, s3*s1, s2*s1, s0*s4, s3*s0, s4*s2, s1*s0] >>> 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]] >>> type(c) <class 'sage.combinat.k_tableau.WeakTableaux_core_with_category.element_class'> >>> t = WeakTableau([[]], Integer(4), representation = 'factorized_permutation'); t [1] >>> t.to_core_tableau() [] >>> from sage.combinat.k_tableau import WeakTableau_factorized_permutation >>> t = WeakTableau([[Integer(2),Integer(0)],[Integer(3),Integer(2)],[Integer(1),Integer(0)]], Integer(3), representation = 'factorized_permutation') >>> WeakTableau_factorized_permutation.from_core_tableau(t.to_core_tableau(), Integer(3)) [s2*s0, s3*s2, s1*s0] >>> t == WeakTableau_factorized_permutation.from_core_tableau(t.to_core_tableau(), Integer(3)) True >>> t = WeakTableau([[Integer(2),Integer(0)],[Integer(3),Integer(2)]], Integer(3), inner_shape = [Integer(2)], representation = 'factorized_permutation') >>> t.to_core_tableau() [[None, None, 1, 1, 2], [1, 2], [2]] >>> t == WeakTableau_factorized_permutation.from_core_tableau(t.to_core_tableau(), Integer(3)) True
- sage.combinat.k_tableau.WeakTableaux(k, shape, weight, representation='core')[source]¶
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]]
>>> from sage.all import * >>> T = WeakTableaux(Integer(3), [Integer(5),Integer(2),Integer(1)], [Integer(1),Integer(1),Integer(1),Integer(1),Integer(1),Integer(1)]) >>> 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]]] >>> T.cardinality() 4 >>> T = WeakTableaux(Integer(3), [[Integer(5),Integer(2),Integer(1)], [Integer(2)]], [Integer(1),Integer(1),Integer(1),Integer(1)]) >>> 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]]] >>> T = WeakTableaux(Integer(3), [Integer(3),Integer(2),Integer(1)], [Integer(1),Integer(1),Integer(1),Integer(1),Integer(1),Integer(1)], representation = 'bounded') >>> 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]]] >>> T = WeakTableaux(Integer(3), [[Integer(3),Integer(2),Integer(1)], [Integer(2)]], [Integer(1),Integer(1),Integer(1),Integer(1)], representation = 'bounded') >>> T.list() [[[None, None, 3], [1, 4], [2]], [[None, None, 1], [2, 4], [3]], [[None, None, 1], [2, 3], [4]]] >>> T = WeakTableaux(Integer(3), [Integer(5),Integer(2),Integer(1)], [Integer(1),Integer(1),Integer(1),Integer(1),Integer(1),Integer(1)], representation = 'factorized_permutation') >>> 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]] >>> T = WeakTableaux(Integer(3), [[Integer(5),Integer(2),Integer(1)], [Integer(2)]], [Integer(1),Integer(1),Integer(1),Integer(1)], representation = 'factorized_permutation') >>> T.list() [[s0, s3, s2, s3], [s0, s2, s3, s2], [s2, s0, s3, s2]]
- class sage.combinat.k_tableau.WeakTableaux_abstract[source]¶
Bases:
UniqueRepresentation,ParentAbstract class for the various parent classes of WeakTableaux.
- representation(representation='core')[source]¶
Return the analogue of
selfin the specified representation.INPUT:
representation– ‘core’, ‘bounded’, or ‘factorized_permutation’ (default:'core')
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)
>>> from sage.all import * >>> T = WeakTableaux(Integer(3), [Integer(5),Integer(2),Integer(1)], [Integer(1),Integer(1),Integer(1),Integer(1),Integer(1),Integer(1)]) >>> T._representation 'core' >>> T.representation('bounded') Bounded weak 3-Tableaux of (skew) 3-bounded shape [3, 2, 1] and weight (1, 1, 1, 1, 1, 1) >>> T.representation('factorized_permutation') Factorized permutation (skew) weak 3-Tableaux of shape [5, 2, 1] and weight (1, 1, 1, 1, 1, 1) >>> T = WeakTableaux(Integer(3), [Integer(3),Integer(2),Integer(1)], [Integer(1),Integer(1),Integer(1),Integer(1),Integer(1),Integer(1)], representation = 'bounded') >>> T._representation 'bounded' >>> T.representation('core') Core weak 3-Tableaux of (skew) core shape [5, 2, 1] and weight (1, 1, 1, 1, 1, 1) >>> T.representation('bounded') Bounded weak 3-Tableaux of (skew) 3-bounded shape [3, 2, 1] and weight (1, 1, 1, 1, 1, 1) >>> T.representation('bounded') == T True >>> T.representation('factorized_permutation') Factorized permutation (skew) weak 3-Tableaux of shape [5, 2, 1] and weight (1, 1, 1, 1, 1, 1) >>> T.representation('factorized_permutation') == T False >>> T = WeakTableaux(Integer(3), [Integer(5),Integer(2),Integer(1)], [Integer(1),Integer(1),Integer(1),Integer(1),Integer(1),Integer(1)], representation = 'factorized_permutation') >>> T._representation 'factorized_permutation' >>> T.representation('core') Core weak 3-Tableaux of (skew) core shape [5, 2, 1] and weight (1, 1, 1, 1, 1, 1) >>> T.representation('bounded') Bounded weak 3-Tableaux of (skew) 3-bounded shape [3, 2, 1] and weight (1, 1, 1, 1, 1, 1) >>> T.representation('factorized_permutation') Factorized permutation (skew) weak 3-Tableaux of shape [5, 2, 1] and weight (1, 1, 1, 1, 1, 1)
- shape()[source]¶
Return the shape of the tableaux of
self.When
selfis the class of straight tableaux, the outer shape is returned. Whenselfis 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 \((k+1)\)-cores. In the ‘bounded’ representation, the shapes are \(k\)-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])
>>> from sage.all import * >>> T = WeakTableaux(Integer(3), [Integer(5),Integer(2),Integer(2)], [Integer(2),Integer(2),Integer(2),Integer(1)]) >>> T.shape() [5, 2, 2] >>> T._shape ([5, 2, 2], []) >>> T = WeakTableaux(Integer(3), [[Integer(5),Integer(2),Integer(2)], [Integer(1)]], [Integer(2),Integer(1),Integer(2),Integer(1)]) >>> T.shape() ([5, 2, 2], [1]) >>> T = WeakTableaux(Integer(3), [Integer(3),Integer(2),Integer(2)], [Integer(2),Integer(2),Integer(2),Integer(1)], representation = 'bounded') >>> T.shape() [3, 2, 2] >>> T._shape ([3, 2, 2], []) >>> T = WeakTableaux(Integer(3), [[Integer(3),Integer(2),Integer(2)], [Integer(1)]], [Integer(2),Integer(1),Integer(2),Integer(1)], representation = 'bounded') >>> T.shape() ([3, 2, 2], [1]) >>> T = WeakTableaux(Integer(3), [Integer(4),Integer(1)], [Integer(2),Integer(2)], representation = 'factorized_permutation') >>> T.shape() [4, 1] >>> T._shape ([4, 1], []) >>> T = WeakTableaux(Integer(4), [[Integer(6),Integer(2),Integer(1)], [Integer(2)]], [Integer(2),Integer(1),Integer(1),Integer(1)], representation = 'factorized_permutation') >>> T.shape() ([6, 2, 1], [2])
- size()[source]¶
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
>>> from sage.all import * >>> T = WeakTableaux(Integer(3), [Integer(5),Integer(2),Integer(1)], [Integer(1),Integer(1),Integer(1),Integer(1),Integer(1),Integer(1)]) >>> T.size() 6 >>> T = WeakTableaux(Integer(3), [Integer(3),Integer(2),Integer(1)], [Integer(1),Integer(1),Integer(1),Integer(1),Integer(1),Integer(1)], representation = 'bounded') >>> T.size() 6 >>> T = WeakTableaux(Integer(4), [[Integer(6),Integer(2),Integer(1)], [Integer(2)]], [Integer(2),Integer(1),Integer(1),Integer(1)], 'factorized_permutation') >>> T.size() 5
- class sage.combinat.k_tableau.WeakTableaux_bounded(k, shape, weight)[source]¶
Bases:
WeakTableaux_abstractThe 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]]]
>>> from sage.all import * >>> T = WeakTableaux(Integer(3), [Integer(3),Integer(1)], [Integer(2),Integer(2)], representation = 'bounded') >>> T.list() [[[1, 1, 2], [2]]] >>> T = WeakTableaux(Integer(3), [[Integer(3),Integer(2),Integer(1)], [Integer(2)]], [Integer(1),Integer(1),Integer(1),Integer(1)], representation = 'bounded') >>> T.list() [[[None, None, 3], [1, 4], [2]], [[None, None, 1], [2, 4], [3]], [[None, None, 1], [2, 3], [4]]]
- Element[source]¶
alias of
WeakTableau_bounded
- class sage.combinat.k_tableau.WeakTableaux_core(k, shape, weight)[source]¶
Bases:
WeakTableaux_abstractThe 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]]]
>>> from sage.all import * >>> T = WeakTableaux(Integer(3), [Integer(4),Integer(1)], [Integer(2),Integer(2)]) >>> T.list() [[[1, 1, 2, 2], [2]]] >>> T = WeakTableaux(Integer(3), [[Integer(5),Integer(2),Integer(1)], [Integer(2)]], [Integer(1),Integer(1),Integer(1),Integer(1)]) >>> 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]]]
- Element[source]¶
alias of
WeakTableau_core
- circular_distance(cr, r)[source]¶
Return the shortest counterclockwise distance between
crandrmodulo \(k+1\).INPUT:
cr,r– nonnegative integers between \(0\) and \(k\)
OUTPUT: positive integer
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
>>> from sage.all import * >>> T = WeakTableaux(Integer(10), [], []) >>> T.circular_distance(Integer(8), Integer(6)) 2 >>> T.circular_distance(Integer(8), Integer(8)) 0 >>> T.circular_distance(Integer(8), Integer(9)) 10
- diag(c, ha)[source]¶
Return the number of diagonals strictly between cells
candhaof the same residue asc.INPUT:
c– a cell in the latticeha– another cell in the lattice with bigger row and smaller column than \(c\)
OUTPUT: nonnegative integer
EXAMPLES:
sage: T = WeakTableaux(4, [5,2,2], [2,2,2,1]) sage: T.diag((1,2),(4,0)) 0
>>> from sage.all import * >>> T = WeakTableaux(Integer(4), [Integer(5),Integer(2),Integer(2)], [Integer(2),Integer(2),Integer(2),Integer(1)]) >>> T.diag((Integer(1),Integer(2)),(Integer(4),Integer(0))) 0
- class sage.combinat.k_tableau.WeakTableaux_factorized_permutation(k, shape, weight)[source]¶
Bases:
WeakTableaux_abstractThe 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]]
>>> from sage.all import * >>> T = WeakTableaux(Integer(3), [Integer(4),Integer(1)], [Integer(2),Integer(2)], representation = 'factorized_permutation') >>> T.list() [[s3*s2, s1*s0]] >>> T = WeakTableaux(Integer(4), [[Integer(6),Integer(2),Integer(1)], [Integer(2)]], [Integer(2),Integer(1),Integer(1),Integer(1)], representation = 'factorized_permutation') >>> T.list() [[s0, s4, s3, s4*s2], [s0, s3, s4, s3*s2], [s3, s0, s4, s3*s2]]
- Element[source]¶
alias of
WeakTableau_factorized_permutation
- sage.combinat.k_tableau.intermediate_shapes(t)[source]¶
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: 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]]
>>> from sage.all import * >>> from sage.combinat.k_tableau import intermediate_shapes >>> t = WeakTableau([[Integer(1), Integer(1), Integer(2), Integer(2), Integer(3)], [Integer(2), Integer(3)], [Integer(3)]],Integer(3)) >>> intermediate_shapes(t) [[], [2], [4, 1], [5, 2, 1]] >>> t = WeakTableau([[None, None, Integer(2), Integer(3), Integer(4)], [Integer(1), Integer(4)], [Integer(2)]], Integer(3)) >>> intermediate_shapes(t) [[2], [2, 1], [3, 1, 1], [4, 1, 1], [5, 2, 1]]
- sage.combinat.k_tableau.nabs(v)[source]¶
Return the absolute value of
vorNone.INPUT:
v– either an integer orNone
OUTPUT: either a nonnegative integer or
NoneEXAMPLES:
sage: from sage.combinat.k_tableau import nabs sage: nabs(None) sage: nabs(-3) 3 sage: nabs(None)
>>> from sage.all import * >>> from sage.combinat.k_tableau import nabs >>> nabs(None) >>> nabs(-Integer(3)) 3 >>> nabs(None)