### Navigation

- index
- modules |
- next |
- previous |
- Combinatorics »
- Rigged Configurations »

# Tensor Product of Kirillov-Reshetikhin Tableaux Elements

A tensor product of `KirillovReshetikhinTableauxElement`.

AUTHORS:

- Travis Scrimshaw (2010-09-26): Initial version

class `sage.combinat.rigged_configurations.tensor_product_kr_tableaux_element.``TensorProductOfKirillovReshetikhinTableauxElement`(parent, list=[[]], **options)

  Bases: `sage.combinat.crystals.tensor_product.TensorProductOfRegularCrystalsElement`

  An element in a tensor product of Kirillov-Reshetikhin tableaux.

  For more on tensor product of Kirillov-Reshetikhin tableaux, see `TensorProductOfKirillovReshetikhinTableaux`.

  The most common way to construct an element is to specify the option `pathlist` which is a list of lists which will be used to generate the individual factors of `KirillovReshetikhinTableauxElement`.

  EXAMPLES:

  Type \(A_n^{(1)}\) examples:

      sage: KRT = crystals.TensorProductOfKirillovReshetikhinTableaux(['A', 3, 1], [[1,1], [2,1], [1,1], [2,1], [2,1], [2,1]])
      sage: T = KRT(pathlist=[[2], [4,1], [3], [4,2], [3,1], [2,1]])
      sage: T
      [[2]] (X) [[1], [4]] (X) [[3]] (X) [[2], [4]] (X) [[1], [3]] (X) [[1], [2]]
      sage: T.to_rigged_configuration()
      <BLANKLINE>
      0[ ][ ]0
      1[ ]1
      <BLANKLINE>
      1[ ][ ]0
      1[ ]0
      1[ ]0
      <BLANKLINE>
      0[ ][ ]0
      <BLANKLINE>
      sage: T = KRT(pathlist=[[1], [2,1], [1], [4,1], [3,1], [2,1]])
      sage: T
      [[1]] (X) [[1], [2]] (X) [[1]] (X) [[1], [4]] (X) [[1], [3]] (X) [[1], [2]]
      sage: T.to_rigged_configuration()
      <BLANKLINE>
      (/)
      <BLANKLINE>
      1[ ]0
      1[ ]0
      <BLANKLINE>
      0[ ]0
      <BLANKLINE>

  Type \(D_n^{(1)}\) examples:

      sage: KRT = crystals.TensorProductOfKirillovReshetikhinTableaux(['D', 4, 1], [[1,1], [1,1], [1,1], [1,1]])
      sage: T = KRT(pathlist=[[-1], [-1], [1], [1]])
      sage: T
      [[-1]] (X) [[-1]] (X) [[1]] (X) [[1]]
      sage: T.to_rigged_configuration()
      <BLANKLINE>
      0[ ][ ]0
      0[ ][ ]0
      <BLANKLINE>
      0[ ][ ]0
      0[ ][ ]0
      <BLANKLINE>
      0[ ][ ]0
      <BLANKLINE>
      0[ ][ ]0
      <BLANKLINE>
      sage: KRT = crystals.TensorProductOfKirillovReshetikhinTableaux(['D', 4, 1], [[2,1], [1,1], [1,1], [1,1]])
      sage: T = KRT(pathlist=[[3,2], [1], [-1], [1]])
      sage: T
      [[2], [3]] (X) [[1]] (X) [[-1]] (X) [[1]]
      sage: T.to_rigged_configuration()
      <BLANKLINE>
      0[ ]0
      0[ ]0
      0[ ]0
      <BLANKLINE>
      0[ ]0
      0[ ]0
      0[ ]0
      <BLANKLINE>
      1[ ]0
      <BLANKLINE>
      1[ ]0
      <BLANKLINE>
      sage: T.to_rigged_configuration().to_tensor_product_of_kirillov_reshetikhin_tableaux()
      [[2], [3]] (X) [[1]] (X) [[-1]] (X) [[1]]

  `classical_weight`()

    Return the classical weight of `self`.

    EXAMPLES:

        sage: KRT = crystals.TensorProductOfKirillovReshetikhinTableaux(['D',4,1], [[2,2]])
        sage: elt = KRT(pathlist=[[3,2,-1,1]]); elt
        [[2, 1], [3, -1]]
        sage: elt.classical_weight()
        (0, 1, 1, 0)
        sage: KRT = crystals.TensorProductOfKirillovReshetikhinTableaux(['A',3,1], [[2,2],[1,3]])
        sage: elt = KRT(pathlist=[[2,1,3,2],[1,4,4]]); elt
        [[1, 2], [2, 3]] (X) [[1, 4, 4]]
        sage: elt.classical_weight()
        (2, 2, 1, 2)

  `left_split`()

    Return the image of `self` under the left column splitting map.

    EXAMPLES:

        sage: KRT = crystals.TensorProductOfKirillovReshetikhinTableaux(['A',3,1], [[2,2],[1,3]])
        sage: elt = KRT(pathlist=[[2,1,3,2],[1,4,4]]); elt.pp()
          1  2 (X)   1  4  4
          2  3
        sage: elt.left_split().pp()
          1 (X)   2 (X)   1  4  4
          2       3

  `lusztig_involution`()

    Return the result of the classical Lusztig involution on `self`.

    EXAMPLES:

        sage: KRT = crystals.TensorProductOfKirillovReshetikhinTableaux(['A',3,1], [[2,2],[1,3]])
        sage: elt = KRT(pathlist=[[2,1,3,2],[1,4,4]])
        sage: li = elt.lusztig_involution(); li
        [[1, 1, 4]] (X) [[2, 3], [3, 4]]
        sage: li.parent()
        Tensor product of Kirillov-Reshetikhin tableaux of type ['A', 3, 1] and factor(s) ((1, 3), (2, 2))

  `pp`()

    Pretty print `self`.

    EXAMPLES:

        sage: TPKRT = crystals.TensorProductOfKirillovReshetikhinTableaux(['A',4,1], [[2,2],[3,1],[3,3]])
        sage: TPKRT.module_generators[0].pp()
          1  1 (X)   1 (X)   1  1  1
          2  2       2       2  2  2
                     3       3  3  3

  `right_split`()

    Return the image of `self` under the right column splitting map.

    EXAMPLES:

        sage: KRT = crystals.TensorProductOfKirillovReshetikhinTableaux(['A',3,1], [[2,2],[1,3]])
        sage: elt = KRT(pathlist=[[2,1,3,2],[1,4,4]]); elt.pp()
          1  2 (X)   1  4  4
          2  3
        sage: elt.right_split().pp()
          1  2 (X)   1  4 (X)   4
          2  3

    Let \(\ast\) denote the `Lusztig involution`, we check that \(\ast \circ \mathrm{ls} \circ \ast = \mathrm{rs}\):

        sage: all(x.lusztig_involution().left_split().lusztig_involution() == x.right_split() for x in KRT)
        True

  `to_rigged_configuration`(display_steps=False)

    Perform the bijection from `self` to a `rigged configuration` which is described in [RigConBijection], [BijectionLRT], and [BijectionDn].

    Note

    This is only proven to be a bijection in types \(A_n^{(1)}\) and \(D_n^{(1)}\), as well as \(\bigotimes_i B^{r_i,1}\) and \(\bigotimes_i B^{1,s_i}\) for general affine types.

    INPUT:

    - `display_steps` – (default: `False`) Boolean which indicates if we want to output each step in the algorithm.

    OUTPUT:

    The rigged configuration corresponding to `self`.

    EXAMPLES:

    Type \(A_n^{(1)}\) example:

        sage: KRT = crystals.TensorProductOfKirillovReshetikhinTableaux(['A', 3, 1], [[2,1], [2,1], [2,1]])
        sage: T = KRT(pathlist=[[4, 2], [3, 1], [2, 1]])
        sage: T
        [[2], [4]] (X) [[1], [3]] (X) [[1], [2]]
        sage: T.to_rigged_configuration()
        <BLANKLINE>
        0[ ]0
        <BLANKLINE>
        1[ ]1
        1[ ]0
        <BLANKLINE>
        0[ ]0
        <BLANKLINE>

    Type \(D_n^{(1)}\) example:

        sage: KRT = crystals.TensorProductOfKirillovReshetikhinTableaux(['D', 4, 1], [[2,2]])
        sage: T = KRT(pathlist=[[2,1,4,3]])
        sage: T
        [[1, 3], [2, 4]]
        sage: T.to_rigged_configuration()
        <BLANKLINE>
        0[ ]0
        <BLANKLINE>
        -1[ ]-1
        -1[ ]-1
        <BLANKLINE>
        0[ ]0
        <BLANKLINE>
        (/)

    Type \(D_n^{(1)}\) spinor example:

        sage: CP = crystals.TensorProductOfKirillovReshetikhinTableaux(['D', 5, 1], [[5,1],[2,1],[1,1],[1,1],[1,1]])
        sage: elt = CP(pathlist=[[-2,-5,4,3,1],[-1,2],[1],[1],[1]])
        sage: elt
        [[1], [3], [4], [-5], [-2]] (X) [[2], [-1]] (X) [[1]] (X) [[1]] (X) [[1]]
        sage: elt.to_rigged_configuration()
        <BLANKLINE>
        2[ ][ ]1
        <BLANKLINE>
        0[ ][ ]0
        0[ ]0
        <BLANKLINE>
        0[ ][ ]0
        0[ ]0
        <BLANKLINE>
        0[ ]0
        <BLANKLINE>
        0[ ][ ]0
        <BLANKLINE>

    This is invertible by calling `to_tensor_product_of_kirillov_reshetikhin_tableaux()`:

        sage: KRT = crystals.TensorProductOfKirillovReshetikhinTableaux(['D', 4, 1], [[2,2]])
        sage: T = KRT(pathlist=[[2,1,4,3]])
        sage: rc = T.to_rigged_configuration()
        sage: ret = rc.to_tensor_product_of_kirillov_reshetikhin_tableaux(); ret
        [[1, 3], [2, 4]]
        sage: ret == T
        True

  `to_tensor_product_of_kirillov_reshetikhin_crystals`()

    Return a tensor product of Kirillov-Reshetikhin crystals corresponding to `self`.

    This works by performing the filling map on each individual factor. For more on the filling map, see `KirillovReshetikhinTableaux`.

    EXAMPLES:

        sage: KRT = crystals.TensorProductOfKirillovReshetikhinTableaux(['D',4,1], [[1,1],[2,2]])
        sage: elt = KRT(pathlist=[[-1],[-1,2,-1,1]]); elt
        [[-1]] (X) [[2, 1], [-1, -1]]
        sage: tp_krc = elt.to_tensor_product_of_kirillov_reshetikhin_crystals(); tp_krc
        [[[-1]], [[2], [-1]]]

    We can recover the original tensor product of KR tableaux:

        sage: ret = KRT(tp_krc); ret
        [[-1]] (X) [[2, 1], [-1, -1]]
        sage: ret == elt
        True

### Navigation

- index
- modules |
- next |
- previous |
- Combinatorics »
- Rigged Configurations »