Ribbon Tableaux#
- class sage.combinat.ribbon_tableau.MultiSkewTableau(parent, *args, **kwds)#
Bases:
sage.combinat.combinat.CombinatorialElement
A multi skew tableau which is a tuple of skew tableaux.
EXAMPLES:
sage: s = MultiSkewTableau([ [[None,1],[2,3]], [[1,2],[2]] ]) sage: s.size() 6 sage: s.weight() [2, 3, 1] sage: s.shape() [[2, 2] / [1], [2, 1] / []]
- inversion_pairs()#
Return a list of the inversion pairs of
self
.EXAMPLES:
sage: s = MultiSkewTableau([ [[2,3],[5,5]], [[1,1],[3,3]], [[2],[6]] ]) sage: s.inversion_pairs() [((0, (0, 0)), (1, (0, 0))), ((0, (1, 0)), (1, (0, 1))), ((0, (1, 1)), (1, (0, 0))), ((0, (1, 1)), (1, (1, 1))), ((0, (1, 1)), (2, (0, 0))), ((1, (0, 1)), (2, (0, 0))), ((1, (1, 1)), (2, (0, 0)))]
- inversions()#
Return the number of inversion pairs of
self
.EXAMPLES:
sage: t1 = SkewTableau([[1]]) sage: t2 = SkewTableau([[2]]) sage: MultiSkewTableau([t1,t1]).inversions() 0 sage: MultiSkewTableau([t1,t2]).inversions() 0 sage: MultiSkewTableau([t2,t2]).inversions() 0 sage: MultiSkewTableau([t2,t1]).inversions() 1 sage: s = MultiSkewTableau([ [[2,3],[5,5]], [[1,1],[3,3]], [[2],[6]] ]) sage: s.inversions() 7
- shape()#
Return the shape of
self
.EXAMPLES:
sage: s = SemistandardSkewTableaux([[2,2],[1]]).list() sage: a = MultiSkewTableau([s[0],s[1],s[2]]) sage: a.shape() [[2, 2] / [1], [2, 2] / [1], [2, 2] / [1]]
- size()#
Return the size of
self
, which is the sum of the sizes of the skew tableaux inself
.EXAMPLES:
sage: s = SemistandardSkewTableaux([[2,2],[1]]).list() sage: a = MultiSkewTableau([s[0],s[1],s[2]]) sage: a.size() 9
- weight()#
Return the weight of
self
.EXAMPLES:
sage: s = SemistandardSkewTableaux([[2,2],[1]]).list() sage: a = MultiSkewTableau([s[0],s[1],s[2]]) sage: a.weight() [5, 3, 1]
- class sage.combinat.ribbon_tableau.MultiSkewTableaux(category=None)#
Bases:
sage.structure.unique_representation.UniqueRepresentation
,sage.structure.parent.Parent
Multiskew tableaux.
- Element#
alias of
MultiSkewTableau
- class sage.combinat.ribbon_tableau.RibbonTableau(parent, st)#
Bases:
sage.combinat.skew_tableau.SkewTableau
A ribbon tableau.
A ribbon is a connected skew shape which does not contain any \(2 \times 2\) boxes. A ribbon tableau is a skew tableau whose shape is partitioned into ribbons, each of which is filled with identical entries.
EXAMPLES:
sage: rt = RibbonTableau([[None, 1],[2,3]]); rt [[None, 1], [2, 3]] sage: rt.inner_shape() [1] sage: rt.outer_shape() [2, 2] sage: rt = RibbonTableau([[None, None, 0, 0, 0], [None, 0, 0, 2], [1, 0, 1]]); rt.pp() . . 0 0 0 . 0 0 2 1 0 1
In the previous example, each ribbon is uniquely determined by a non-zero entry. The 0 entries are used to fill in the rest of the skew shape.
Note
Sanity checks are not performed; lists can contain any object.
sage: RibbonTableau(expr=[[1,1],[[5],[3,4],[1,2]]]) [[None, 1, 2], [None, 3, 4], [5]]
- length()#
Return the length of the ribbons into a ribbon tableau.
EXAMPLES:
sage: RibbonTableau([[None, 1],[2,3]]).length() 1 sage: RibbonTableau([[1,0],[2,0]]).length() 2
- to_word()#
Return a word obtained from a row reading of
self
.Warning
Unlike the
to_word
method on skew tableaux (which are a superclass of this), this method does not filter outNone
entries.EXAMPLES:
sage: R = RibbonTableau([[0, 0, 3, 0], [1, 1, 0], [2, 0, 4]]) sage: R.to_word() word: 2041100030
- class sage.combinat.ribbon_tableau.RibbonTableau_class(parent, st)#
Bases:
sage.combinat.ribbon_tableau.RibbonTableau
This exists solely for unpickling
RibbonTableau_class
objects.
- class sage.combinat.ribbon_tableau.RibbonTableaux#
Bases:
sage.structure.unique_representation.UniqueRepresentation
,sage.structure.parent.Parent
Ribbon tableaux.
A ribbon tableau is a skew tableau whose skew shape
shape
is tiled by ribbons of lengthlength
. The weightweight
is calculated from the labels on the ribbons.Note
Here we impose the condition that the ribbon tableaux are semistandard.
INPUT(Optional):
shape
– skew shape as a list of lists or an object of type SkewPartitionlength
– integer,shape
is partitioned into ribbons of lengthlength
weight
– list of integers, computed from the values of non-zero entries labeling the ribbons
EXAMPLES:
sage: RibbonTableaux([[2,1],[]], [1,1,1], 1) Ribbon tableaux of shape [2, 1] / [] and weight [1, 1, 1] with 1-ribbons sage: R = RibbonTableaux([[5,4,3],[2,1]], [2,1], 3) sage: for i in R: i.pp(); print("\n") . . 0 0 0 . 0 0 2 1 0 1 . . 1 0 0 . 0 0 0 1 0 2 . . 0 0 0 . 1 0 1 2 0 0
REFERENCES:
- vanLeeuwen91
Marc. A. A. van Leeuwen, Edge sequences, ribbon tableaux, and an action of affine permutations. Europe J. Combinatorics. 20 (1999). http://wwwmathlabo.univ-poitiers.fr/~maavl/pdf/edgeseqs.pdf
- Element#
alias of
RibbonTableau
- from_expr(l)#
Return a
RibbonTableau
from a MuPAD-Combinat expr for a skew tableau. The first list inexpr
is the inner shape of the skew tableau. The second list are the entries in the rows of the skew tableau from bottom to top.Provided primarily for compatibility with MuPAD-Combinat.
EXAMPLES:
sage: RibbonTableaux().from_expr([[1,1],[[5],[3,4],[1,2]]]) [[None, 1, 2], [None, 3, 4], [5]]
- options(*get_value, **set_value)#
Sets the global options for elements of the tableau, skew_tableau, and tableau tuple classes. The defaults are for tableau to be displayed as a list, latexed as a Young diagram using the English convention.
OPTIONS:
ascii_art
– (default:repr
) Controls the ascii art output for tableauxcompact
– minimal length ascii artrepr
– display using the diagram string representationtable
– display as a table
convention
– (default:English
) Sets the convention used for displaying tableaux and partitionsEnglish
– use the English conventionFrench
– use the French convention
display
– (default:list
) Controls the way in which tableaux are printedarray
– alias fordiagram
compact
– minimal length string representationdiagram
– display as Young diagram (similar topp()
ferrers_diagram
– alias fordiagram
list
– print tableaux as listsyoung_diagram
– alias fordiagram
latex
– (default:diagram
) Controls the way in which tableaux are latexedarray
– alias fordiagram
diagram
– as a Young diagramferrers_diagram
– alias fordiagram
list
– as a listyoung_diagram
– alias fordiagram
notation
– alternative name forconvention
Note
Changing the
convention
for tableaux also changes theconvention
for partitions.If no parameters are set, then the function returns a copy of the options dictionary.
EXAMPLES:
sage: T = Tableau([[1,2,3],[4,5]]) sage: T [[1, 2, 3], [4, 5]] sage: Tableaux.options.display="array" sage: T 1 2 3 4 5 sage: Tableaux.options.convention="french" sage: T 4 5 1 2 3
Changing the
convention
for tableaux also changes theconvention
for partitions and vice versa:sage: P = Partition([3,3,1]) sage: print(P.ferrers_diagram()) * *** *** sage: Partitions.options.convention="english" sage: print(P.ferrers_diagram()) *** *** * sage: T 1 2 3 4 5
The ASCII art can also be changed:
sage: t = Tableau([[1,2,3],[4,5]]) sage: ascii_art(t) 1 2 3 4 5 sage: Tableaux.options.ascii_art = "table" sage: ascii_art(t) +---+---+---+ | 1 | 2 | 3 | +---+---+---+ | 4 | 5 | +---+---+ sage: Tableaux.options.ascii_art = "compact" sage: ascii_art(t) |1|2|3| |4|5| sage: Tableaux.options._reset()
See
GlobalOptions
for more features of these options.
- class sage.combinat.ribbon_tableau.RibbonTableaux_shape_weight_length(shape, weight, length)#
Bases:
sage.combinat.ribbon_tableau.RibbonTableaux
Ribbon tableaux of a given shape, weight, and length.
- cardinality()#
Return the cardinality of
self
.EXAMPLES:
sage: RibbonTableaux([[2,1],[]],[1,1,1],1).cardinality() 2 sage: RibbonTableaux([[2,2],[]],[1,1],2).cardinality() 2 sage: RibbonTableaux([[4,3,3],[]],[2,1,1,1],2).cardinality() 5
- class sage.combinat.ribbon_tableau.SemistandardMultiSkewTableaux(shape, weight)#
Bases:
sage.combinat.ribbon_tableau.MultiSkewTableaux
Semistandard multi skew tableaux.
A multi skew tableau is a \(k\)-tuple of skew tableaux of given shape with a specified total weight.
EXAMPLES:
sage: S = SemistandardMultiSkewTableaux([ [[2,1],[]], [[2,2],[1]] ], [2,2,2]); S Semistandard multi skew tableaux of shape [[2, 1] / [], [2, 2] / [1]] and weight [2, 2, 2] sage: S.list() [[[[1, 1], [2]], [[None, 2], [3, 3]]], [[[1, 2], [2]], [[None, 1], [3, 3]]], [[[1, 3], [2]], [[None, 2], [1, 3]]], [[[1, 3], [2]], [[None, 1], [2, 3]]], [[[1, 1], [3]], [[None, 2], [2, 3]]], [[[1, 2], [3]], [[None, 2], [1, 3]]], [[[1, 2], [3]], [[None, 1], [2, 3]]], [[[2, 2], [3]], [[None, 1], [1, 3]]], [[[1, 3], [3]], [[None, 1], [2, 2]]], [[[2, 3], [3]], [[None, 1], [1, 2]]]]
- sage.combinat.ribbon_tableau.cospin_polynomial(part, weight, length)#
Return the cospin polynomial associated to
part
,weight
, andlength
.EXAMPLES:
sage: from sage.combinat.ribbon_tableau import cospin_polynomial sage: cospin_polynomial([6,6,6],[4,2],3) t^4 + t^3 + 2*t^2 + t + 1 sage: cospin_polynomial([3,3,3,2,1], [3,1], 3) 1 sage: cospin_polynomial([3,3,3,2,1], [2,2], 3) t + 1 sage: cospin_polynomial([3,3,3,2,1], [2,1,1], 3) t^2 + 2*t + 2 sage: cospin_polynomial([3,3,3,2,1], [1,1,1,1], 3) t^3 + 3*t^2 + 5*t + 3 sage: cospin_polynomial([5,4,3,2,1,1,1], [2,2,1], 3) 2*t^2 + 6*t + 2 sage: cospin_polynomial([[6]*6, [3,3]], [4,4,2], 3) 3*t^4 + 6*t^3 + 9*t^2 + 5*t + 3
- sage.combinat.ribbon_tableau.count_rec(nexts, current, part, weight, length)#
INPUT:
nexts, current, part
– skew partitionsweight
– non-negative integer listlength
– integer
- sage.combinat.ribbon_tableau.graph_implementation_rec(skp, weight, length, function)#
- sage.combinat.ribbon_tableau.insertion_tableau(skp, perm, evaluation, tableau, length)#
INPUT:
skp
– skew partitionsperm, evaluation
– non-negative integerstableau
– skew tableaulength
– integer
- sage.combinat.ribbon_tableau.list_rec(nexts, current, part, weight, length)#
INPUT:
nexts, current, part
– skew partitionsweight
– non-negative integer listlength
– integer
- sage.combinat.ribbon_tableau.spin_polynomial(part, weight, length)#
Returns the spin polynomial associated to
part
,weight
, andlength
.EXAMPLES:
sage: from sage.combinat.ribbon_tableau import spin_polynomial sage: spin_polynomial([6,6,6],[4,2],3) t^6 + t^5 + 2*t^4 + t^3 + t^2 sage: spin_polynomial([6,6,6],[4,1,1],3) t^6 + 2*t^5 + 3*t^4 + 2*t^3 + t^2 sage: spin_polynomial([3,3,3,2,1], [2,2], 3) t^(7/2) + t^(5/2) sage: spin_polynomial([3,3,3,2,1], [2,1,1], 3) 2*t^(7/2) + 2*t^(5/2) + t^(3/2) sage: spin_polynomial([3,3,3,2,1], [1,1,1,1], 3) 3*t^(7/2) + 5*t^(5/2) + 3*t^(3/2) + sqrt(t) sage: spin_polynomial([5,4,3,2,1,1,1], [2,2,1], 3) 2*t^(9/2) + 6*t^(7/2) + 2*t^(5/2) sage: spin_polynomial([[6]*6, [3,3]], [4,4,2], 3) 3*t^9 + 5*t^8 + 9*t^7 + 6*t^6 + 3*t^5
- sage.combinat.ribbon_tableau.spin_polynomial_square(part, weight, length)#
Returns the spin polynomial associated with
part
,weight
, andlength
, with the substitution \(t \to t^2\) made.EXAMPLES:
sage: from sage.combinat.ribbon_tableau import spin_polynomial_square sage: spin_polynomial_square([6,6,6],[4,2],3) t^12 + t^10 + 2*t^8 + t^6 + t^4 sage: spin_polynomial_square([6,6,6],[4,1,1],3) t^12 + 2*t^10 + 3*t^8 + 2*t^6 + t^4 sage: spin_polynomial_square([3,3,3,2,1], [2,2], 3) t^7 + t^5 sage: spin_polynomial_square([3,3,3,2,1], [2,1,1], 3) 2*t^7 + 2*t^5 + t^3 sage: spin_polynomial_square([3,3,3,2,1], [1,1,1,1], 3) 3*t^7 + 5*t^5 + 3*t^3 + t sage: spin_polynomial_square([5,4,3,2,1,1,1], [2,2,1], 3) 2*t^9 + 6*t^7 + 2*t^5 sage: spin_polynomial_square([[6]*6, [3,3]], [4,4,2], 3) 3*t^18 + 5*t^16 + 9*t^14 + 6*t^12 + 3*t^10
- sage.combinat.ribbon_tableau.spin_rec(t, nexts, current, part, weight, length)#
Routine used for constructing the spin polynomial.
INPUT:
weight
– list of non-negative integerslength
– the length of the ribbons we’re tiling witht
– the variable
EXAMPLES:
sage: from sage.combinat.ribbon_tableau import spin_rec sage: sp = SkewPartition sage: t = ZZ['t'].gen() sage: spin_rec(t, [], [[[], [3, 3]]], sp([[2, 2, 2], []]), [2], 3) [t^4] sage: spin_rec(t, [[0], [t^4]], [[[2, 1, 1, 1, 1], [0, 3]], [[2, 2, 2], [3, 0]]], sp([[2, 2, 2, 2, 1], []]), [2, 1], 3) [t^5] sage: spin_rec(t, [], [[[], [3, 3, 0]]], sp([[3, 3], []]), [2], 3) [t^2] sage: spin_rec(t, [[t^4], [t^3], [t^2]], [[[2, 2, 2], [0, 0, 3]], [[3, 2, 1], [0, 3, 0]], [[3, 3], [3, 0, 0]]], sp([[3, 3, 3], []]), [2, 1], 3) [t^6 + t^4 + t^2] sage: spin_rec(t, [[t^5], [t^4], [t^6 + t^4 + t^2]], [[[2, 2, 2, 2, 1], [0, 0, 3]], [[3, 3, 1, 1, 1], [0, 3, 0]], [[3, 3, 3], [3, 0, 0]]], sp([[3, 3, 3, 2, 1], []]), [2, 1, 1], 3) [2*t^7 + 2*t^5 + t^3]