Shifted primed tableaux

AUTHORS:

• Kirill Paramonov (2017-08-18): initial implementation

• Chaman Agrawal (2019-08-12): add parameter to allow primed diagonal entry

class sage.combinat.shifted_primed_tableau.CrystalElementShiftedPrimedTableau(parent, T, skew=None, check=True, preprocessed=False)

Bases: sage.combinat.shifted_primed_tableau.ShiftedPrimedTableau

Class for elements of crystals.ShiftedPrimedTableau.

e(ind)

Compute the action of the crystal operator \(e_i\) on a shifted primed tableau using cases from the papers [HPS2017] and [AO2018].

INPUT:

• ind – an element in the index set of the crystal

OUTPUT:

Primed tableau or None.

EXAMPLES:

sage: SPT = ShiftedPrimedTableaux([5,4,2])
sage: t = SPT([[1,1,1,'2p','3p'], [2,'3p',3,3],[3,4]])
sage: t.pp()
1  1  1  2' 3'
   2  3' 3  3
      3  4
sage: s = t.e(2)
sage: s.pp()
1  1  1  2' 3'
   2  2  3  3
      3  4
sage: t == s.f(2)
True

sage: SPT = ShiftedPrimedTableaux([2,1])
sage: t = SPT([[2,'3p'],[3]])
sage: t.e(-1).pp()
1  3'
   3
sage: t.e(1).pp()
1  3'
   3
sage: t.e(2).pp()
2  2
   3

sage: r = SPT([[2, 2],[3]])
sage: r.e(-1).pp()
1  2
   3
sage: r.e(1).pp()
1  2
   3
sage: r.e(2) is None
True

sage: r = SPT([[1,'3p'],[3]])
sage: r.e(-1) is None
True
sage: r.e(1) is None
True
sage: r.e(2).pp()
1  2'
   3
sage: r = SPT([[1,'2p'],[3]])
sage: r.e(-1).pp()
1  1
   3
sage: r.e(1) is None
True
sage: r.e(2).pp()
1  2'
   2
sage: t = SPT([[2,'3p'],[3]])
sage: t.e(-1).e(2).e(2).e(-1) == t.e(2).e(1).e(1).e(2)
True
sage: t.e(-1).e(2).e(2).e(-1).pp()
1  1
   2
sage: all(t.e(-1).e(2).e(2).e(-1).e(i) is None for i in {-1, 1, 2})
True

sage: SPT = ShiftedPrimedTableaux([4])
sage: t = SPT([[2,2,2,2]])
sage: t.e(-1).pp()
1  2  2  2
sage: t.e(1).pp()
1  2  2  2
sage: t.e(-1).e(-1) is None
True
sage: t.e(1).e(1).pp()
1  1  2  2

f(ind)

Compute the action of the crystal operator \(f_i\) on a shifted primed tableau using cases from the papers [HPS2017] and [AO2018].

INPUT:

• ind – element in the index set of the crystal

OUTPUT:

Primed tableau or None.

EXAMPLES:

sage: SPT = ShiftedPrimedTableaux([5,4,2])
sage: t = SPT([[1,1,1,1,'3p'],[2,2,2,'3p'],[3,3]])
sage: t.pp()
1  1  1  1  3'
   2  2  2  3'
      3  3
sage: s = t.f(2)
sage: s is None
True

sage: t = SPT([[1,1,1,'2p','3p'],[2,2,3,3],[3,4]])
sage: t.pp()
1  1  1  2' 3'
   2  2  3  3
      3  4
sage: s = t.f(2)
sage: s.pp()
1  1  1  2' 3'
   2  3' 3  3
      3  4

sage: SPT = ShiftedPrimedTableaux([2,1])
sage: t = SPT([[1,1],[2]])
sage: t.f(-1).pp()
1  2'
   2
sage: t.f(1).pp()
1  2'
   2
sage: t.f(2).pp()
1  1
   3

sage: r = SPT([[1,'2p'],[2]])
sage: r.f(-1) is None
True
sage: r.f(1) is None
True
sage: r.f(2).pp()
1  2'
   3

sage: r = SPT([[1,1],[3]])
sage: r.f(-1).pp()
1  2'
   3
sage: r.f(1).pp()
1  2
   3
sage: r.f(2) is None
True

sage: r = SPT([[1,2],[3]])
sage: r.f(-1).pp()
2  2
   3
