Ribbon Tableaux

sage.combinat.ribbon_tableau.MultiSkewTableau(x)

Returns a multi skew tableau object 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], []]]
class sage.combinat.ribbon_tableau.MultiSkewTableau_class(l)

Bases: sage.combinat.combinat.CombinatorialObject

CombinatorialObject provides a thin wrapper around a list. The main differences are that __setitem__ is disabled so that CombinatorialObjects are shallowly immutable, and the intention is that they are semantically immutable.

Because of this, CombinatorialObjects provide a __hash__ function which computes the hash of the string representation of a list and the hash of its parent’s class. Thus, each CombinatorialObject should have a unique string representation.

INPUT:

  • l - a list or any object that can be convert to a list by

    list

EXAMPLES:

sage: c = CombinatorialObject([1,2,3])
sage: c == loads(dumps(c))
True
sage: c._list
[1, 2, 3]
sage: c._hash is None
True
inversion_pairs()

Returns 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()

Returns 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()

Returns 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()

Returns 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()

Returns 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]
sage.combinat.ribbon_tableau.RibbonTableau(rt=None, expr=None)

Returns a ribbon tableau object.

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: RibbonTableau(expr=[[1,1],[[5],[3,4],[1,2]]])
[[None, 1, 2], [None, 3, 4], [5]]
class sage.combinat.ribbon_tableau.RibbonTableau_class(t)

Bases: sage.combinat.skew_tableau.SkewTableau_class

TESTS:

sage: st = SkewTableau([[None, 1],[2,3]])
sage: st == loads(dumps(st))
True
evaluation()

Returns 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()

Returns 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()

Returns 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
sage.combinat.ribbon_tableau.RibbonTableaux(shape, weight, length)

Returns the combinatorial class of ribbon tableaux of skew shape shape and weight weight tiled by ribbons of length length.

EXAMPLES:

sage: RibbonTableaux([[2,1],[]],[1,1,1],1)
Ribbon tableaux of shape [[2, 1], []] and weight [1, 1, 1] with 1-ribbons
class sage.combinat.ribbon_tableau.RibbonTableaux_shapeweightlength(shape, weight, length)

Bases: sage.combinat.combinat.CombinatorialClass

EXAMPLES:

sage: r = RibbonTableaux([[2,1],[]],[1,1,1],1)
sage: r == loads(dumps(r))
True
cardinality()

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
list()

EXAMPLES:

sage: RibbonTableaux([[2,1],[]],[1,1,1],1).list()
[[[1, 3], [2]], [[1, 2], [3]]]
sage: RibbonTableaux([[2,2],[]],[1,1],2).list()
[[[0, 0], [1, 2]], [[1, 0], [2, 0]]]
sage.combinat.ribbon_tableau.SemistandardMultiSkewTableaux(shape, weight)

Returns the combinatorial class of semistandard multi skew tableaux. A multi skew tableau is a k-tuple of skew tableaux of givens 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]]]]
class sage.combinat.ribbon_tableau.SemistandardMultiSkewTtableaux_shapeweight(shape, weight)

Bases: sage.combinat.combinat.CombinatorialClass

TESTS:

sage: s = SemistandardMultiSkewTableaux([ [[2,1],[]], [[2,2],[1]] ], [2,2,2])
sage: s == loads(dumps(s))
True
list()

EXAMPLES:

sage: sp = SkewPartitions(3).list()
sage: SemistandardMultiSkewTableaux([SkewPartition([[1, 1, 1], []]), SkewPartition([[3], []])],[2,2,2]).list()
[[[[1], [2], [3]], [[1, 2, 3]]]]
sage: a = SkewPartition([[8,7,6,5,1,1],[2,1,1]])
sage: weight = [3,3,2]
sage: k = 3
sage: s = SemistandardMultiSkewTableaux(a.quotient(k),weight)
sage: len(s.list())
34
sage: RibbonTableaux(a,weight,k).cardinality()
34
sage.combinat.ribbon_tableau.cospin_polynomial(part, weight, length)

Returns 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)

Returns 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: import sage.combinat.ribbon_tableau as ribbon_tableau
sage: sage.combinat.ribbon_tableau.from_expr([[1,1],[[5],[3,4],[1,2]]])
[[None, 1, 2], [None, 3, 4], [5]]
sage: type(_)
<class 'sage.combinat.ribbon_tableau.RibbonTableau_class'>
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 -> 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