### Navigation

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

# Rigged Configurations

AUTHORS:

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

`sage.combinat.rigged_configurations.rigged_configurations.``HighestWeightRiggedConfigurations`(cartan_type, B)

  Deprecated in trac ticket #13872. Use instead the attribute `module_generators` of `RiggedConfigurations`.

  EXAMPLES:

      sage: HighestWeightRiggedConfigurations(['A',2,1], [[1,1]])
      doctest:...: DeprecationWarning: this class is deprecated.
       Use RiggedConfigurations(cartan_type, B).module_generators instead
      See http://trac.sagemath.org/13872 for details.
      (
      <BLANKLINE>
      (/)
      <BLANKLINE>
      (/)
      <BLANKLINE>
      )

`sage.combinat.rigged_configurations.rigged_configurations.``KirillovReshetikhinCrystal`(cartan_type, r, s)

  Return the KR crystal \(B^{r,s}\) using `rigged configurations`.

  This is the rigged configuration \(RC(B^{r,s})\) or \(RC(L)\) with \(L = (L_i^{(a)})\) and \(L_i^{(a)} = \delta_{a,r} \delta_{i,s}\).

  EXAMPLES:

      sage: K1 = crystals.kirillov_reshetikhin.RiggedConfigurations(['A',6,2], 2, 1)
      sage: K2 = crystals.kirillov_reshetikhin.LSPaths(['A',6,2], 2, 1)
      sage: K1.digraph().is_isomorphic(K2.digraph(), edge_labels=True)
      True

  TESTS:

  We explicitly import and check we get the same crystal:

      sage: from sage.combinat.rigged_configurations.rigged_configurations import KirillovReshetikhinCrystal
      sage: K1 = crystals.kirillov_reshetikhin.RiggedConfigurations(['A',6,2], 2, 1)
      sage: K1 is KirillovReshetikhinCrystal(['A',6,2], 2, 1)
      True

class `sage.combinat.rigged_configurations.rigged_configurations.``RCNonSimplyLaced`(cartan_type, dims)

  Bases: `sage.combinat.rigged_configurations.rigged_configurations.RiggedConfigurations`

  Rigged configurations in non-simply-laced types.

  These are rigged configurations which lift to virtual rigged configurations in a simply-laced type.

  For more on rigged configurations, see `RiggedConfigurations`.

  `Element`

    alias of `KRRCNonSimplyLacedElement`

  `from_virtual`(vrc)

    Convert `vrc` in the virtual crystal into a rigged configution of the original Cartan type.

    INPUT:

    - `vrc` – a virtual rigged configuration

    EXAMPLES:

        sage: RC = RiggedConfigurations(['C',2,1], [[1,2],[1,1],[2,1]])
        sage: elt = RC(partition_list=[[3],[2]])
        sage: vrc_elt = RC.to_virtual(elt)
        sage: ret = RC.from_virtual(vrc_elt); ret
        <BLANKLINE>
        0[ ][ ][ ]0
        <BLANKLINE>
        0[ ][ ]0
        sage: ret == elt
        True

  `kleber_tree`()

    Return the underlying (virtual) Kleber tree used to generate all highest weight rigged configurations.

    EXAMPLES:

        sage: RC = RiggedConfigurations(['C',3,1], [[1,1], [2,1]])
        sage: RC.kleber_tree()
        Virtual Kleber tree of Cartan type ['C', 3, 1] and B = ((1, 1), (2, 1))

  `module_generators`()

    Module generators for this set of rigged configurations.

    Iterate over the highest weight rigged configurations by moving through the `KleberTree` and then setting appropriate values of the partitions.

    EXAMPLES:

        sage: RC = RiggedConfigurations(['C', 3, 1], [[1,2]])
        sage: for x in RC.module_generators: x
        <BLANKLINE>
        (/)
        <BLANKLINE>
        (/)
        <BLANKLINE>
        (/)
        <BLANKLINE>
        <BLANKLINE>
        0[ ][ ]0
        <BLANKLINE>
        0[ ][ ]0
        <BLANKLINE>
        0[ ]0
        <BLANKLINE>

        sage: RC = RiggedConfigurations(['D',4,3], [[1,1]])
        sage: RC.module_generators
        (
        <BLANKLINE>
             0[ ]0
        (/)  0[ ]0
        <BLANKLINE>
        (/)  0[ ]0
           ,
        )

  `to_virtual`(rc)

    Convert `rc` into a rigged configuration in the virtual crystal.

    INPUT:

    - `rc` – a rigged configuration element

    EXAMPLES:

        sage: RC = RiggedConfigurations(['C',2,1], [[1,2],[1,1],[2,1]])
        sage: elt = RC(partition_list=[[3],[2]]); elt
        <BLANKLINE>
        0[ ][ ][ ]0
        <BLANKLINE>
        0[ ][ ]0
        sage: velt = RC.to_virtual(elt); velt
        <BLANKLINE>
        0[ ][ ][ ]0
        <BLANKLINE>
        0[ ][ ][ ][ ]0
        <BLANKLINE>
        0[ ][ ][ ]0
        sage: velt.parent()
        Rigged configurations of type ['A', 3, 1] and factor(s) ((1, 2), (3, 2), (1, 1), (3, 1), (2, 2))

  `virtual`()

    Return the corresponding virtual crystal.

    EXAMPLES:

        sage: RC = RiggedConfigurations(['C',2,1], [[1,2],[1,1],[2,1]])
        sage: RC
        Rigged configurations of type ['C', 2, 1] and factor(s) ((1, 2), (1, 1), (2, 1))
        sage: RC.virtual
        Rigged configurations of type ['A', 3, 1] and factor(s) ((1, 2), (3, 2), (1, 1), (3, 1), (2, 2))