sage: r.f(1).pp()
2  2
   3
sage: r.f(2) is None
True

sage: t = SPT([[1,1],[2]])
sage: t.f(-1).f(2).f(2).f(-1) == t.f(2).f(1).f(-1).f(2)
True
sage: t.f(-1).f(2).f(2).f(-1).pp()
2  3'
   3
sage: all(t.f(-1).f(2).f(2).f(-1).f(i) is None for i in {-1, 1, 2})
True

sage: SPT = ShiftedPrimedTableaux([4])
sage: t = SPT([[1,1,1,1]])
sage: t.f(-1).pp()
1  1  1  2'
sage: t.f(1).pp()
1  1  1  2
sage: t.f(-1).f(-1) is None
True
sage: t.f(1).f(-1).pp()
1  1  2' 2
sage: t.f(1).f(1).pp()
1  1  2  2
sage: t.f(1).f(1).f(-1).pp()
1  2' 2  2
sage: t.f(1).f(1).f(1).pp()
1  2  2  2
sage: t.f(1).f(1).f(1).f(-1).pp()
2  2  2  2
sage: t.f(1).f(1).f(1).f(1).pp()
2  2  2  2
sage: t.f(1).f(1).f(1).f(1).f(-1) is None
True

is_highest_weight(index_set=None)

Return whether self is a highest weight element of the crystal.

An element is highest weight if it vanishes under all crystal operators \(e_i\).

EXAMPLES:

sage: SPT = ShiftedPrimedTableaux([5,4,2])
sage: t = SPT([(1, 1, 1, 1, 1), (2, 2, 2, "3p"), (3, 3)])
sage: t.is_highest_weight()
True

sage: SPT = ShiftedPrimedTableaux([5,4])
sage: s = SPT([(1, 1, 1, 1, 1), (2, 2, "3p", 3)])
sage: s.is_highest_weight(index_set=[1])
True

reading_word()

Return the reading word of self.

The reading word of a shifted primed tableau is constructed as follows:

1. List all primed entries in the tableau, column by column, in decreasing order within each column, moving from the rightmost column to the left, and with all the primes removed (i.e. all entries are increased by half a unit).

2. Then list all unprimed entries, row by row, in increasing order within each row, moving from the bottommost row to the top.

EXAMPLES:

sage: SPT = ShiftedPrimedTableaux([4,2])
sage: t = SPT([[1,'2p',2,2],[2,'3p']])
sage: t.reading_word()
[3, 2, 2, 1, 2, 2]

weight()

Return the weight of self.

