A tableau model for . For more information, see
InfinityCrystalOfTableaux.
AUTHORS:
Bases: sage.combinat.crystals.tensor_product.CrystalOfWords
crystal of tableaux.
A tableaux model for the crystal
is introduced by Hong and Lee in [HL08]. This model
is currently valid for types
,
,
,
, and
, and
builds on the tableaux model given by Kashiwara and Nakashima [KN94] in
types
,
,
, and
, and by Kang and Misra [KM94] in
type
.
Note
We are using the English convention for our tableaux.
We say a tableau is marginally large if:
We now will describe this tableaux model type-by-type.
Type
is the set of marginally large semistandard
tableaux with exactly
rows over the alphabet
.
Type
is the set of marginally large semistandard
tableaux with exactly
rows over the alphabet
and subject to the following constraints:
Type
is the set of marginally large semistandard
tableaux with exactly
rows over the alphabet
and
for each
, the contents of the boxes in the
-th
row are
.
Type
is the set of marginally large semistandard
tableaux with exactly
rows over the alphabet
and subject
to the following constaints:
Type
is the set of marginally large semistandard
tableaux with exactly
rows over the ordered alphabet
and subject to the following constraints:
In particular, the shape of the tableaux is not fixed in any instance of
; the row lengths of a tableau can be arbitrarily long.
REFERENCES:
[BN10] | D. Bump and M. Nakasuji.
Integration on ![]() |
[LS12] | (1, 2) K.-H. Lee and B. Salisbury. Young tableaux, canonical bases, and the Gindikin-Karpelevich formula. Arxiv 1205.6006. |
[HL08] | J. Hong and H. Lee.
Young tableaux and crystal ![]() |
[KM94] | S.-J. Kang and K. C. Misra.
Crystal bases and tensor product decompositions of ![]() |
INPUT:
EXAMPLES:
sage: B = crystals.infinity.Tableaux(['A',2])
sage: b = B.highest_weight_vector(); b.pp()
1 1
2
sage: b.f_string([2,1,1,2,2,2]).pp()
1 1 1 1 1 2 3
2 3 3 3
sage: B = crystals.infinity.Tableaux(['G',2])
sage: b = B(rows=[[1,1,1,1,1,2,3,3,0,-3,-1,-1,-1],[2,3,3,3]])
sage: b.e_string([2,1,1,1,1,1,1]).pp()
1 1 1 1 2 3 3 3 3 -2 -2 -2
2 3 3
sage: b.e_string([2,1,1,1,1,1,1,1])
We check that a few classical crystals embed into :
sage: def crystal_test(B, C):
....: g = {C.module_generators[0] : B.module_generators[0]}
....: f = C.crystal_morphism(g)
....: G = B.digraph(subset=[f(x) for x in C])
....: return G.is_isomorphic(C.digraph(), edge_labels=True)
sage: B = crystals.infinity.Tableaux(['A',2])
sage: C = crystals.Tableaux(['A',2], shape=[2,1])
sage: crystal_test(B, C)
True
sage: C = crystals.Tableaux(['A',2], shape=[6,2])
sage: crystal_test(B, C)
True
sage: B = crystals.infinity.Tableaux(['B',2])
sage: C = crystals.Tableaux(['B',2], shape=[3])
sage: crystal_test(B, C)
True
sage: C = crystals.Tableaux(['B',2], shape=[2,1])
sage: crystal_test(B, C)
True
sage: B = crystals.infinity.Tableaux(['C',3])
sage: C = crystals.Tableaux(['C',3], shape=[2,1])
sage: crystal_test(B, C)
True
sage: B = crystals.infinity.Tableaux(['D',4])
sage: C = crystals.Tableaux(['D',4], shape=[2])
sage: crystal_test(B, C)
True
sage: C = crystals.Tableaux(['D',4], shape=[1,1,1,1])
sage: crystal_test(B, C)
True
sage: B = crystals.infinity.Tableaux(['G',2])
sage: C = crystals.Tableaux(['G',2], shape=[3])
sage: crystal_test(B, C)
True
Bases: sage.combinat.crystals.tensor_product.CrystalOfTableauxElement
Elements in crystal of tableaux.
Return the content of self.
The content of
is the number of
blocks added to the highest weight to obtain
with any
-boxes in the
-th row counted with
multiplicity
provided the underlying Cartan type is of type
,
, or
.
EXAMPLES:
sage: B = crystals.infinity.Tableaux("D5")
sage: b = B.highest_weight_vector().f_string([5,4,3,1,1,3,4,5,3,4,5,1,4,5,2,3,5,3,2,4])
sage: b.content()
13
sage: B = crystals.infinity.Tableaux("B2")
sage: b = B(rows=[[1,1,1,1,1,1,2,2,2,-2,-2],[2,0,-2,-2,-2]])
sage: b.content()
12
sage: B = crystals.infinity.Tableaux("C2")
sage: b = B(rows=[[1,1,1,1,1,1,2,2,2,-2,-2],[2,-2,-2,-2]])
sage: b.content()
8
Return the action of on self.
INPUT:
EXAMPLES:
sage: B = crystals.infinity.Tableaux(['B',3])
sage: b = B(rows=[[1,1,1,1,1,1,1,2,0,-3,-1,-1,-1,-1],[2,2,2,2,-2,-2],[3,-3,-3]])
sage: b.e(3).pp()
1 1 1 1 1 1 1 2 0 -3 -1 -1 -1 -1
2 2 2 2 -2 -2
3 0 -3
sage: b.e(1).pp()
1 1 1 1 1 1 1 0 -3 -1 -1 -1 -1
2 2 2 2 -2 -2
3 -3 -3
Return the action of on self.
INPUT:
EXAMPLES:
sage: B = crystals.infinity.Tableaux(['C',4])
sage: b = B.highest_weight_vector()
sage: b.f(1).pp()
1 1 1 1 2
2 2 2
3 3
4
sage: b.f(3).pp()
1 1 1 1 1
2 2 2 2
3 3 4
4
sage: b.f(3).f(4).pp()
1 1 1 1 1
2 2 2 2
3 3 -4
4
Return of self.
Let Define
, where
is the
-th simple coroot and
is the weight()
of
.
INPUT:
EXAMPLES:
sage: B = crystals.infinity.Tableaux("A3")
sage: [B.highest_weight_vector().f_string([1,3,2,3,1,3,2,1]).phi(i) for i in B.index_set()]
[-3, 4, -3]
sage: B = crystals.infinity.Tableaux("G2")
sage: [B.highest_weight_vector().f_string([2,2,1,2,1,1,1,2]).phi(i) for i in B.index_set()]
[5, -3]
Return the reduced form of self.
The reduced form of a tableaux is the
(not necessarily semistandard) tableaux obtained from
by
removing all
-boxes in the
-th row, subject to the condition
that if the row is empty, a
is put as a placeholder.
This is described in [BN10] and [LS12].
EXAMPLES:
sage: B = crystals.infinity.Tableaux(['A',3])
sage: b = B.highest_weight_vector().f_string([2,2,2,3,3,3,3,3])
sage: b.pp()
1 1 1 1 1 1 1 1
2 2 2 2 4 4 4
3 4 4
sage: b.reduced_form().pp()
*
4 4 4
4 4
Returns the statistic of self.
More precisely, following [LS12], define a -segment of a
tableau
in
to be a maximal string
of
-boxes in a single row of
. Set
to be the number of
-segments in
, as
varies over
all possible values. Then
is determined
type-by-type.
EXAMPLES:
sage: B = crystals.infinity.Tableaux(['A',3])
sage: b = B.highest_weight_vector().f_string([1,3,2,2,3,1,1,3])
sage: b.pp()
1 1 1 1 1 1 2 2 4
2 2 2 2 3
3 4 4
sage: b.seg()
4
sage: B = crystals.infinity.Tableaux(['D',4])
sage: b = B(rows=[[1,1,1,1,1,1,3,-2,-1],[2,2,2,4,-2],[3,3],[4]])
sage: b.pp()
1 1 1 1 1 1 3 -2 -1
2 2 2 4 -2
3 3
4
sage: b.seg()
6
sage: B = crystals.infinity.Tableaux(['G',2])
sage: b = B.highest_weight_vector().f_string([2,1,1,1,2,1,2,2,1,2,2,2,1,2,2,1])
sage: b.pp()
1 1 1 1 1 1 1 1 2 3 0 -3
2 3 3 3 3 3 3
sage: b.seg()
5
Return the string parametrization of self with respect to word.
For in the Weyl group, let
denote the set of reduced
expressions for
; that is, if
is a reduced expression, then
. For brevity, such words
are denoted by
.
For and
,
the string parametrization
of
in the
direction
is defined recursively by
and
for
. If
is the longest
element of the Weyl group, then the path determined by the string
parametrization terminates at the highest weight vector.
INPUT:
EXAMPLES:
sage: B = crystals.infinity.Tableaux("A5")
sage: b = B(rows=[[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,3,6,6,6,6,6,6],[2,2,2,2,2,2,2,2,2,4,5,5,5,6],[3,3,3,3,3,3,3,5],[4,4,4,6,6,6],[5,6]])
sage: b.string_parameters([1,2,1,3,2,1,4,3,2,1,5,4,3,2,1])
[0, 1, 1, 1, 1, 0, 4, 4, 3, 0, 11, 10, 7, 7, 6]
sage: B = crystals.infinity.Tableaux("G2")
sage: b = B(rows=[[1,1,1,1,1,3,3,0,-3,-3,-2,-2,-1,-1,-1,-1],[2,3,3,3]])
sage: b.string_parameters([2,1,2,1,2,1])
[5, 13, 11, 15, 4, 4]
sage: b.string_parameters([1,2,1,2,1,2])
[7, 12, 15, 8, 10, 0]
Return the weight of self.
From the definition of a crystal and that the highest weight
element of
is
, the weight of
can be defined as
where
and
is the
set of simple roots. (Note that the weight is independent of the
path chosen to get to the highest weight.)
However we can also take advantage of the fact that
, where
is the shape of
, preserves the
tableau representation of
. Therefore
where is just the usual weight of
the tableau
.
Let be the
-th fundamental weight. In type
, the
height
columns corresponds to
and
the in type
, the height
columns corresponds to
.
EXAMPLES:
sage: B = crystals.infinity.Tableaux("C7")
sage: b = B.highest_weight_vector().f_string([1,6,4,7,4,2,4,6,2,4,6,7,1,2,4,7])
sage: b.weight()
(-2, -1, 3, -5, 5, -3, -3)
Check that the definitions agree:
sage: P = B.weight_lattice_realization()
sage: alpha = P.simple_roots()
sage: b.weight() == -2*alpha[1] - 3*alpha[2] - 5*alpha[4] - 3*alpha[6] - 3*alpha[7]
True
Check that it works for type :
sage: B = crystals.infinity.Tableaux("B2")
sage: B.highest_weight_vector().weight()
(0, 0)
sage: b = B.highest_weight_vector().f_string([1,2,2,2,1,2])
sage: P = B.weight_lattice_realization()
sage: alpha = P.simple_roots()
sage: b.weight() == -2*alpha[1] - 4*alpha[2]
True
Check that it works for type :
sage: B = crystals.infinity.Tableaux("D4")
sage: B.highest_weight_vector().weight()
(0, 0, 0, 0)
sage: b = B.highest_weight_vector().f_string([1,4,4,2,4,3,2,4,1,3,2,4])
sage: P = B.weight_lattice_realization()
sage: alpha = P.simple_roots()
sage: b.weight() == -2*alpha[1] - 3*alpha[2] - 2*alpha[3] - 5*alpha[4]
True
Return the module generator (or highest weight element) of self.
The module generator is the unique tableau of shape with weight
.
EXAMPLES:
sage: T = crystals.infinity.Tableaux(['A',3])
sage: T.module_generator()
[[1, 1, 1], [2, 2], [3]]
Bases: sage.combinat.crystals.infinity_crystals.InfinityCrystalOfTableaux
crystal of tableaux for type
.
This is the set of marginally large semistandard
tableaux with exactly
rows over the alphabet
and subject
to the following constraints:
For more information, see InfinityCrystalOfTableaux.
EXAMPLES:
sage: B = crystals.infinity.Tableaux("D4")
sage: b = B.highest_weight_vector().f_string([4,3,2,1,4])
sage: b.pp()
1 1 1 1 1 1 2
2 2 2 2 3
3 -4 -3
sage: b.weight()
(-1, 0, -2, -1)
Bases: sage.combinat.crystals.infinity_crystals.InfinityCrystalOfTableaux.Element
Elements in crystal of tableaux for type
.
Return the action of on self.
INPUT:
EXAMPLES:
sage: B = crystals.infinity.Tableaux(['D',4])
sage: b = B.highest_weight_vector().f_string([1,4,3,1,2]); b.pp()
1 1 1 1 2 3
2 2 2
3 -3
sage: b.e(2).pp()
1 1 1 1 2 2
2 2 2
3 -3
Return the action of on self.
INPUT:
EXAMPLES:
sage: B = crystals.infinity.Tableaux(['D',5])
sage: b = B.highest_weight_vector().f_string([1,4,3,1,5]); b.pp()
1 1 1 1 1 1 2 2
2 2 2 2 2
3 3 3 -5
4 5
sage: b.f(1).pp()
1 1 1 1 1 1 2 2 2
2 2 2 2 2
3 3 3 -5
4 5
sage: b.f(5).pp()
1 1 1 1 1 1 2 2
2 2 2 2 2
3 3 3 -5
4 -4
Return the module generator (or highest weight element) of self.
The module generator is the unique tableau of shape with weight
.
EXAMPLES:
sage: T = crystals.infinity.Tableaux(['D',4])
sage: T.module_generator()
[[1, 1, 1], [2, 2], [3]]