class `sage.combinat.rigged_configurations.rigged_configurations.``RCTypeA2Dual`(cartan_type, dims)

  Bases: `sage.combinat.rigged_configurations.rigged_configurations.RCTypeA2Even`

  Rigged configurations of type \(A_{2n}^{(2)\dagger}\).

  For more on rigged configurations, see `RiggedConfigurations`.

  EXAMPLES:

      sage: RC = RiggedConfigurations(CartanType(['A',4,2]).dual(), [[1,2],[1,1],[2,1]])
      sage: RC
      Rigged configurations of type ['BC', 2, 2]^* and factor(s) ((1, 2), (1, 1), (2, 1))
      sage: RC.cardinality()
      750
      sage: RC.virtual
      Rigged configurations of type ['A', 3, 1] and factor(s) ((1, 2), (3, 2), (1, 1), (3, 1), (2, 1), (2, 1))
      sage: RC = RiggedConfigurations(CartanType(['A',2,2]).dual(), [[1,1]])
      sage: RC.cardinality()
      3
      sage: RC = RiggedConfigurations(CartanType(['A',2,2]).dual(), [[1,2],[1,1]])
      sage: TestSuite(RC).run() # long time
      sage: RC = RiggedConfigurations(CartanType(['A',4,2]).dual(), [[2,1]])
      sage: TestSuite(RC).run() # long time

  `Element`

    alias of `KRRCTypeA2DualElement`

  `from_virtual`(vrc)

    Convert `vrc` in the virtual crystal into a rigged configution of the original Cartan type.

    INPUT:

    - `vrc` – a virtual rigged configuration element

    EXAMPLES:

        sage: RC = RiggedConfigurations(CartanType(['A',4,2]).dual(), [[2,2]])
        sage: elt = RC(partition_list=[[1],[1]])
        sage: velt = RC.to_virtual(elt)
        sage: ret = RC.from_virtual(velt); ret
        <BLANKLINE>
        -1[ ]-1
        <BLANKLINE>
        1[ ]1
        <BLANKLINE>
        sage: ret == elt
        True

  `module_generators`()

    Module generators for rigged configurations of type \(A_{2n}^{(2)\dagger}\).

    Iterate over the highest weight rigged configurations by moving through the `KleberTree` and then setting appropriate values of the partitions. This also skips rigged configurations where \(P_i^{(n)} < 1\) when \(i\) is odd.

    EXAMPLES:

        sage: RC = RiggedConfigurations(CartanType(['A', 4, 2]).dual(), [[1,1]])
        sage: for x in RC.module_generators: x
        <BLANKLINE>
        (/)
        <BLANKLINE>
        (/)
        <BLANKLINE>

  `to_virtual`(rc)

    Convert `rc` into a rigged configuration in the virtual crystal.

    INPUT:

    - `rc` – a rigged configuration element

    EXAMPLES:

        sage: RC = RiggedConfigurations(CartanType(['A',4,2]).dual(), [[2,2]])
        sage: elt = RC(partition_list=[[1],[1]]); elt
        <BLANKLINE>
        -1[ ]-1
        <BLANKLINE>
        1[ ]1
        <BLANKLINE>
        sage: velt = RC.to_virtual(elt); velt
        <BLANKLINE>
        -1[ ]-1
        <BLANKLINE>
        2[ ]2
        <BLANKLINE>
        -1[ ]-1
        <BLANKLINE>
        sage: velt.parent()
        Rigged configurations of type ['A', 3, 1] and factor(s) ((2, 2), (2, 2))

