\(\mathcal{B}(\infty)\) crystals of tableaux in nonexceptional types and \(G_2\) - Combinatorics

Skip to content
Back to top
View this page
Edit this page

# \(\mathcal{B}(\infty)\) crystals of tableaux in nonexceptional types and \(G_2\)

A tableau model for \(\mathcal{B}(\infty)\). For more information, see `InfinityCrystalOfTableaux`.

AUTHORS:

- Ben Salisbury: initial version

- Travis Scrimshaw: initial version

class sage.combinat.crystals.infinity_crystals.DualInfinityQueerCrystalOfTableaux(cartan_type)

  Bases: `CrystalOfWords`

  Initialize `self`.

  EXAMPLES:

  Sage

      sage: B = crystals.infinity.Tableaux(['A',2])
      sage: TestSuite(B).run() # long time

  Python

      >>> from sage.all import *
      >>> B = crystals.infinity.Tableaux(['A',Integer(2)])
      >>> TestSuite(B).run() # long time

  class Element

    Bases: `InfinityQueerCrystalOfTableauxElement`

  index_set()

    Return the index set of `self`.

    EXAMPLES:

    Sage

        sage: B = crystals.infinity.Tableaux(["Q",3])
        sage: B.index_set()
        (1, 2, -1)

    Python

        >>> from sage.all import *
        >>> B = crystals.infinity.Tableaux(["Q",Integer(3)])
        >>> B.index_set()
        (1, 2, -1)

  module_generator()

    Return the module generator (or highest weight element) of `self`.

    The module generator is the unique semistandard hook tableau of shape \((n, n-1, \ldots,2, 1)\) with weight \(0\).

    EXAMPLES:

    Sage

        sage: B = crystals.infinity.Tableaux(["Q",5])
        sage: B.module_generator()
        [[5, 5, 5, 5, 5], [4, 4, 4, 4], [3, 3, 3], [2, 2], [1]]

    Python

        >>> from sage.all import *
        >>> B = crystals.infinity.Tableaux(["Q",Integer(5)])
        >>> B.module_generator()
        [[5, 5, 5, 5, 5], [4, 4, 4, 4], [3, 3, 3], [2, 2], [1]]

