Ribbon Tableaux

class sage.combinat.ribbon_tableau.MultiSkewTableau(parent, x)

Bases: sage.combinat.combinat.CombinatorialObject, sage.structure.element.Element

A multi skew tableau which is a tuple of skew tableau.

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 in self.

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.parent.Parent, sage.structure.unique_representation.UniqueRepresentation

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 skew tableau such that the skew shape does not contain any \(2 \times 2\) boxes. A ribbon tableau is a skew tableau that is partitioned into ribbons.

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 anyobject.

sage: RibbonTableau(expr=[[1,1],[[5],[3,4],[1,2]]])
[[None, 1, 2], [None, 3, 4], [5]]
evaluation()

Return the evaluation of the ribbon tableau.

EXAMPLES:

sage: RibbonTableau([[0, 0, 3, 0], [1, 1, 0], [2, 0, 4]]).evaluation()
[2, 1, 1, 1]
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.

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.RibbonTableaux

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

Ribbon tableaux.

A ribbon tableau is a skew tableau whose skew shape shape is tiled by ribbons of length length. The weight weight is calculated from the labels on the ribbons.

Note

Here we inpose the condition that the ribbon tableaux are semistandard.

INPUT(Optional):

  • shape – skew shape as a list of lists or an object of type SkewPartition
  • length – integer, shape is partitioned into ribbons of length length
  • 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
  .  .  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

REFRENCES:

[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 in expr 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]]
global_options(*get_value, **set_value)

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

OPTIONS:

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

Note

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

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

EXAMPLES:

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

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

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

The ASCII art can also be changed:

sage: t = Tableau([[1,2,3],[4,5]])
sage: ascii_art(t)
  1  2  3
  4  5
sage: Tableaux.global_options(ascii_art="normal")
sage: ascii_art(t)
+---+---+
| 4 | 5 |
+---+---+---+
| 1 | 2 | 3 |
+---+---+---+
sage: Tableaux.global_options(ascii_art="compact")
sage: ascii_art(t)
|4|5|
|1|2|3|
sage: Tableaux.global_options.reset()

See GlobalOptions for more features of these options.

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

TESTS:

sage: RibbonTableaux([6,6,6], [4,2], 3).cardinality()
6
sage: RibbonTableaux([3,3,3,2,1], [3,1], 3).cardinality()
1
sage: RibbonTableaux([3,3,3,2,1], [2,2], 3).cardinality()
2
sage: RibbonTableaux([3,3,3,2,1], [2,1,1], 3).cardinality()
5
sage: RibbonTableaux([3,3,3,2,1], [1,1,1,1], 3).cardinality()
12
sage: RibbonTableaux([5,4,3,2,1], [2,2,1], 3).cardinality()
10
sage: RibbonTableaux([8,7,6,5,1,1], [3,2,2,1], 3).cardinality()
85
sage: RibbonTableaux([5,4,3,2,1,1,1], [2,2,1], 3).cardinality()
10
sage: RibbonTableaux([7,7,7,2,1,1], [3,2,0,1,1], 3).cardinality()
25

Weights with some zeros in the middle and end:

sage: RibbonTableaux([3,3,3], [0,1,0,2,0], 3).cardinality()
3
sage: RibbonTableaux([3,3,3], [1,0,1,0,1,0,0,0], 3).cardinality()
6
sage.combinat.ribbon_tableau.RibbonTableaux_shapeweightlength(shape, weight, length)

EXAMPLES:

sage: sage.combinat.ribbon_tableau.RibbonTableaux_shapeweightlength([[2,1],[]], [1,1,1], 1)
doctest:...: DeprecationWarning: this class is deprecated. Use RibbonTableaux instead
See http://trac.sagemath.org/14101 for details.
Ribbon tableaux of shape [2, 1] / [] and weight [1, 1, 1] with 1-ribbons
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.SemistandardMultiSkewTtableaux_shapeweight(shape, weight)

EXAMPLES:

sage: sage.combinat.ribbon_tableau.SemistandardMultiSkewTtableaux_shapeweight([ [[2,1],[]], [[2,2],[1]] ], [2,2,2])
doctest:...: DeprecationWarning: this class is deprecated. Use SemistandardMultiSkewTableaux instead
See http://trac.sagemath.org/14101 for details.
Semistandard multi skew tableaux of shape [[2, 1] / [], [2, 2] / [1]] and weight [2, 2, 2]
sage.combinat.ribbon_tableau.cospin_polynomial(part, weight, length)

Return the cospin polynomial associated to part, weight, and length.

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 partitions
  • weight – non-negative integer list
  • length – integer

TESTS:

sage: from sage.combinat.ribbon_tableau import count_rec
sage: count_rec([], [], [[2, 1, 1], []], [2], 2)
[0]
sage: count_rec([[0], [1]], [[[2, 1, 1], [0, 0, 2, 0]], [[4], [2, 0, 0, 0]]], [[4, 1, 1], []], [2, 1], 2)
[1]
sage: count_rec([], [[[], [2, 2]]], [[2, 2], []], [2], 2)
[1]
sage: count_rec([], [[[], [2, 0, 2, 0]]], [[4], []], [2], 2)
[1]
sage: count_rec([[1], [1]], [[[2, 2], [0, 0, 2, 0]], [[4], [2, 0, 0, 0]]], [[4, 2], []], [2, 1], 2)
[2]
sage: count_rec([[1], [1], [2]], [[[2, 2, 2], [0, 0, 2, 0]], [[4, 1, 1], [0, 2, 0, 0]], [[4, 2], [2, 0, 0, 0]]], [[4, 2, 2], []], [2, 1, 1], 2)
[4]
sage: count_rec([[4], [1]], [[[4, 2, 2], [0, 0, 2, 0]], [[4, 3, 1], [0, 2, 0, 0]]], [[4, 3, 3], []], [2, 1, 1, 1], 2)
[5]
sage.combinat.ribbon_tableau.from_expr(l)