class `sage.combinat.rigged_configurations.rigged_configurations.``RCTypeA2Even`(cartan_type, dims)

  Bases: `sage.combinat.rigged_configurations.rigged_configurations.RCNonSimplyLaced`

  Rigged configurations for type \(A_{2n}^{(2)}\).

  For more on rigged configurations, see `RiggedConfigurations`.

  EXAMPLES:

      sage: RC = RiggedConfigurations(['A',4,2], [[2,1], [1,2]])
      sage: RC.cardinality()
      150
      sage: RC = RiggedConfigurations(['A',2,2], [[1,1]])
      sage: RC.cardinality()
      3
      sage: RC = RiggedConfigurations(['A',2,2], [[1,2],[1,1]])
      sage: TestSuite(RC).run() # long time
      sage: RC = RiggedConfigurations(['A',4,2], [[2,1]])
      sage: TestSuite(RC).run() # long time

  `cardinality`()

    Return the cardinality of `self`.

    EXAMPLES:

        sage: RC = RiggedConfigurations(['A',4,2], [[1,1], [2,2]])
        sage: RC.cardinality()
        250

  `from_virtual`(vrc)

    Convert `vrc` in the virtual crystal into a rigged configution of the original Cartan type.

    INPUT:

    - `vrc` – a virtual rigged configuration element

    EXAMPLES:

        sage: RC = RiggedConfigurations(['A',4,2], [[2,2]])
        sage: elt = RC(partition_list=[[1],[1]])
        sage: velt = RC.to_virtual(elt)
        sage: ret = RC.from_virtual(velt); ret
        <BLANKLINE>
        -1[ ]-1
        <BLANKLINE>
        1[ ]1
        <BLANKLINE>
        sage: ret == elt
        True

  `to_virtual`(rc)

    Convert `rc` into a rigged configuration in the virtual crystal.

    INPUT:

    - `rc` – a rigged configuration element

    EXAMPLES:

        sage: RC = RiggedConfigurations(['A',4,2], [[2,2]])
        sage: elt = RC(partition_list=[[1],[1]]); elt
        <BLANKLINE>
        -1[ ]-1
        <BLANKLINE>
        1[ ]1
        <BLANKLINE>
        sage: velt = RC.to_virtual(elt); velt
        <BLANKLINE>
        -1[ ]-1
        <BLANKLINE>
        2[ ]2
        <BLANKLINE>
        -1[ ]-1
        <BLANKLINE>
        sage: velt.parent()
        Rigged configurations of type ['A', 3, 1] and factor(s) ((2, 2), (2, 2))

  `virtual`()

    Return the corresponding virtual crystal.

    EXAMPLES:

        sage: RC = RiggedConfigurations(['A',4,2], [[1,2],[1,1],[2,1]])
        sage: RC
        Rigged configurations of type ['BC', 2, 2] and factor(s) ((1, 2), (1, 1), (2, 1))
        sage: RC.virtual
        Rigged configurations of type ['A', 3, 1] and factor(s) ((1, 2), (3, 2), (1, 1), (3, 1), (2, 1), (2, 1))