class sage.combinat.crystals.infinity_crystals.InfinityCrystalOfTableaux(cartan_type)

  Bases: `CrystalOfWords`

  \(\mathcal{B}(\infty)\) crystal of tableaux.

  A tableaux model \(\mathcal{T}(\infty)\) for the crystal \(\mathcal{B}(\infty)\) is introduced by Hong and Lee in [HL2008]. This model is currently valid for types \(A_n\), \(B_n\), \(C_n\), \(D_n\), and \(G_2\), and builds on the tableaux model given by Kashiwara and Nakashima [KN1994] in types \(A_n\), \(B_n\), \(C_n\), and \(D_n\), and by Kang and Misra [KM1994] in type \(G_2\).

  Note

  We are using the English convention for our tableaux.

  We say a tableau \(T\) is marginally large if:

  - for each \(1 \leq i \leq n\), the leftmost box in the \(i\)-th row from the top in \(T\) is an \(i\)-box,

  - for each \(1 \leq i \leq n\), the number of \(i\)-boxes in the \(i\)-th row from the top in \(T\) is greater than the total number of boxes in the \((i+1)\)-th row by exactly one.

  We now will describe this tableaux model type-by-type.

  Type \(A_n\)

  \(\mathcal{T}(\infty)\) is the set of marginally large semistandard tableaux with exactly \(n\) rows over the alphabet \(\{1 \prec 2 \prec \cdots \prec n+1 \}\).

  Type \(B_n\)

  \(\mathcal{T}(\infty)\) is the set of marginally large semistandard tableaux with exactly \(n\) rows over the alphabet \(\{1 \prec \cdots \prec n \prec 0 \prec \overline{n} \prec \cdots \prec \overline{1} \}\) and subject to the following constraints:

  - for each \(1 \le i \le n\), the contents of the boxes in the \(i\)-th row are \(\preceq \overline{i}\),

  - the entry \(0\) can appear at most once in a single row.

  Type \(C_n\)

  \(\mathcal{T}(\infty)\) is the set of marginally large semistandard tableaux with exactly \(n\) rows over the alphabet \(\{1 \prec \cdots \prec n \prec \overline{n} \prec \cdots \prec \overline{1} \}\) and for each \(1 \leq i \leq n\), the contents of the boxes in the \(i\)-th row are \(\preceq \overline{i}\).

  Type \(D_n\)

  \(\mathcal{T}(\infty)\) is the set of marginally large semistandard tableaux with exactly \(n-1\) rows over the alphabet \(\{1 \prec \cdots \prec n, \overline{n} \prec \cdots \prec \overline{1} \}\) and subject to the following constraints:

  - for each \(1 \le i \le n\), the contents of the boxes in the \(i\)-th row are \(\preceq \overline{i}\),

  - the entries \(n\) and \(\overline{n}\) may not appear simultaneously in a single row.

  Type \(G_2\)

  \(\mathcal{T}(\infty)\) is the set of marginally large semistandard tableaux with exactly \(2\) rows over the ordered alphabet \(\{1 \prec 2 \prec 3 \prec 0 \prec \overline{3} \prec \overline{2} \prec \overline{1}\}\) and subject to the following constraints:

  - the contents of the boxes in the first row are \(\preceq \overline{i}\),

  - the contents of the boxes in the second row are \(\preceq 3\),

  - the entry \(0\) can appear at most once in the first row and not at all in the second row.

  In particular, the shape of the tableaux is not fixed in any instance of \(\mathcal{T}(\infty)\); the row lengths of a tableau can be arbitrarily long.

  INPUT:

  - `cartan_type` – one of `['A',n]`, `['B',n]`, `['C',n]`, `['D',n]`, or `['G',2]`, where `n` is a positive integer

  EXAMPLES:

  Sage

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

  Python

      >>> from sage.all import *
      >>> B = crystals.infinity.Tableaux(['A',Integer(2)])
      >>> b = B.highest_weight_vector(); b.pp()
      1  1
      2
      >>> b.f_string([Integer(2),Integer(1),Integer(1),Integer(2),Integer(2),Integer(2)]).pp()
      1  1  1  1  1  2  3
      2  3  3  3

      >>> B = crystals.infinity.Tableaux(['G',Integer(2)])
      >>> b = B(rows=[[Integer(1),Integer(1),Integer(1),Integer(1),Integer(1),Integer(2),Integer(3),Integer(3),Integer(0),-Integer(3),-Integer(1),-Integer(1),-Integer(1)],[Integer(2),Integer(3),Integer(3),Integer(3)]])
      >>> b.e_string([Integer(2),Integer(1),Integer(1),Integer(1),Integer(1),Integer(1),Integer(1)]).pp()
      1  1  1  1  2  3  3  3  3 -2 -2 -2
      2  3  3
      >>> b.e_string([Integer(2),Integer(1),Integer(1),Integer(1),Integer(1),Integer(1),Integer(1),Integer(1)])

  We check that a few classical crystals embed into \(\mathcal{T}(\infty)\):

  Sage

      sage: def crystal_test(B, C):
      ....:     T = crystals.elementary.T(C.cartan_type(), C.module_generators[0].weight())
      ....:     TP = crystals.TensorProduct(T, B)
      ....:     mg = TP(T[0], B.module_generators[0])
      ....:     g = {C.module_generators[0]: mg}
      ....:     f = C.crystal_morphism(g, category=HighestWeightCrystals())
      ....:     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

  [Python]

      >>> from sage.all import *
      >>> def crystal_test(B, C):
      ...     T = crystals.elementary.T(C.cartan_type(), C.module_generators[Integer(0)].weight())
      ...     TP = crystals.TensorProduct(T, B)
      ...     mg = TP(T[Integer(0)], B.module_generators[Integer(0)])
      ...     g = {C.module_generators[Integer(0)]: mg}
      ...     f = C.crystal_morphism(g, category=HighestWeightCrystals())
      ...     G = B.digraph(subset=[f(x) for x in C])
      ...     return G.is_isomorphic(C.digraph(), edge_labels=True)
      >>> B = crystals.infinity.Tableaux(['A',Integer(2)])
      >>> C = crystals.Tableaux(['A',Integer(2)], shape=[Integer(2),Integer(1)])
      >>> crystal_test(B, C)
      True
      >>> C = crystals.Tableaux(['A',Integer(2)], shape=[Integer(6),Integer(2)])
      >>> crystal_test(B, C)
      True
      >>> B = crystals.infinity.Tableaux(['B',Integer(2)])
      >>> C = crystals.Tableaux(['B',Integer(2)], shape=[Integer(3)])
      >>> crystal_test(B, C)
      True
      >>> C = crystals.Tableaux(['B',Integer(2)], shape=[Integer(2),Integer(1)])
      >>> crystal_test(B, C)
      True
      >>> B = crystals.infinity.Tableaux(['C',Integer(3)])
      >>> C = crystals.Tableaux(['C',Integer(3)], shape=[Integer(2),Integer(1)])
      >>> crystal_test(B, C)
      True
      >>> B = crystals.infinity.Tableaux(['D',Integer(4)])
      >>> C = crystals.Tableaux(['D',Integer(4)], shape=[Integer(2)])
      >>> crystal_test(B, C)
      True
      >>> C = crystals.Tableaux(['D',Integer(4)], shape=[Integer(1),Integer(1),Integer(1),Integer(1)])
      >>> crystal_test(B, C)
      True
      >>> B = crystals.infinity.Tableaux(['G',Integer(2)])
      >>> C = crystals.Tableaux(['G',Integer(2)], shape=[Integer(3)])
      >>> crystal_test(B, C)
      True

  class Element

    Bases: `InfinityCrystalOfTableauxElement`

    Elements in \(\mathcal{B}(\infty)\) crystal of tableaux.

    content()

      Return the content of `self`.

      The content \(|T|\) of \(T \in \mathcal{B}(\infty)\) is the number of blocks added to the highest weight to obtain \(T\) with any \(\overline{\imath}\)-boxes in the \(i\)-th row counted with multiplicity \(2\) provided the underlying Cartan type is of type \(B\), \(D\), or \(G\).

      EXAMPLES:

      Sage

          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

      Python

          >>> from sage.all import *
          >>> B = crystals.infinity.Tableaux("D5")
          >>> b = B.highest_weight_vector().f_string([Integer(5),Integer(4),Integer(3),Integer(1),Integer(1),Integer(3),Integer(4),Integer(5),Integer(3),Integer(4),Integer(5),Integer(1),Integer(4),Integer(5),Integer(2),Integer(3),Integer(5),Integer(3),Integer(2),Integer(4)])
          >>> b.content()
          13

          >>> B = crystals.infinity.Tableaux("B2")
          >>> b = B(rows=[[Integer(1),Integer(1),Integer(1),Integer(1),Integer(1),Integer(1),Integer(2),Integer(2),Integer(2),-Integer(2),-Integer(2)],[Integer(2),Integer(0),-Integer(2),-Integer(2),-Integer(2)]])
          >>> b.content()
          12

          >>> B = crystals.infinity.Tableaux("C2")
          >>> b = B(rows=[[Integer(1),Integer(1),Integer(1),Integer(1),Integer(1),Integer(1),Integer(2),Integer(2),Integer(2),-Integer(2),-Integer(2)],[Integer(2),-Integer(2),-Integer(2),-Integer(2)]])
          >>> b.content()
          8

    phi(i)

      Return \(\varphi_i\) of `self`.

      Let \(T \in \mathcal{B}(\infty)\) Define \(\varphi_i(T) := \varepsilon_i(T) + \langle h_i, \mathrm{wt}(T) \rangle\), where \(h_i\) is the \(i\)-th simple coroot and \(\mathrm{wt}(T)\) is the `weight()` of \(T\).

      INPUT:

      - `i` – an element of the index set

      EXAMPLES:

      Sage

          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]

      Python

          >>> from sage.all import *
          >>> B = crystals.infinity.Tableaux("A3")
          >>> [B.highest_weight_vector().f_string([Integer(1),Integer(3),Integer(2),Integer(3),Integer(1),Integer(3),Integer(2),Integer(1)]).phi(i) for i in B.index_set()]
          [-3, 4, -3]

          >>> B = crystals.infinity.Tableaux("G2")
          >>> [B.highest_weight_vector().f_string([Integer(2),Integer(2),Integer(1),Integer(2),Integer(1),Integer(1),Integer(1),Integer(2)]).phi(i) for i in B.index_set()]
          [5, -3]

    reduced_form()

      Return the reduced form of `self`.

      The reduced form of a tableaux \(T \in \mathcal{T}(\infty)\) is the (not necessarily semistandard) tableaux obtained from \(T\) by removing all \(i\)-boxes in the \(i\)-th row, subject to the condition that if the row is empty, a \(\ast\) is put as a placeholder. This is described in [BN2010] and [LS2012].

      EXAMPLES:

      Sage

          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()
          [['*'], [4, 4, 4], [4, 4]]

      Python

          >>> from sage.all import *
          >>> B = crystals.infinity.Tableaux(['A',Integer(3)])
          >>> b = B.highest_weight_vector().f_string([Integer(2),Integer(2),Integer(2),Integer(3),Integer(3),Integer(3),Integer(3),Integer(3)])
          >>> b.pp()
          1  1  1  1  1  1  1  1
          2  2  2  2  4  4  4
          3  4  4
          >>> b.reduced_form()
          [['*'], [4, 4, 4], [4, 4]]

    seg()

      Return the statistic \(\mathrm{seg}\) of `self`.

      More precisely, following [LS2012], define a \(k\)-segment of a tableau \(T\) in \(\mathcal{B}(\infty)\) to be a maximal string of \(k\)-boxes in a single row of \(T\). Set \(\mathrm{seg}^{\prime}(T)\) to be the number of \(k\)-segments in \(T\), as \(k\) varies over all possible values. Then \(\mathrm{seg}(T)\) is determined type-by-type.

      - In types \(A_n\) and \(C_n\), define \(\mathrm{seg}(T) := \mathrm{seg}^{\prime}(T)\).

      - In types \(B_n\) and \(G_2\), set \(e(T)\) to be the number of rows in \(T\) which contain both a \(0\)-box and an \(\overline{\imath}\)-box. Define \(\mathrm{seg}(T) := \mathrm{seg}^{\prime}(T) - e(T)\).

      - In type \(D_n\), set \(d(T)\) to be the number of rows in \(T\) which contain an \(\overline{\imath}\)-box, but no \(n\)-box nor \(\overline{n}\)-box. Define \(\mathrm{seg}(T) := \mathrm{seg}^{\prime}(T) + d(T)\).

      EXAMPLES:

      Sage

          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

      Python

          >>> from sage.all import *
          >>> B = crystals.infinity.Tableaux(['A',Integer(3)])
          >>> b = B.highest_weight_vector().f_string([Integer(1),Integer(3),Integer(2),Integer(2),Integer(3),Integer(1),Integer(1),Integer(3)])
          >>> b.pp()
          1  1  1  1  1  1  2  2  4
          2  2  2  2  3
          3  4  4
          >>> b.seg()
          4

          >>> B = crystals.infinity.Tableaux(['D',Integer(4)])
          >>> b = B(rows=[[Integer(1),Integer(1),Integer(1),Integer(1),Integer(1),Integer(1),Integer(3),-Integer(2),-Integer(1)],[Integer(2),Integer(2),Integer(2),Integer(4),-Integer(2)],[Integer(3),Integer(3)],[Integer(4)]])
          >>> b.pp()
          1  1  1  1  1  1  3 -2 -1
          2  2  2  4 -2
          3  3
          4
          >>> b.seg()
          6

          >>> B = crystals.infinity.Tableaux(['G',Integer(2)])
          >>> b = B.highest_weight_vector().f_string([Integer(2),Integer(1),Integer(1),Integer(1),Integer(2),Integer(1),Integer(2),Integer(2),Integer(1),Integer(2),Integer(2),Integer(2),Integer(1),Integer(2),Integer(2),Integer(1)])
          >>> b.pp()
          1  1  1  1  1  1  1  1  2  3  0 -3
          2  3  3  3  3  3  3
          >>> b.seg()
          5

    weight()

      Return the weight of `self`.

      From the definition of a crystal and that the highest weight element \(b_{\infty}\) of \(\mathcal{B}(\infty)\) is \(0\), the weight of \(T \in \mathcal{B}(\infty)\) can be defined as \(\mathrm{wt}(T) := -\sum_j \alpha_{i_j}\) where \(\widetilde{e}_{i_1} \cdots \widetilde{e}_{i_{\ell}} T = b_{\infty}\) and \(\{\alpha_i\}\) 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 \(\rho \colon R_{\lambda} \otimes \mathcal{B}(\infty) \longrightarrow B(\lambda)\), where \(\lambda\) is the shape of \(T\), preserves the tableau representation of \(T\). Therefore

      \[\mathrm{wt}(T) = \mathrm{wt}\bigl( \rho(T) \bigr) - \lambda\]

      where \(\mathrm{wt}\bigl( \rho(T) \bigr)\) is just the usual weight of the tableau \(T\).

      Let \(\Lambda_i\) be the \(i\)-th fundamental weight. In type \(D\), the height \(n-1\) columns corresponds to \(\Lambda_{n-1} + \Lambda_n\) and the in type \(B\), the height \(n\) columns corresponds to \(2 \Lambda_n\).

      EXAMPLES:

      Sage

          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)

      Python

          >>> from sage.all import *
          >>> B = crystals.infinity.Tableaux("C7")
          >>> b = B.highest_weight_vector().f_string([Integer(1),Integer(6),Integer(4),Integer(7),Integer(4),Integer(2),Integer(4),Integer(6),Integer(2),Integer(4),Integer(6),Integer(7),Integer(1),Integer(2),Integer(4),Integer(7)])
          >>> b.weight()
          (-2, -1, 3, -5, 5, -3, -3)

      Check that the definitions agree:

      Sage

          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

      [Python]

          >>> from sage.all import *
          >>> P = B.weight_lattice_realization()
          >>> alpha = P.simple_roots()
          >>> b.weight() == -Integer(2)*alpha[Integer(1)] - Integer(3)*alpha[Integer(2)] - Integer(5)*alpha[Integer(4)] - Integer(3)*alpha[Integer(6)] - Integer(3)*alpha[Integer(7)]
          True

      Check that it works for type \(B\):

      Sage

          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

      Python

          >>> from sage.all import *
          >>> B = crystals.infinity.Tableaux("B2")
          >>> B.highest_weight_vector().weight()
          (0, 0)
          >>> b = B.highest_weight_vector().f_string([Integer(1),Integer(2),Integer(2),Integer(2),Integer(1),Integer(2)])
          >>> P = B.weight_lattice_realization()
          >>> alpha = P.simple_roots()
          >>> b.weight() == -Integer(2)*alpha[Integer(1)] - Integer(4)*alpha[Integer(2)]
          True

      Check that it works for type \(D\):

      Sage

          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

      [Python]

          >>> from sage.all import *
          >>> B = crystals.infinity.Tableaux("D4")
          >>> B.highest_weight_vector().weight()
          (0, 0, 0, 0)
          >>> b = B.highest_weight_vector().f_string([Integer(1),Integer(4),Integer(4),Integer(2),Integer(4),Integer(3),Integer(2),Integer(4),Integer(1),Integer(3),Integer(2),Integer(4)])
          >>> P = B.weight_lattice_realization()
          >>> alpha = P.simple_roots()
          >>> b.weight() == -Integer(2)*alpha[Integer(1)] - Integer(3)*alpha[Integer(2)] - Integer(2)*alpha[Integer(3)] - Integer(5)*alpha[Integer(4)]
          True

  module_generator()

    Return the module generator (or highest weight element) of `self`.

    The module generator is the unique tableau of shape \((n, n-1, \ldots, 2, 1)\) with weight \(0\).

    EXAMPLES:

    Sage

        sage: T = crystals.infinity.Tableaux(['A',3])
        sage: T.module_generator()
        [[1, 1, 1], [2, 2], [3]]

    Python

        >>> from sage.all import *
        >>> T = crystals.infinity.Tableaux(['A',Integer(3)])
        >>> T.module_generator()
        [[1, 1, 1], [2, 2], [3]]