Deprecated in trac ticket #14101. Use instead RibbonTableaux.from_expr().

EXAMPLES:

sage: sage.combinat.ribbon_tableau.from_expr([[1,1],[[5],[3,4],[1,2]]])
doctest:...: DeprecationWarning: from_expr is deprecated. Use RibbonTableaux().from_expr instead
See http://trac.sagemath.org/14101 for details.
[[None, 1, 2], [None, 3, 4], [5]]
sage.combinat.ribbon_tableau.graph_implementation_rec(skp, weight, length, function)

TESTS:

sage: from sage.combinat.ribbon_tableau import graph_implementation_rec, list_rec
sage: graph_implementation_rec(SkewPartition([[1], []]), [1], 1, list_rec)
[[[], [[1]]]]
sage: graph_implementation_rec(SkewPartition([[2, 1], []]), [1, 2], 1, list_rec)
[[[], [[2], [1, 2]]]]
sage: graph_implementation_rec(SkewPartition([[], []]), [0], 1, list_rec)
[[[], []]]
sage.combinat.ribbon_tableau.insertion_tableau(skp, perm, evaluation, tableau, length)

INPUT:

  • skp – skew partitions
  • perm, evaluation – non-negative integers
  • tableau – skew tableau
  • length – integer

TESTS:

sage: from sage.combinat.ribbon_tableau import insertion_tableau
sage: insertion_tableau([[1], []], [1], 1, [[], []], 1)
[[], [[1]]]
sage: insertion_tableau([[2, 1], []], [1, 1], 2, [[], [[1]]], 1)
[[], [[2], [1, 2]]]
sage: insertion_tableau([[2, 1], []], [0, 0], 3, [[], [[2], [1, 2]]], 1)
[[], [[2], [1, 2]]]
sage: insertion_tableau([[1, 1], []], [1], 2, [[], [[1]]], 1)
[[], [[2], [1]]]
sage: insertion_tableau([[2], []], [0, 1], 2, [[], [[1]]], 1)
[[], [[1, 2]]]
sage: insertion_tableau([[2, 1], []], [0, 1], 3, [[], [[2], [1]]], 1)
[[], [[2], [1, 3]]]
sage: insertion_tableau([[1, 1], []], [2], 1, [[], []], 2)
[[], [[1], [0]]]
sage: insertion_tableau([[2], []], [2, 0], 1, [[], []], 2)
[[], [[1, 0]]]
sage: insertion_tableau([[2, 2], []], [0, 2], 2, [[], [[1], [0]]], 2)
[[], [[1, 2], [0, 0]]]
sage: insertion_tableau([[2, 2], []], [2, 0], 2, [[], [[1, 0]]], 2)
[[], [[2, 0], [1, 0]]]
sage: insertion_tableau([[2, 2], [1]], [3, 0], 1, [[], []], 3)
[[1], [[1, 0], [0]]]
sage.combinat.ribbon_tableau.list_rec(nexts, current, part, weight, length)

INPUT:

  • nexts, current, part – skew partitions
  • weight – non-negative integer list
  • length – integer

TESTS:

sage: from sage.combinat.ribbon_tableau import list_rec
sage: list_rec([], [[[], [1]]], [[1], []], [1], 1)
[[[], [[1]]]]
sage: list_rec([[[[], [[1]]]]], [[[1], [1, 1]]], [[2, 1], []], [1, 2], 1)
[[[], [[2], [1, 2]]]]
sage: list_rec([], [[[1], [3, 0]]], [[2, 2], [1]], [1], 3)
[[[1], [[1, 0], [0]]]]
sage: list_rec([[[[], [[2]]]]], [[[1], [1, 1]]], [[2, 1], []], [0, 1, 2], 1)
[[[], [[3], [2, 3]]]]
sage: list_rec([], [[[], [2]]], [[1, 1], []], [1], 2)
[[[], [[1], [0]]]]
sage: list_rec([], [[[], [2, 0]]], [[2], []], [1], 2)
[[[], [[1, 0]]]]
sage: list_rec([[[[], [[1], [0]]]], [[[], [[1, 0]]]]], [[[1, 1], [0, 2]], [[2], [2, 0]]], [[2, 2], []], [1, 1], 2)
[[[], [[1, 2], [0, 0]]], [[], [[2, 0], [1, 0]]]]
sage: list_rec([], [[[], [2, 2]]], [[2, 2], []], [2], 2)
[[[], [[1, 1], [0, 0]]]]
sage: list_rec([], [[[], [1, 1]]], [[2], []], [2], 1)
[[[], [[1, 1]]]]
sage: list_rec([[[[], [[1, 1]]]]], [[[2], [1, 1]]], [[2, 2], []], [2, 2], 1)
[[[], [[2, 2], [1, 1]]]]
sage.combinat.ribbon_tableau.spin_polynomial(part, weight, length)

Returns the spin polynomial associated to part, weight, and length.

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, and length, 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 integers
  • length – the length of the ribbons we’re tiling with
  • t – 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]

Previous topic

Ribbons

Next topic

TableauTuples

This Page