The weight of a shifted primed tableau is defined to be the vector with \(i\)-th component equal to the number of entries \(i\) and \(i'\) in the tableau.

EXAMPLES:

sage: t = ShiftedPrimedTableau([[1,'2p',2,2],[2,'3p']])
sage: t.weight()
(1, 4, 1)

class sage.combinat.shifted_primed_tableau.PrimedEntry(entry=None, double=None)

Bases: sage.structure.sage_object.SageObject

The class of entries in shifted primed tableaux.

An entry in a shifted primed tableau is an element in the alphabet \(\{1' < 1 < 2' < 2 < \cdots < n' < n\}\). The difference between two elements \(i\) and \(i-1\) counts as a whole unit, whereas the difference between \(i\) and \(i'\) counts as half a unit. Internally, we represent an unprimed element \(x\) as \(2x\) and the primed elements as the corresponding odd integer that respects the total order.

INPUT:

• entry – a half integer or a string of an integer possibly ending in p or '

• double – the doubled value

decrease_half()

Decrease self by half a unit.

decrease_one()

Decrease self by one unit.

increase_half()

Increase self by half a unit.

increase_one()

Increase self by one unit.

integer()

Return the corresponding integer \(i\) for primed entries of the form \(i\) or \(i'\).

is_primed()

Checks if self is a primed element.

is_unprimed()

Checks if self is an unprimed element.

primed()

Prime self if it is an unprimed element.

unprimed()

Unprime self if it is a primed element.

class sage.combinat.shifted_primed_tableau.ShiftedPrimedTableau(parent, T, skew=None, check=True, preprocessed=False)

Bases: sage.structure.list_clone.ClonableArray

A shifted primed tableau.

A primed tableau is a tableau of shifted shape in the alphabet \(X' = \{1' < 1 < 2' < 2 < \cdots < n' < n\}\) such that

1. the entries are weakly increasing along rows and columns;

2. a row cannot have two repeated primed elements, and a column cannot have two repeated non-primed elements;

Skew shape of the shifted primed tableaux is specified either with an optional argument skew or with None entries.

Primed entries in the main diagonal can be allowed with the optional boolean parameter primed_diagonal``(default: ``False).

EXAMPLES:

sage: T = ShiftedPrimedTableaux([4,2])
sage: T([[1,"2'","3'",3],[2,"3'"]])[1]
(2, 3')
sage: t = ShiftedPrimedTableau([[1,"2p",2.5,3],[2,2.5]])
sage: t[1]
(2, 3')
sage: ShiftedPrimedTableau([["2p",2,3],["2p","3p"],[2]], skew=[2,1])
[(None, None, 2', 2, 3), (None, 2', 3'), (2,)]
sage: ShiftedPrimedTableau([[None,None,"2p"],[None,"2p"]])
[(None, None, 2'), (None, 2')]
sage: T = ShiftedPrimedTableaux([4,2], primed_diagonal=True)
sage: T([[1,"2'","3'",3],["2'","3'"]])[1] # With primed diagonal entry
(2', 3')

check()

Check that self is a valid primed tableau.

EXAMPLES:

sage: T = ShiftedPrimedTableaux([4,2])
sage: t = T([[1,'2p',2,2],[2,'3p']])
sage: t.check()
sage: s = ShiftedPrimedTableau([["2p",2,3],["2p"],[2]],skew=[2,1])
sage: s.check()
sage: t = T([['1p','2p',2,2],[2,'3p']])
Traceback (most recent call last):
...
ValueError: [['1p', '2p', 2, 2], [2, '3p']] is not an element of
 Shifted Primed Tableaux of shape [4, 2]

sage: T = ShiftedPrimedTableaux([4,2], primed_diagonal=True)
sage: t = T([['1p','2p',2,2],[2,'3p']])  # primed_diagonal allowed
sage: t.check()
sage: t = T([['1p','1p',2,2],[2,'3p']])
Traceback (most recent call last):
...
ValueError: [['1p', '1p', 2, 2], [2, '3p']] is not an element of
 Shifted Primed Tableaux of shape [4, 2] and maximum entry 6

is_standard()

Return True if the entries of self are in bijection with positive primed integers \(1', 1, 2', \ldots, n\).

EXAMPLES:

sage: ShiftedPrimedTableau([["1'", 1, "2'"], [2, "3'"]],
....:                      primed_diagonal=True).is_standard()
True
sage: ShiftedPrimedTableau([["1'", 1, 2], ["2'", "3'"]],
....:                      primed_diagonal=True).is_standard()
True
sage: ShiftedPrimedTableau([["1'", 1, 1], ["2'", 2]],
....:                      primed_diagonal=True).is_standard()
False
sage: ShiftedPrimedTableau([[1, "2'"], [2]]).is_standard()
False
sage: s = ShiftedPrimedTableau([[None, None,"1p","2p",2],[None,"1"]])
sage: s.is_standard()
True

max_entry()

Return the minimum unprimed letter \(x > y\) for all \(y\) in self.

EXAMPLES:

sage: Tab = ShiftedPrimedTableau([(1,1,'2p','3p'),(2,2)])
sage: Tab.max_entry()
3

pp()

Pretty print self.

EXAMPLES:

sage: t = ShiftedPrimedTableau([[1,'2p',2,2],[2,'3p']])
sage: t.pp()
1  2' 2  2
   2  3'
sage: t = ShiftedPrimedTableau([[10,'11p',11,11],[11,'12']])
sage: t.pp()
10  11' 11  11
    11  12
sage: s = ShiftedPrimedTableau([['2p',2,3],['2p']],skew=[2,1])
sage: s.pp()
 .  .  2' 2  3
    .  2'

restrict(n)

Return the restriction of the shifted tableau to all the numbers less than or equal to n.

Note

If only the outer shape of the restriction, rather than the whole restriction, is needed, then the faster method restriction_outer_shape() is preferred. Similarly if only the skew shape is needed, use restriction_shape().

EXAMPLES:

sage: t = ShiftedPrimedTableau([[1,'2p',2,2],[2,'3p']])
sage: t.restrict(2).pp()
1  2' 2  2
   2

sage: t.restrict("2p").pp()
1  2'

sage: s = ShiftedPrimedTableau([["2p",2,3],["2p"]], skew=[2,1])
sage: s.restrict(2).pp()
.  .  2' 2
   .  2'
sage: s.restrict(1.5).pp()
.  .  2'
   .  2'

restriction_outer_shape(n)

Return the outer shape of the restriction of the shifted tableau self to \(n\).

If \(T\) is a (skew) shifted tableau and \(n\) is a half-integer, then the restriction of \(T\) to \(n\) is defined as the (skew) shifted tableau obtained by removing all cells filled with entries greater than \(n\) from \(T\).

This method computes merely the outer shape of the restriction. For the restriction itself, use restrict().

EXAMPLES:

sage: s = ShiftedPrimedTableau([["2p",2,3],["2p"]], skew=[2,1])
sage: s.pp()
.  .  2' 2  3
   .  2'
sage: s.restriction_outer_shape(2)
[4, 2]
sage: s.restriction_outer_shape("2p")
[3, 2]

restriction_shape(n)

Return the skew shape of the restriction of the skew tableau self to n.

If \(T\) is a shifted tableau and \(n\) is a half-integer, then the restriction of \(T\) to \(n\) is defined as the (skew) shifted tableau obtained by removing all cells filled with entries greater than \(n\) from \(T\).

This method computes merely the skew shape of the restriction. For the restriction itself, use restrict().

EXAMPLES:

sage: s = ShiftedPrimedTableau([["2p",2,3],["2p"]], skew=[2,1])
sage: s.pp()
 .  .  2' 2  3
    .  2'

sage: s.restriction_shape(2)
[4, 2] / [2, 1]

shape()

Return the shape of the underlying partition of self.

EXAMPLES:

sage: t = ShiftedPrimedTableau([[1,'2p',2,2],[2,'3p']])
sage: t.shape()
[4, 2]
sage: s = ShiftedPrimedTableau([["2p",2,3],["2p"]],skew=[2,1])
sage: s.shape()
[5, 2] / [2, 1]

to_chain()

Return the chain of partitions corresponding to the (skew) shifted tableau self, interlaced by one of the colours 1 is the added cell is on the diagonal, 2 if an ordinary entry is added and 3 if a primed entry is added.

EXAMPLES:

sage: s = ShiftedPrimedTableau([(1, 2, 3.5, 5, 6.5), (3, 5.5)])
sage: s.pp()
 1  2  4' 5  7'
    3  6'

sage: s.to_chain()
[[], 1, [1], 2, [2], 1, [2, 1], 3, [3, 1], 2, [4, 1], 3, [4, 2], 3, [5, 2]]


sage: s = ShiftedPrimedTableau([(1, 3.5), (2.5,), (6,)], skew=[2,1])
sage: s.pp()
 .  .  1  4'
    .  3'
       6

sage: s.to_chain()
[[2, 1], 2, [3, 1], 0, [3, 1], 3, [3, 2], 3, [4, 2], 0, [4, 2], 1, [4, 2, 1]]

weight()

Return the weight of self.

The weight of a shifted primed tableau is defined to be the vector with \(i\)-th component equal to the number of entries \(i\) and \(i'\) in the tableau.

EXAMPLES:

sage: t = ShiftedPrimedTableau([['2p',2,2],[2,'3p']], skew=[1])
sage: t.weight()
(0, 4, 1)

class sage.combinat.shifted_primed_tableau.ShiftedPrimedTableaux(skew=None, primed_diagonal=False)

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

Returns the combinatorial class of shifted primed tableaux subject to the constraints given by the arguments.

A primed tableau is a tableau of shifted shape on the alphabet \(X' = \{1' < 1 < 2' < 2 < \cdots < n' < n\}\) such that

1. the entries are weakly increasing along rows and columns

2. a row cannot have two repeated primed entries, and a column cannot have two repeated non-primed entries

INPUT:

Valid optional keywords:

• shape – the (outer skew) shape of tableaux

• weight – the weight of tableaux

• max_entry – the maximum entry of tableaux

• skew – the inner skew shape of tableaux

• primed_diagonal – allow primed entries in main diagonal of tableaux

The weight of a tableau is defined to be the vector with \(i\)-th component equal to the number of entries \(i\) and \(i'\) in the tableau. The sum of the coordinates in the weight vector must be equal to the number of entries in the partition.

The shape and skew must be strictly decreasing partitions. The primed_diagonal is a boolean (default: False).

EXAMPLES:

sage: SPT = ShiftedPrimedTableaux(weight=(1,2,2), shape=[3,2]); SPT
Shifted Primed Tableaux of weight (1, 2, 2) and shape [3, 2]
sage: SPT.list()
[[(1, 2, 2), (3, 3)],
 [(1, 2', 3'), (2, 3)],
 [(1, 2', 3'), (2, 3')],
 [(1, 2', 2), (3, 3)]]
sage: SPT = ShiftedPrimedTableaux(weight=(1,2,2), shape=[3,2],
....:                             primed_diagonal=True); SPT
Shifted Primed Tableaux of weight (1, 2, 2) and shape [3, 2]
sage: SPT.list()
[[(1, 2, 2), (3, 3)],
 [(1, 2, 2), (3', 3)],
 [(1, 2', 3'), (2, 3)],
 [(1, 2', 3'), (2, 3')],
 [(1, 2', 3'), (2', 3)],
 [(1, 2', 3'), (2', 3')],
 [(1, 2', 2), (3, 3)],
 [(1, 2', 2), (3', 3)],
 [(1', 2, 2), (3, 3)],
 [(1', 2, 2), (3', 3)],
 [(1', 2', 3'), (2, 3)],
 [(1', 2', 3'), (2, 3')],
 [(1', 2', 3'), (2', 3)],
 [(1', 2', 3'), (2', 3')],
 [(1', 2', 2), (3, 3)],
 [(1', 2', 2), (3', 3)]]
sage: SPT = ShiftedPrimedTableaux(weight=(1,2)); SPT
Shifted Primed Tableaux of weight (1, 2)
sage: list(SPT)
[[(1, 2, 2)], [(1, 2', 2)], [(1, 2'), (2,)]]
sage: SPT = ShiftedPrimedTableaux(weight=(1,2), primed_diagonal=True)
sage: list(SPT)
[[(1, 2, 2)],
 [(1, 2', 2)],
 [(1', 2, 2)],
 [(1', 2', 2)],
 [(1, 2'), (2,)],
 [(1, 2'), (2',)],
 [(1', 2'), (2,)],
 [(1', 2'), (2',)]]
sage: SPT = ShiftedPrimedTableaux([3,2], max_entry=2); SPT
Shifted Primed Tableaux of shape [3, 2] and maximum entry 2
sage: list(SPT)
[[(1, 1, 1), (2, 2)], [(1, 1, 2'), (2, 2)]]
sage: SPT = ShiftedPrimedTableaux([3,2], max_entry=2,
....:                             primed_diagonal=True)
sage: list(SPT)
[[(1, 1, 1), (2, 2)],
 [(1, 1, 1), (2', 2)],
 [(1', 1, 1), (2, 2)],
 [(1', 1, 1), (2', 2)],
 [(1, 1, 2'), (2, 2)],
 [(1, 1, 2'), (2', 2)],
 [(1', 1, 2'), (2, 2)],
 [(1', 1, 2'), (2', 2)]]

See also

• ShiftedPrimedTableau

Element

alias of ShiftedPrimedTableau

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.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 the convention 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.shifted_primed_tableau.ShiftedPrimedTableaux_all(skew=None, primed_diagonal=False)

Bases: sage.combinat.shifted_primed_tableau.ShiftedPrimedTableaux

The class of all shifted primed tableaux.

class sage.combinat.shifted_primed_tableau.ShiftedPrimedTableaux_shape(shape, max_entry=None, skew=None, primed_diagonal=False)

Bases: sage.combinat.shifted_primed_tableau.ShiftedPrimedTableaux

Shifted primed tableaux of a fixed shape.

Shifted primed tableaux admit a type \(A_n\) classical crystal structure with highest weights corresponding to a given shape.

The list of module generators consists of all elements of the crystal with nonincreasing weight entries.

The crystal is constructed following operations described in [HPS2017] and [AO2018].

The optional primed_diagonal allows primed entries in the main diagonal of all the Shifted primed tableaux of a fixed shape. If the max_entry is None then max_entry is set to the total number of entries in the tableau if primed_diagonal is True.

EXAMPLES:

sage: ShiftedPrimedTableaux([4,3,1], max_entry=4)
Shifted Primed Tableaux of shape [4, 3, 1] and maximum entry 4
sage: ShiftedPrimedTableaux([4,3,1], max_entry=4).cardinality()
384

We compute some of the crystal structure:

sage: SPTC = crystals.ShiftedPrimedTableaux([3,2], 3)
sage: T = SPTC.module_generators[-1]
sage: T
[(1, 1, 2'), (2, 3')]
sage: T.f(2)
[(1, 1, 3'), (2, 3')]
sage: len(SPTC.module_generators)
7
sage: SPTC[0]
[(1, 1, 1), (2, 2)]
sage: SPTC.cardinality()
24

We compare this implementation with the \(q(n)\)-crystal on (tensor products) of letters:

sage: tableau_crystal = crystals.ShiftedPrimedTableaux([4,1], 3)
sage: tableau_digraph = tableau_crystal.digraph()
sage: c = crystals.Letters(['Q', 3])
sage: tensor_crystal = tensor([c]*5)
sage: u = tensor_crystal(c(1), c(1), c(1), c(2), c(1))
sage: subcrystal = tensor_crystal.subcrystal(generators=[u],
....:                                        index_set=[1,2,-1])
sage: tensor_digraph = subcrystal.digraph()
sage: tensor_digraph.is_isomorphic(tableau_digraph, edge_labels=True)
True

If we allow primed entries in the main diagonal:

sage: ShiftedPrimedTableaux([4,3,1], max_entry=4,
....:                        primed_diagonal=True)
Shifted Primed Tableaux of shape [4, 3, 1] and maximum entry 4
sage: ShiftedPrimedTableaux([4,3,1], max_entry=4,
....:                       primed_diagonal=True).cardinality()
3072
sage: SPTC = ShiftedPrimedTableaux([3,2], max_entry=3,
....:                              primed_diagonal=True)
sage: T = SPTC[-1]
sage: T
[(1', 2', 2), (3', 3)]
sage: SPTC[0]
[(1, 1, 1), (2, 2)]
sage: SPTC.cardinality()
96

module_generators()

Return the generators of self as a crystal.

shape()

Return the shape of the shifted tableaux self.

class sage.combinat.shifted_primed_tableau.ShiftedPrimedTableaux_weight(weight, skew=None, primed_diagonal=False)

Bases: sage.combinat.shifted_primed_tableau.ShiftedPrimedTableaux

Shifted primed tableaux of fixed weight.

EXAMPLES:

sage: ShiftedPrimedTableaux(weight=(2,3,1))
Shifted Primed Tableaux of weight (2, 3, 1)
sage: ShiftedPrimedTableaux(weight=(2,3,1)).cardinality()
17
sage: SPT = ShiftedPrimedTableaux(weight=(2,3,1), primed_diagonal=True)
sage: SPT.cardinality()
64
sage: T = ShiftedPrimedTableaux(weight=(3,2), primed_diagonal=True)
sage: T[:5]
[[(1, 1, 1, 2, 2)],
 [(1, 1, 1, 2', 2)],
 [(1', 1, 1, 2, 2)],
 [(1', 1, 1, 2', 2)],
 [(1, 1, 1, 2), (2,)]]
sage: T.cardinality()
16

class sage.combinat.shifted_primed_tableau.ShiftedPrimedTableaux_weight_shape(weight, shape, skew=None, primed_diagonal=False)

Bases: sage.combinat.shifted_primed_tableau.ShiftedPrimedTableaux

Shifted primed tableaux of the fixed weight and shape.

EXAMPLES:

sage: ShiftedPrimedTableaux([4,2,1], weight=(2,3,2))
Shifted Primed Tableaux of weight (2, 3, 2) and shape [4, 2, 1]
sage: ShiftedPrimedTableaux([4,2,1], weight=(2,3,2)).cardinality()
4
sage: T = ShiftedPrimedTableaux([4,2,1], weight=(2,3,2),
....:                           primed_diagonal=True)
sage: T[:6]
[[(1, 1, 2, 2), (2, 3'), (3,)],
 [(1, 1, 2, 2), (2, 3'), (3',)],
 [(1, 1, 2, 2), (2', 3'), (3,)],
 [(1, 1, 2, 2), (2', 3'), (3',)],
 [(1, 1, 2', 3), (2, 2), (3,)],
 [(1, 1, 2', 3), (2, 2), (3',)]]
sage: T.cardinality()
32