class sage.combinat.crystals.infinity_crystals.InfinityCrystalOfTableauxTypeD(cartan_type)

  Bases: `InfinityCrystalOfTableaux`

  \(\mathcal{B}(\infty)\) crystal of tableaux for type \(D_n\).

  This is the set \(\mathcal{T}(\infty)\) of marginally large semistandard tableaux with exactly \(n-1\) rows over the alphabet \(\{1 \prec \cdots \prec n, \overline{n} \prec \cdots \prec \overline{1} \}\) and subject to the following constraints:

  - for each \(1 \le i \le n\), the contents of the boxes in the \(i\)-th row are \(\preceq \overline{i}\),

  - the entries \(n\) and \(\overline{n}\) may not appear simultaneously in a single row.

  For more information, see `InfinityCrystalOfTableaux`.

  EXAMPLES:

  Sage

      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)

  Python

      >>> from sage.all import *
      >>> B = crystals.infinity.Tableaux("D4")
      >>> b = B.highest_weight_vector().f_string([Integer(4),Integer(3),Integer(2),Integer(1),Integer(4)])
      >>> b.pp()
      1  1  1  1  1  1  2
      2  2  2  2  3
      3 -4 -3
      >>> b.weight()
      (-1, 0, -2, -1)

  class Element

    Bases: `InfinityCrystalOfTableauxElementTypeD`, `Element`

    Elements in \(\mathcal{B}(\infty)\) crystal of tableaux for type \(D_n\).

  module_generator()

    Return the module generator (or highest weight element) of `self`.

    The module generator is the unique tableau of shape \((n-1, \ldots, 2, 1)\) with weight \(0\).

    EXAMPLES:

    Sage

        sage: T = crystals.infinity.Tableaux(['D',4])
        sage: T.module_generator()
        [[1, 1, 1], [2, 2], [3]]

    Python

        >>> from sage.all import *
        >>> T = crystals.infinity.Tableaux(['D',Integer(4)])
        >>> T.module_generator()
        [[1, 1, 1], [2, 2], [3]]