### Navigation

- index
- modules |
- next |
- previous |
- Combinatorics »
- Tableaux and Tableaux-like Objects »

# 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
      <BLANKLINE>
        .  .  1  0  0
        .  0  0  0
        1  0  2
      <BLANKLINE>
        .  .  0  0  0
        .  1  0  1
        2  0  0
      <BLANKLINE>

  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]

### Navigation

- index
- modules |
- next |
- previous |
- Combinatorics »
- Tableaux and Tableaux-like Objects »