class `sage.combinat.rigged_configurations.rigged_configurations.``RiggedConfigurations`(cartan_type, B)

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

  Rigged configurations as \(U_q^{\prime}(\mathfrak{g})\)-crystals.

  Let \(\overline{I}\) denote the classical index set associated to the Cartan type of the rigged configurations. A rigged configuration of multiplicity array \(L_i^{(a)}\) and dominant weight \(\Lambda\) is a sequence of partitions \(\{ \nu^{(a)} \mid a \in \overline{I} \}\) such that

  \[\begin{split}\sum_{\overline{I} \times \mathbb{Z}_{>0}} i m_i^{(a)} \alpha_a = \sum_{\overline{I} \times \mathbb{Z}_{>0}} i L_i^{(a)} \Lambda_a - \Lambda\end{split}\]

  where \(\alpha_a\) is a simple root, \(\Lambda_a\) is a fundamental weight, and \(m_i^{(a)}\) is the number of rows of length \(i\) in the partition \(\nu^{(a)}\).

  Each partition \(\nu^{(a)}\), in the sequence also comes with a sequence of statistics \(p_i^{(a)}\) called vacancy numbers and a weakly decreasing sequence \(J_i^{(a)}\) of length \(m_i^{(a)}\) called riggings. Vacancy numbers are computed based upon the partitions and \(L_i^{(a)}\), and the riggings must satisfy \(\max J_i^{(a)} \leq p_i^{(a)}\). We call such a partition a rigged partition. For more, see [RigConBijection] [CrysStructSchilling06] [BijectionLRT].

  Rigged configurations form combinatorial objects first introduced by Kerov, Kirillov and Reshetikhin that arose from studies of statistical mechanical models using the Bethe Ansatz. They are sequences of rigged partitions. A rigged partition is a partition together with a label associated to each part that satisfy certain constraints. The labels are also called riggings.

  Rigged configurations exist for all affine Kac-Moody Lie algebras. See for example [HKOTT2002]. In Sage they are specified by providing a Cartan type and a list of rectangular shapes \(B\). The list of all (highest weight) rigged configurations for given \(B\) is computed via the (virtual) Kleber algorithm (see also `KleberTree` and `VirtualKleberTree`).

  Rigged configurations in simply-laced types all admit a classical crystal structure [CrysStructSchilling06]. For non-simply-laced types, the crystal is given by using virtual rigged configurations [OSS03]. The highest weight rigged configurations are those where all riggings are nonnegative. The list of all rigged configurations is computed from the highest weight ones using the crystal operators.

  Rigged configurations are conjecturally in bijection with `TensorProductOfKirillovReshetikhinTableaux` of non-exceptional affine types where the list \(B\) corresponds to the tensor factors \(B^{r,s}\). The bijection has been proven in types \(A_n^{(1)}\) and \(D_n^{(1)}\) and when the only non-zero entries of \(L_i^{(a)}\) are either only \(L_1^{(a)}\) or only \(L_i^{(1)}\) (corresponding to single columns or rows respectively) [RigConBijection], [BijectionLRT], [BijectionDn].

  KR crystals are implemented in Sage, see `KirillovReshetikhinCrystal()`, however, in the bijection with rigged configurations a different realization of the elements in the crystal are obtained, which are coined KR tableaux, see `KirillovReshetikhinTableaux`. For more details see [OSS2011].

  Note

  All non-simply-laced rigged configurations have not been proven to give rise to aligned virtual crystals (i.e. have the correct crystal structure or ismorphic as affine crystals to the tensor product of KR tableaux).

  INPUT:

  - `cartan_type` – a Cartan type
  - `B` – a list of positive integer tuples \((r,s)\) corresponding to the tensor factors in the bijection with tensor product of Kirillov-Reshetikhin tableaux or equivalently the sequence of width \(s\) and height \(r\) rectangles

  REFERENCES:

  [HKOTT2002] | (1, 2) G. Hatayama, A. Kuniba, M. Okado, T. Takagi, Z. Tsuboi. Paths, Crystals and Fermionic Formulae. Prog. Math. Phys. 23 (2002) Pages 205-272.

  [CrysStructSchilling06] | (1, 2) Anne Schilling. Crystal structure on rigged configurations. International Mathematics Research Notices. Volume 2006. (2006) Article ID 97376. Pages 1-27.

  [RigConBijection] | (1, 2) Masato Okado, Anne Schilling, Mark Shimozono. A crystal to rigged configuration bijection for non-exceptional affine algebras. Algebraic Combinatorics and Quantum Groups. Edited by N. Jing. World Scientific. (2003) Pages 85-124.

  [BijectionDn] | (1, 2) Anne Schilling. A bijection between type \(D_n^{(1)}\) crystals and rigged configurations. J. Algebra. 285 (2005) 292-334

  [BijectionLRT] | (1, 2, 3) Anatol N. Kirillov, Anne Schilling, Mark Shimozono. A bijection between Littlewood-Richardson tableaux and rigged configurations. Selecta Mathematica (N.S.). 8 (2002) Pages 67-135. (MathSciNet MR1890195).

  EXAMPLES:

      sage: RC = RiggedConfigurations(['A', 3, 1], [[3, 2], [1, 2], [1, 1]])
      sage: RC
      Rigged configurations of type ['A', 3, 1] and factor(s) ((3, 2), (1, 2), (1, 1))

      sage: RC = RiggedConfigurations(['A', 3, 1], [[2,1]]); RC
      Rigged configurations of type ['A', 3, 1] and factor(s) ((2, 1),)
      sage: RC.cardinality()
      6
      sage: len(RC.list()) == RC.cardinality()
      True
      sage: RC.list()
      [
      <BLANKLINE>
                                               0[ ]0
      (/)  (/)      (/)      -1[ ]-1  -1[ ]-1
                                               -1[ ]-1
      (/)  -1[ ]-1  0[ ]0    0[ ]0    1[ ]1    -1[ ]-1
      <BLANKLINE>
      (/)  (/)      -1[ ]-1  (/)      -1[ ]-1  0[ ]0
         ,        ,        ,        ,        ,
      ]

  A rigged configuration element with all riggings equal to the vacancy numbers can be created as follows:

      sage: RC = RiggedConfigurations(['A', 3, 1], [[3,2], [2,1], [1,1], [1,1]]); RC
      Rigged configurations of type ['A', 3, 1] and factor(s) ((3, 2), (2, 1), (1, 1), (1, 1))
      sage: elt = RC(partition_list=[[1],[],[]]); elt
      <BLANKLINE>
      0[ ]0
      <BLANKLINE>
      (/)
      <BLANKLINE>
      (/)
      <BLANKLINE>

  If on the other hand we also want to specify the riggings, this can be achieved as follows:

      sage: RC = RiggedConfigurations(['A', 3, 1], [[3, 2], [1, 2], [1, 1]])
      sage: RC(partition_list=[[2],[2],[2]])
      <BLANKLINE>
      1[ ][ ]1
      <BLANKLINE>
      0[ ][ ]0
      <BLANKLINE>
      0[ ][ ]0
      sage: RC(partition_list=[[2],[2],[2]], rigging_list=[[0],[0],[0]])
      <BLANKLINE>
      1[ ][ ]0
      <BLANKLINE>
      0[ ][ ]0
      <BLANKLINE>
      0[ ][ ]0

  A larger example:

      sage: RC = RiggedConfigurations(['D', 7, 1], [[3,3],[5,2],[4,3],[2,3],[4,4],[3,1],[1,4],[2,2]])
      sage: elt = RC(partition_list=[[2],[3,2,1],[2,2,1,1],[2,2,1,1,1,1],[3,2,1,1,1,1],[2,1,1],[2,2]],
      ....:          rigging_list=[[2],[1,0,0],[4,1,2,1],[1,0,0,0,0,0],[0,1,0,0,0,0],[0,0,0],[0,0]])
      sage: elt
      <BLANKLINE>
      3[ ][ ]2
      <BLANKLINE>
      1[ ][ ][ ]1
      2[ ][ ]0
      1[ ]0
      <BLANKLINE>
      4[ ][ ]4
      4[ ][ ]1
      3[ ]2
      3[ ]1
      <BLANKLINE>
      2[ ][ ]1
      2[ ][ ]0
      0[ ]0
      0[ ]0
      0[ ]0
      0[ ]0
      <BLANKLINE>
      0[ ][ ][ ]0
      2[ ][ ]1
      0[ ]0
      0[ ]0
      0[ ]0
      0[ ]0
      <BLANKLINE>
      0[ ][ ]0
      0[ ]0
      0[ ]0
      <BLANKLINE>
      0[ ][ ]0
      0[ ][ ]0
      <BLANKLINE>

  To obtain the KR tableau under the bijection between rigged configurations and KR tableaux, we can type the following. This example was checked against Reiho Sakamoto’s Mathematica program on rigged configurations:

      sage: output = elt.to_tensor_product_of_kirillov_reshetikhin_tableaux(); output
      [[1, 1, 1], [2, 3, 3], [3, 4, -5]] (X) [[1, 1], [2, 2], [3, 3], [5, -6], [6, -5]] (X)
      [[1, 1, 2], [2, 2, 3], [3, 3, 7], [4, 4, -7]] (X) [[1, 1, 1], [2, 2, 2]] (X)
      [[1, 1, 1, 3], [2, 2, 3, 4], [3, 3, 4, 5], [4, 4, 5, 6]] (X) [[1], [2], [3]] (X) [[1, 1, 1, 1]] (X) [[1, 1], [2, 2]]
      sage: elt.to_tensor_product_of_kirillov_reshetikhin_tableaux().to_rigged_configuration() == elt
      True
      sage: output.to_rigged_configuration().to_tensor_product_of_kirillov_reshetikhin_tableaux() == output
      True

  We can also convert between rigged configurations and tensor products of KR crystals:

      sage: RC = RiggedConfigurations(['D', 4, 1], [[2, 1]])
      sage: elt = RC(partition_list=[[1],[1,1],[1],[1]])
      sage: tp_krc = elt.to_tensor_product_of_kirillov_reshetikhin_crystals(); tp_krc
      [[]]
      sage: ret = RC(tp_krc)
      sage: ret == elt
      True

      sage: RC = RiggedConfigurations(['D', 4, 1], [[4,1], [3,3]])
      sage: KR1 = crystals.KirillovReshetikhin(['D', 4, 1], 4, 1)
      sage: KR2 = crystals.KirillovReshetikhin(['D', 4, 1], 3, 3)
      sage: T = crystals.TensorProduct(KR1, KR2)
      sage: t = T[1]; t
      [[++++, []], [+++-, [[1], [2], [4], [-4]]]]
      sage: ret = RC(t)
      sage: ret.to_tensor_product_of_kirillov_reshetikhin_crystals()
      [[++++, []], [+++-, [[1], [2], [4], [-4]]]]

  TESTS:

      sage: RC = RiggedConfigurations(['A', 3, 1], [[3,2], [2,1], [1,1], [1,1]])
      sage: len(RC.module_generators)
      17
      sage: RC = RiggedConfigurations(['D', 4, 1], [[1, 1]])
      sage: RC.cardinality()
      8

      sage: RC = RiggedConfigurations(['D', 4, 1], [[2, 1]])
      sage: c = RC.cardinality(); c
      29
      sage: K = crystals.KirillovReshetikhin(['D',4,1],2,1)
      sage: K.cardinality() == c
      True

  `Element`

    alias of `KRRCSimplyLacedElement`

  `cardinality`()

    Return the cardinality of `self`.

    EXAMPLES:

        sage: RC = RiggedConfigurations(['A', 3, 1], [[3, 2], [1, 2]])
        sage: RC.cardinality()
        100
        sage: RC = RiggedConfigurations(['B', 3, 1], [[2,2],[1,2]])
        sage: RC.cardinality()
        5130
        sage: RC = RiggedConfigurations(['E', 7, 1], [[1,1]])
        sage: RC.cardinality()
        134

  `fermionic_formula`(q=None, only_highest_weight=False, weight=None)

    Return the fermoinic formula associated to `self`.

    Given a set of rigged configurations \(RC(\lambda, L)\), the fermonic formula is defined as:

    \[M(\lambda, L; q) = \sum_{(\nu,J)} q^{cc(\nu, J)}\]

    where we sum over all (classically highest weight) rigged configurations of weight \(\lambda\) where \(cc\) is the `cocharge statistic`. This is known to reduce to

    \[\begin{split}M(\lambda, L; q) = \sum_{\nu} q^{cc(\nu)} \prod_{(a,i) \in I \times \ZZ} \begin{bmatrix} p_i^{(a)} + m_i^{(a)} \\ m_i^{(a)} \end{bmatrix}_q.\end{split}\]

    The generating function of \(M(\lambda, L; q)\) in the weight algebra subsumes all fermionic formulas:

    \[M(L; q) = \sum_{\lambda \in P} M(\lambda, L; q) \lambda.\]

    This is conjecturally equal to the `one dimensional configuration sum` of the corresponding tensor product of Kirillov-Reshetikhin crystals, see [HKOTT2002]. This has been proven in general for type \(A_n^{(1)}\) [BijectionLRT], single factors \(B^{r,s}\) in type \(D_n^{(1)}\) [OSS2011] with the result from [Sakamoto13], as well as for a tensor product of single columns [OSS2003], [BijectionDn] or a tensor product of single rows [OSS03] for all non-exceptional types.

    INPUT:

    - `q` – the variable \(q\)
    - `only_highest_weight` – use only the classicaly highest weight rigged configurations
    - `weight` – return the fermionic formula \(M(\lambda, L; q)\) where \(\lambda\) is the classical weight `weight`

    REFERENCES:

    [OSS2003] | Masato Okado, Anne Schilling, and Mark Shimozono. Virtual crystals and fermionic formulas of type \(D_{n+1}^{(2)}\), \(A_{2n}^{(2)}\), and \(C_n^{(1)}\). Representation Theory. 7 (2003) Arxiv math.QA/0105017.

    [Sakamoto13] | Reiho Sakamoto. Rigged configurations and Kashiwara operators. (2013) Arxiv 1302.4562v1.

    EXAMPLES:

        sage: RC = RiggedConfigurations(['A', 2, 1], [[1,1], [1,1]])
        sage: RC.fermionic_formula()
        B[-2*Lambda[1] + 2*Lambda[2]] + (q+1)*B[-Lambda[1]]
         + (q+1)*B[Lambda[1] - Lambda[2]] + B[2*Lambda[1]]
         + B[-2*Lambda[2]] + (q+1)*B[Lambda[2]]
        sage: t = QQ['t'].gen(0)
        sage: RC.fermionic_formula(t)
        B[-2*Lambda[1] + 2*Lambda[2]] + (t+1)*B[-Lambda[1]]
         + (t+1)*B[Lambda[1] - Lambda[2]] + B[2*Lambda[1]]
         + B[-2*Lambda[2]] + (t+1)*B[Lambda[2]]
        sage: La = RC.weight_lattice_realization().classical().fundamental_weights()
        sage: RC.fermionic_formula(weight=La[2])
        q + 1
        sage: RC.fermionic_formula(only_highest_weight=True, weight=La[2])
        q

    Only using the highest weight elements on other types:

        sage: RC = RiggedConfigurations(['A', 3, 1], [[3,1], [2,2]])
        sage: RC.fermionic_formula(only_highest_weight=True)
        q*B[Lambda[1] + Lambda[2]] + B[2*Lambda[2] + Lambda[3]]
        sage: RC = RiggedConfigurations(['D', 4, 1], [[3,1], [4,1], [2,1]])
        sage: RC.fermionic_formula(only_highest_weight=True)
        (q^4+q^3+q^2)*B[Lambda[1]] + (q^2+q)*B[Lambda[1] + Lambda[2]]
         + q*B[Lambda[1] + 2*Lambda[3]] + q*B[Lambda[1] + 2*Lambda[4]]
         + B[Lambda[2] + Lambda[3] + Lambda[4]] + (q^3+2*q^2+q)*B[Lambda[3] + Lambda[4]]
        sage: RC = RiggedConfigurations(['E', 6, 1], [[2,2]])
        sage: RC.fermionic_formula(only_highest_weight=True)
        q^2*B[0] + q*B[Lambda[2]] + B[2*Lambda[2]]
        sage: RC = RiggedConfigurations(['B', 3, 1], [[3,1], [2,2]])
        sage: RC.fermionic_formula(only_highest_weight=True) # long time
        q*B[Lambda[1] + Lambda[2] + Lambda[3]] + q^2*B[Lambda[1]
         + Lambda[3]] + (q^2+q)*B[Lambda[2] + Lambda[3]] + B[2*Lambda[2]
         + Lambda[3]] + (q^3+q^2)*B[Lambda[3]]
        sage: RC = RiggedConfigurations(['C', 3, 1], [[3,1], [2,2]])
        sage: RC.fermionic_formula(only_highest_weight=True) # long time
        (q^3+q^2)*B[Lambda[1] + Lambda[2]] + q*B[Lambda[1] + 2*Lambda[2]]
         + (q^2+q)*B[2*Lambda[1] + Lambda[3]] + B[2*Lambda[2] + Lambda[3]]
         + (q^4+q^3+q^2)*B[Lambda[3]]
        sage: RC = RiggedConfigurations(['D', 4, 2], [[3,1], [2,2]])
        sage: RC.fermionic_formula(only_highest_weight=True) # long time
        (q^2+q)*B[Lambda[1] + Lambda[2] + Lambda[3]] + (q^5+2*q^4+q^3)*B[Lambda[1]
         + Lambda[3]] + (q^3+q^2)*B[2*Lambda[1] + Lambda[3]] + (q^4+q^3+q^2)*B[Lambda[2]
         + Lambda[3]] + B[2*Lambda[2] + Lambda[3]] + (q^6+q^5+q^4)*B[Lambda[3]]
        sage: RC = RiggedConfigurations(CartanType(['A',4,2]).dual(), [[1,1],[2,2]])
        sage: RC.fermionic_formula(only_highest_weight=True)
        (q^3+q^2)*B[Lambda[1]] + (q^2+q)*B[Lambda[1] + 2*Lambda[2]]
         + B[Lambda[1] + 4*Lambda[2]] + q*B[3*Lambda[1]] + q*B[4*Lambda[2]]

    TESTS:

        sage: RC = RiggedConfigurations(['A', 2, 1], [[1,1], [1,1]])
        sage: KR = RC.tensor_product_of_kirillov_reshetikhin_crystals()
        sage: RC.fermionic_formula() == KR.one_dimensional_configuration_sum()
        True
        sage: KT = RC.tensor_product_of_kirillov_reshetikhin_tableaux()
        sage: RC.fermionic_formula() == KT.one_dimensional_configuration_sum()
        True
        sage: RC = RiggedConfigurations(['C', 2, 1], [[2,1], [2,1]])
        sage: KR = RC.tensor_product_of_kirillov_reshetikhin_crystals()
        sage: RC.fermionic_formula() == KR.one_dimensional_configuration_sum() # long time
        True
        sage: t = QQ['t'].gen(0)
        sage: RC = RiggedConfigurations(['D', 4, 1], [[1,1], [2,1]])
        sage: KR = RC.tensor_product_of_kirillov_reshetikhin_crystals()
        sage: RC.fermionic_formula(t) == KR.one_dimensional_configuration_sum(t) # long time
        True

  `global_options`(*get_value, **set_value)

    Sets and displays the global options for rigged configurations. If no parameters are set, then the function returns a copy of the options dictionary.

    The `options` to partitions can be accessed as the method `RiggedConfigurations.global_options` of `RiggedConfigurations`.

    OPTIONS:

    - `convention` – (default: `English`) Sets the convention used for displaying tableaux and partitions
      - `English` – use the English convention
      - `French` – use the French convention
    - `display` – (default: `vertical`) Specifies how rigged configurations should be printed
      - `horizontal` – displayed horizontally
      - `vertical` – displayed vertically
    - `element_ascii_art` – (default: `True`) display using the repr option `element_ascii_art`
    - `half_width_boxes_type_b` – (default: `True`) display the last rigged partition in affine type B as half width boxes
    - `notation` – alternative name for `convention`

    EXAMPLES:

        sage: RC = RiggedConfigurations(['A',3,1], [[2,2],[1,1],[1,1]])
        sage: elt = RC(partition_list=[[3,1], [3], [1]])
        sage: elt
        <BLANKLINE>
        -3[ ][ ][ ]-3
        -1[ ]-1
        <BLANKLINE>
        1[ ][ ][ ]1
        <BLANKLINE>
        -1[ ]-1
        <BLANKLINE>
        sage: RiggedConfigurations.global_options(display="horizontal", convention="french")
        sage: elt
        -1[ ]-1         1[ ][ ][ ]1   -1[ ]-1
        -3[ ][ ][ ]-3

    Changing the `convention` for rigged configurations also changes the `convention` option for tableaux and vice versa:

        sage: T = Tableau([[1,2,3],[4,5]])
        sage: T.pp()
          4  5
          1  2  3
        sage: Tableaux.global_options(convention="english")
        sage: elt
        -3[ ][ ][ ]-3   1[ ][ ][ ]1   -1[ ]-1
        -1[ ]-1
        sage: T.pp()
          1  2  3
          4  5
        sage: RiggedConfigurations.global_options.reset()

    See `GlobalOptions` for more features of these options.

  `kleber_tree`()

    Return the underlying Kleber tree used to generate all highest weight rigged configurations.

    EXAMPLES:

        sage: RC = RiggedConfigurations(['A',3,1], [[1,1], [2,1]])
        sage: RC.kleber_tree()
        Kleber tree of Cartan type ['A', 3, 1] and B = ((1, 1), (2, 1))

  `module_generators`()

    Module generators for this set of rigged configurations.

    Iterate over the highest weight rigged configurations by moving through the `KleberTree` and then setting appropriate values of the partitions.

    EXAMPLES:

        sage: RC = RiggedConfigurations(['D', 4, 1], [[2,1]])
        sage: for x in RC.module_generators: x
        <BLANKLINE>
        (/)
        <BLANKLINE>
        (/)
        <BLANKLINE>
        (/)
        <BLANKLINE>
        (/)
        <BLANKLINE>
        <BLANKLINE>
        0[ ]0
        <BLANKLINE>
        0[ ]0
        0[ ]0
        <BLANKLINE>
        0[ ]0
        <BLANKLINE>
        0[ ]0
        <BLANKLINE>

    TESTS:

    We check that this works with relabelled Cartan types (trac ticket #16876):

        sage: ct = CartanType(['A',3,1]).relabel(lambda x: x+2)
        sage: RC = RiggedConfigurations(ct, [[4,1],[5,1]])
        sage: len(RC.module_generators)
        2
        sage: ct = CartanType(['A',3,1]).relabel(lambda x: (x+2) % 4)
        sage: RC = RiggedConfigurations(ct, [[0,1],[1,1]])
        sage: len(RC.module_generators)
        2

  `tensor`(*crystals, **options)

    Return the tensor product of `self` with `crystals`.

    If `crystals` is a list of rigged configurations of the same Cartan type, then this returns a new `RiggedConfigurations`.

    EXAMPLES:

        sage: RC = RiggedConfigurations(['A', 3, 1], [[2,1],[1,3]])
        sage: RC2 = RiggedConfigurations(['A', 3, 1], [[1,1], [3,3]])
        sage: RC.tensor(RC2, RC2)
        Rigged configurations of type ['A', 3, 1]
         and factor(s) ((2, 1), (1, 3), (1, 1), (3, 3), (1, 1), (3, 3))

        sage: K = crystals.KirillovReshetikhin(['A', 3, 1], 2, 2, model='KR')
        sage: RC.tensor(K)
        Full tensor product of the crystals
         [Rigged configurations of type ['A', 3, 1] and factor(s) ((2, 1), (1, 3)),
          Kirillov-Reshetikhin tableaux of type ['A', 3, 1] and shape (2, 2)]

  `tensor_product_of_kirillov_reshetikhin_crystals`()

    Return the corresponding tensor product of Kirillov-Reshetikhin crystals.

    EXAMPLES:

        sage: RC = RiggedConfigurations(['A', 3, 1], [[3,1],[2,2]])
        sage: RC.tensor_product_of_kirillov_reshetikhin_crystals()
        Full tensor product of the crystals
        [Kirillov-Reshetikhin crystal of type ['A', 3, 1] with (r,s)=(3,1),
         Kirillov-Reshetikhin crystal of type ['A', 3, 1] with (r,s)=(2,2)]

  `tensor_product_of_kirillov_reshetikhin_tableaux`()

    Return the corresponding tensor product of Kirillov-Reshetikhin tableaux.

    EXAMPLES:

        sage: RC = RiggedConfigurations(['A', 3, 1], [[3, 2], [1, 2]])
        sage: RC.tensor_product_of_kirillov_reshetikhin_tableaux()
        Tensor product of Kirillov-Reshetikhin tableaux of type ['A', 3, 1] and factor(s) ((3, 2), (1, 2))

### Navigation

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