Kleber trees - Combinatorics

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

# Kleber trees

A Kleber tree is a tree of weights generated by Kleber’s algorithm [Kleber1]. The nodes correspond to the weights in the positive Weyl chamber obtained by subtracting a (nonzero) positive root. The edges are labeled by the coefficients of the roots of the difference.

EXAMPLES:

Sage

    sage: from sage.combinat.rigged_configurations.kleber_tree import KleberTree
    sage: KleberTree(['A', 3, 1], [[3,2], [2,1], [1,1], [1,1]])
    Kleber tree of Cartan type ['A', 3, 1] and B = ((3, 2), (2, 1), (1, 1), (1, 1))
    sage: KleberTree(['D', 4, 1], [[2,2]])
    Kleber tree of Cartan type ['D', 4, 1] and B = ((2, 2),)

Python

    >>> from sage.all import *
    >>> from sage.combinat.rigged_configurations.kleber_tree import KleberTree
    >>> KleberTree(['A', Integer(3), Integer(1)], [[Integer(3),Integer(2)], [Integer(2),Integer(1)], [Integer(1),Integer(1)], [Integer(1),Integer(1)]])
    Kleber tree of Cartan type ['A', 3, 1] and B = ((3, 2), (2, 1), (1, 1), (1, 1))
    >>> KleberTree(['D', Integer(4), Integer(1)], [[Integer(2),Integer(2)]])
    Kleber tree of Cartan type ['D', 4, 1] and B = ((2, 2),)

AUTHORS:

- Travis Scrimshaw (2011-05-03): initial version

- Travis Scrimshaw (2013-02-13): added support for virtual trees and improved \(\LaTeX\) output

class sage.combinat.rigged_configurations.kleber_tree.KleberTree(cartan_type, B, classical_ct)

  Bases: `UniqueRepresentation`, `Parent`

  The tree that is generated by Kleber’s algorithm.

  A Kleber tree is a tree of weights generated by Kleber’s algorithm [Kleber1]. It is used to generate the set of all admissible rigged configurations for the simply-laced affine types \(A_n^{(1)}\), \(D_n^{(1)}\), \(E_6^{(1)}\), \(E_7^{(1)}\), and \(E_8^{(1)}\).

  See also

  There is a modified version for non-simply-laced affine types at `VirtualKleberTree`.

  The nodes correspond to the weights in the positive Weyl chamber obtained by subtracting a (nonzero) positive root. The edges are labeled by the coefficients of the roots, and \(X\) is a child of \(Y\) if \(Y\) is the root else if the edge label of \(Y\) to its parent \(Z\) is greater (in every component) than the label from \(X\) to \(Y\).

  For a Kleber tree, one needs to specify an affine (simply-laced) Cartan type and a sequence of pairs \((r,s)\), where \(s\) is any positive integer and \(r\) is a node in the Dynkin diagram. Each \((r,s)\) can be viewed as a rectangle of width \(s\) and height \(r\).

  INPUT:

  - `cartan_type` – an affine simply-laced Cartan type

  - `B` – list of dimensions of rectangles by \([r, c]\) where \(r\) is the number of rows and \(c\) is the number of columns

  REFERENCES:

  [Kleber1] (1,2)

  Michael Kleber. Combinatorial structure of finite dimensional representations of Yangians: the simply-laced case. Internat. Math. Res. Notices. (1997) no. 4. 187-201.

  [Kleber2]

  Michael Kleber. Finite dimensional representations of quantum affine algebras. Ph.D. dissertation at University of California Berkeley. (1998). arXiv math.QA/9809087.

  EXAMPLES:

  Simply-laced example:

  Sage

      sage: from sage.combinat.rigged_configurations.kleber_tree import KleberTree
      sage: KT = KleberTree(['A', 3, 1], [[3,2], [1,1]])
      sage: KT.list()
      [Kleber tree node with weight [1, 0, 2] and upwards edge root [0, 0, 0],
       Kleber tree node with weight [0, 0, 1] and upwards edge root [1, 1, 1]]
      sage: KT = KleberTree(['A', 3, 1], [[3,2], [2,1], [1,1], [1,1]])
      sage: KT.cardinality()
      10
      sage: KT = KleberTree(['D', 4, 1], [[2,2]])
      sage: KT.cardinality()
      3
      sage: KT = KleberTree(['D', 4, 1], [[4,5]])
      sage: KT.cardinality()
      1

  Python

      >>> from sage.all import *
      >>> from sage.combinat.rigged_configurations.kleber_tree import KleberTree
      >>> KT = KleberTree(['A', Integer(3), Integer(1)], [[Integer(3),Integer(2)], [Integer(1),Integer(1)]])
      >>> KT.list()
      [Kleber tree node with weight [1, 0, 2] and upwards edge root [0, 0, 0],
       Kleber tree node with weight [0, 0, 1] and upwards edge root [1, 1, 1]]
      >>> KT = KleberTree(['A', Integer(3), Integer(1)], [[Integer(3),Integer(2)], [Integer(2),Integer(1)], [Integer(1),Integer(1)], [Integer(1),Integer(1)]])
      >>> KT.cardinality()
      10
      >>> KT = KleberTree(['D', Integer(4), Integer(1)], [[Integer(2),Integer(2)]])
      >>> KT.cardinality()
      3
      >>> KT = KleberTree(['D', Integer(4), Integer(1)], [[Integer(4),Integer(5)]])
      >>> KT.cardinality()
      1

  From [Kleber2]:

  Sage

      sage: KT = KleberTree(['E', 6, 1], [[4, 2]])  # long time (9s on sage.math, 2012)
      sage: KT.cardinality()  # long time
      12

  [Python]

      >>> from sage.all import *
      >>> KT = KleberTree(['E', Integer(6), Integer(1)], [[Integer(4), Integer(2)]])  # long time (9s on sage.math, 2012)
      >>> KT.cardinality()  # long time
      12

  We check that relabelled types work (Issue #16876):

  Sage

      sage: ct = CartanType(['A',3,1]).relabel(lambda x: x+2)
      sage: kt = KleberTree(ct, [[3,1],[5,1]])
      sage: list(kt)
      [Kleber tree node with weight [1, 0, 1] and upwards edge root [0, 0, 0],
       Kleber tree node with weight [0, 0, 0] and upwards edge root [1, 1, 1]]
      sage: kt = KleberTree(['A',3,1], [[1,1],[3,1]])
      sage: list(kt)
      [Kleber tree node with weight [1, 0, 1] and upwards edge root [0, 0, 0],
       Kleber tree node with weight [0, 0, 0] and upwards edge root [1, 1, 1]]

  Python

      >>> from sage.all import *
      >>> ct = CartanType(['A',Integer(3),Integer(1)]).relabel(lambda x: x+Integer(2))
      >>> kt = KleberTree(ct, [[Integer(3),Integer(1)],[Integer(5),Integer(1)]])
      >>> list(kt)
      [Kleber tree node with weight [1, 0, 1] and upwards edge root [0, 0, 0],
       Kleber tree node with weight [0, 0, 0] and upwards edge root [1, 1, 1]]
      >>> kt = KleberTree(['A',Integer(3),Integer(1)], [[Integer(1),Integer(1)],[Integer(3),Integer(1)]])
      >>> list(kt)
      [Kleber tree node with weight [1, 0, 1] and upwards edge root [0, 0, 0],
       Kleber tree node with weight [0, 0, 0] and upwards edge root [1, 1, 1]]

  Element

    alias of `KleberTreeNode`

  breadth_first_iter()

    Iterate over all nodes in the tree following a breadth-first traversal.

    EXAMPLES:

    Sage

        sage: from sage.combinat.rigged_configurations.kleber_tree import KleberTree
        sage: KT = KleberTree(['A', 3, 1], [[2, 2], [2, 3]])
        sage: for x in KT.breadth_first_iter(): x
        Kleber tree node with weight [0, 5, 0] and upwards edge root [0, 0, 0]
        Kleber tree node with weight [1, 3, 1] and upwards edge root [0, 1, 0]
        Kleber tree node with weight [0, 3, 0] and upwards edge root [1, 2, 1]
        Kleber tree node with weight [2, 1, 2] and upwards edge root [0, 1, 0]
        Kleber tree node with weight [1, 1, 1] and upwards edge root [0, 1, 0]
        Kleber tree node with weight [0, 1, 0] and upwards edge root [1, 2, 1]

    Python

        >>> from sage.all import *
        >>> from sage.combinat.rigged_configurations.kleber_tree import KleberTree
        >>> KT = KleberTree(['A', Integer(3), Integer(1)], [[Integer(2), Integer(2)], [Integer(2), Integer(3)]])
        >>> for x in KT.breadth_first_iter(): x
        Kleber tree node with weight [0, 5, 0] and upwards edge root [0, 0, 0]
        Kleber tree node with weight [1, 3, 1] and upwards edge root [0, 1, 0]
        Kleber tree node with weight [0, 3, 0] and upwards edge root [1, 2, 1]
        Kleber tree node with weight [2, 1, 2] and upwards edge root [0, 1, 0]
        Kleber tree node with weight [1, 1, 1] and upwards edge root [0, 1, 0]
        Kleber tree node with weight [0, 1, 0] and upwards edge root [1, 2, 1]

  cartan_type()

    Return the Cartan type of this Kleber tree.

    EXAMPLES:

    Sage

        sage: from sage.combinat.rigged_configurations.kleber_tree import KleberTree
        sage: KT = KleberTree(['A', 3, 1], [[1,1]])
        sage: KT.cartan_type()
        ['A', 3, 1]

    Python

        >>> from sage.all import *
        >>> from sage.combinat.rigged_configurations.kleber_tree import KleberTree
        >>> KT = KleberTree(['A', Integer(3), Integer(1)], [[Integer(1),Integer(1)]])
        >>> KT.cartan_type()
        ['A', 3, 1]

  depth_first_iter()

    Iterate (recursively) over the nodes in the tree following a depth-first traversal.

    EXAMPLES:

    Sage

        sage: from sage.combinat.rigged_configurations.kleber_tree import KleberTree
        sage: KT = KleberTree(['A', 3, 1], [[2, 2], [2, 3]])
        sage: for x in KT.depth_first_iter(): x
        Kleber tree node with weight [0, 5, 0] and upwards edge root [0, 0, 0]
        Kleber tree node with weight [1, 3, 1] and upwards edge root [0, 1, 0]
        Kleber tree node with weight [2, 1, 2] and upwards edge root [0, 1, 0]
        Kleber tree node with weight [0, 3, 0] and upwards edge root [1, 2, 1]
        Kleber tree node with weight [1, 1, 1] and upwards edge root [0, 1, 0]
        Kleber tree node with weight [0, 1, 0] and upwards edge root [1, 2, 1]

    Python

        >>> from sage.all import *
        >>> from sage.combinat.rigged_configurations.kleber_tree import KleberTree
        >>> KT = KleberTree(['A', Integer(3), Integer(1)], [[Integer(2), Integer(2)], [Integer(2), Integer(3)]])
        >>> for x in KT.depth_first_iter(): x
        Kleber tree node with weight [0, 5, 0] and upwards edge root [0, 0, 0]
        Kleber tree node with weight [1, 3, 1] and upwards edge root [0, 1, 0]
        Kleber tree node with weight [2, 1, 2] and upwards edge root [0, 1, 0]
        Kleber tree node with weight [0, 3, 0] and upwards edge root [1, 2, 1]
        Kleber tree node with weight [1, 1, 1] and upwards edge root [0, 1, 0]
        Kleber tree node with weight [0, 1, 0] and upwards edge root [1, 2, 1]

  digraph()

    Return a DiGraph representation of this Kleber tree.

    EXAMPLES:

    Sage

        sage: from sage.combinat.rigged_configurations.kleber_tree import KleberTree
        sage: KT = KleberTree(['D', 4, 1], [[2, 2]])
        sage: KT.digraph()
        Digraph on 3 vertices

    Python

        >>> from sage.all import *
        >>> from sage.combinat.rigged_configurations.kleber_tree import KleberTree
        >>> KT = KleberTree(['D', Integer(4), Integer(1)], [[Integer(2), Integer(2)]])
        >>> KT.digraph()
        Digraph on 3 vertices

  latex_options(**options)

    Return the current latex options if no arguments are passed, otherwise set the corresponding latex option.

    OPTIONS:

    - `hspace` – (default: \(2.5\)) the horizontal spacing of the tree nodes

    - `vspace` – (default: `x`) the vertical spacing of the tree nodes, here `x` is the minimum of \(-2.5\) or \(-.75n\) where \(n\) is the rank of the classical type

    - `edge_labels` – boolean (default: `True`); display edge labels

    - `use_vector_notation` – boolean (default: `False`); display edge labels using vector notation instead of a linear combination

    EXAMPLES:

    Sage

        sage: from sage.combinat.rigged_configurations.kleber_tree import KleberTree
        sage: KT = KleberTree(['D', 3, 1], [[2,1], [2,1]])
        sage: KT.latex_options(vspace=-4, use_vector_notation=True)
        sage: sorted(KT.latex_options().items())
        [('edge_labels', True), ('hspace', 2.5), ('use_vector_notation', True), ('vspace', -4)]

    Python

        >>> from sage.all import *
        >>> from sage.combinat.rigged_configurations.kleber_tree import KleberTree
        >>> KT = KleberTree(['D', Integer(3), Integer(1)], [[Integer(2),Integer(1)], [Integer(2),Integer(1)]])
        >>> KT.latex_options(vspace=-Integer(4), use_vector_notation=True)
        >>> sorted(KT.latex_options().items())
        [('edge_labels', True), ('hspace', 2.5), ('use_vector_notation', True), ('vspace', -4)]

  plot(**options)

    Return the plot of `self` as a directed graph.

    EXAMPLES:

    Sage

        sage: from sage.combinat.rigged_configurations.kleber_tree import KleberTree
        sage: KT = KleberTree(['D', 4, 1], [[2, 2]])
        sage: print(KT.plot())                                                      # needs sage.plot
        Graphics object consisting of 8 graphics primitives

    Python

        >>> from sage.all import *
        >>> from sage.combinat.rigged_configurations.kleber_tree import KleberTree
        >>> KT = KleberTree(['D', Integer(4), Integer(1)], [[Integer(2), Integer(2)]])
        >>> print(KT.plot())                                                      # needs sage.plot
        Graphics object consisting of 8 graphics primitives

class sage.combinat.rigged_configurations.kleber_tree.KleberTreeNode(parent_obj, node_weight, dominant_root, parent_node=None)

  Bases: `Element`

  A node in the Kleber tree.

  This class is meant to be used internally by the Kleber tree class and should not be created directly by the user.

  For more on the Kleber tree and the nodes, see `KleberTree`.

  The dominating root is the `up_root` which is the difference between the parent node’s weight and this node’s weight.

  INPUT:

  - `parent_obj` – the parent object of this element

  - `node_weight` – the weight of this node

  - `dominant_root` – the dominating root

  - `parent_node` – (default: `None`) the parent node of this node

  depth()

    Return the depth of this node in the tree.

    EXAMPLES:

    Sage

        sage: from sage.combinat.rigged_configurations.kleber_tree import KleberTree
        sage: RS = RootSystem(['A', 2])
        sage: WS = RS.weight_lattice()
        sage: R = RS.root_lattice()
        sage: KT = KleberTree(['A', 2, 1], [[1,1]])
        sage: n = KT(WS.sum_of_terms([(1,5), (2,2)]), R.zero())
        sage: n.depth
        0
        sage: n2 = KT(WS.sum_of_terms([(1,5), (2,2)]), R.zero(), n)
        sage: n2.depth
        1

    Python

        >>> from sage.all import *
        >>> from sage.combinat.rigged_configurations.kleber_tree import KleberTree
        >>> RS = RootSystem(['A', Integer(2)])
        >>> WS = RS.weight_lattice()
        >>> R = RS.root_lattice()
        >>> KT = KleberTree(['A', Integer(2), Integer(1)], [[Integer(1),Integer(1)]])
        >>> n = KT(WS.sum_of_terms([(Integer(1),Integer(5)), (Integer(2),Integer(2))]), R.zero())
        >>> n.depth
        0
        >>> n2 = KT(WS.sum_of_terms([(Integer(1),Integer(5)), (Integer(2),Integer(2))]), R.zero(), n)
        >>> n2.depth
        1

  multiplicity()

    Return the multiplicity of `self`.

    The multiplicity of a node \(x\) of depth \(d\) weight \(\lambda\) in a simply-laced Kleber tree is equal to:

    \[\prod_{i > 0} \prod_{a \in \overline{I}} \binom{p_i^{(a)} + m_i^{(a)}}{p_i^{(a)}}\]

    Recall that

    \[ \begin{align}\begin{aligned}m_i^{(a)} = \left( \lambda^{(i-1)} - 2 \lambda^{(i)} + \lambda^{(i+1)} \mid \overline{\Lambda}_a \right),\\p_i^{(a)} = \left( \alpha_a \mid \lambda^{(i)} \right) - \sum_{j > i} (j - i) L_j^{(a)},\end{aligned}\end{align} \]

    where \(\lambda^{(i)}\) is the weight node at depth \(i\) in the path to \(x\) from the root and we set \(\lambda^{(j)} = \lambda\) for all \(j \geq d\).

    Note that \(m_i^{(a)} = 0\) for all \(i > d\).

    EXAMPLES:

    Sage

        sage: from sage.combinat.rigged_configurations.kleber_tree import KleberTree
        sage: KT = KleberTree(['A',3,1], [[3,2],[2,1],[1,1],[1,1]])
        sage: for x in KT: x, x.multiplicity()
        (Kleber tree node with weight [2, 1, 2] and upwards edge root [0, 0, 0], 1)
        (Kleber tree node with weight [3, 0, 1] and upwards edge root [0, 1, 1], 1)
        (Kleber tree node with weight [0, 2, 2] and upwards edge root [1, 0, 0], 1)
        (Kleber tree node with weight [1, 0, 3] and upwards edge root [1, 1, 0], 2)
        (Kleber tree node with weight [1, 1, 1] and upwards edge root [1, 1, 1], 4)
        (Kleber tree node with weight [0, 0, 2] and upwards edge root [2, 2, 1], 2)
        (Kleber tree node with weight [2, 0, 0] and upwards edge root [0, 1, 1], 2)
        (Kleber tree node with weight [0, 0, 2] and upwards edge root [1, 1, 0], 1)
        (Kleber tree node with weight [0, 1, 0] and upwards edge root [1, 1, 1], 2)
        (Kleber tree node with weight [0, 1, 0] and upwards edge root [0, 0, 1], 1)

    Python

        >>> from sage.all import *
        >>> from sage.combinat.rigged_configurations.kleber_tree import KleberTree
        >>> KT = KleberTree(['A',Integer(3),Integer(1)], [[Integer(3),Integer(2)],[Integer(2),Integer(1)],[Integer(1),Integer(1)],[Integer(1),Integer(1)]])
        >>> for x in KT: x, x.multiplicity()
        (Kleber tree node with weight [2, 1, 2] and upwards edge root [0, 0, 0], 1)
        (Kleber tree node with weight [3, 0, 1] and upwards edge root [0, 1, 1], 1)
        (Kleber tree node with weight [0, 2, 2] and upwards edge root [1, 0, 0], 1)
        (Kleber tree node with weight [1, 0, 3] and upwards edge root [1, 1, 0], 2)
        (Kleber tree node with weight [1, 1, 1] and upwards edge root [1, 1, 1], 4)
        (Kleber tree node with weight [0, 0, 2] and upwards edge root [2, 2, 1], 2)
        (Kleber tree node with weight [2, 0, 0] and upwards edge root [0, 1, 1], 2)
        (Kleber tree node with weight [0, 0, 2] and upwards edge root [1, 1, 0], 1)
        (Kleber tree node with weight [0, 1, 0] and upwards edge root [1, 1, 1], 2)
        (Kleber tree node with weight [0, 1, 0] and upwards edge root [0, 0, 1], 1)

class sage.combinat.rigged_configurations.kleber_tree.KleberTreeTypeA2Even(cartan_type, B)

  Bases: `VirtualKleberTree`

  Kleber tree for types \(A_{2n}^{(2)}\) and \(A_{2n}^{(2)\dagger}\).

  Note that here for \(A_{2n}^{(2)}\) we use \(\tilde{\gamma}_a\) in place of \(\gamma_a\) in constructing the virtual Kleber tree, and so we end up selecting all nodes since \(\tilde{\gamma}_a = 1\) for all \(a \in \overline{I}\). For type \(A_{2n}^{(2)\dagger}\), we have \(\gamma_a = 1\) for all \(a \in \overline{I}\).

  See also

  `VirtualKleberTree`

  breadth_first_iter(all_nodes=False)

    Iterate over all nodes in the tree following a breadth-first traversal.

    INPUT:

    - `all_nodes` – boolean (default: `False`); if `True`, output all nodes in the tree

    EXAMPLES:

    Sage

        sage: from sage.combinat.rigged_configurations.kleber_tree import VirtualKleberTree
        sage: KT = VirtualKleberTree(['A', 4, 2], [[2,1]])
        sage: for x in KT.breadth_first_iter(): x
        Kleber tree node with weight [0, 2, 0] and upwards edge root [0, 0, 0]
        Kleber tree node with weight [1, 0, 1] and upwards edge root [0, 1, 0]
        Kleber tree node with weight [0, 0, 0] and upwards edge root [1, 2, 1]
        sage: for x in KT.breadth_first_iter(True): x
        Kleber tree node with weight [0, 2, 0] and upwards edge root [0, 0, 0]
        Kleber tree node with weight [1, 0, 1] and upwards edge root [0, 1, 0]
        Kleber tree node with weight [0, 0, 0] and upwards edge root [1, 2, 1]

    Python

        >>> from sage.all import *
        >>> from sage.combinat.rigged_configurations.kleber_tree import VirtualKleberTree
        >>> KT = VirtualKleberTree(['A', Integer(4), Integer(2)], [[Integer(2),Integer(1)]])
        >>> for x in KT.breadth_first_iter(): x
        Kleber tree node with weight [0, 2, 0] and upwards edge root [0, 0, 0]
        Kleber tree node with weight [1, 0, 1] and upwards edge root [0, 1, 0]
        Kleber tree node with weight [0, 0, 0] and upwards edge root [1, 2, 1]
        >>> for x in KT.breadth_first_iter(True): x
        Kleber tree node with weight [0, 2, 0] and upwards edge root [0, 0, 0]
        Kleber tree node with weight [1, 0, 1] and upwards edge root [0, 1, 0]
        Kleber tree node with weight [0, 0, 0] and upwards edge root [1, 2, 1]

  depth_first_iter(all_nodes=False)

    Iterate (recursively) over the nodes in the tree following a depth-first traversal.

    INPUT:

    - `all_nodes` – boolean (default: `False`); if `True`, output all nodes in the tree

    EXAMPLES:

    Sage

        sage: from sage.combinat.rigged_configurations.kleber_tree import VirtualKleberTree
        sage: KT = VirtualKleberTree(['A', 4, 2], [[2,1]])
        sage: for x in KT.depth_first_iter(): x
        Kleber tree node with weight [0, 2, 0] and upwards edge root [0, 0, 0]
        Kleber tree node with weight [1, 0, 1] and upwards edge root [0, 1, 0]
        Kleber tree node with weight [0, 0, 0] and upwards edge root [1, 2, 1]
        sage: for x in KT.depth_first_iter(True): x
        Kleber tree node with weight [0, 2, 0] and upwards edge root [0, 0, 0]
        Kleber tree node with weight [1, 0, 1] and upwards edge root [0, 1, 0]
        Kleber tree node with weight [0, 0, 0] and upwards edge root [1, 2, 1]

    Python

        >>> from sage.all import *
        >>> from sage.combinat.rigged_configurations.kleber_tree import VirtualKleberTree
        >>> KT = VirtualKleberTree(['A', Integer(4), Integer(2)], [[Integer(2),Integer(1)]])
        >>> for x in KT.depth_first_iter(): x
        Kleber tree node with weight [0, 2, 0] and upwards edge root [0, 0, 0]
        Kleber tree node with weight [1, 0, 1] and upwards edge root [0, 1, 0]
        Kleber tree node with weight [0, 0, 0] and upwards edge root [1, 2, 1]
        >>> for x in KT.depth_first_iter(True): x
        Kleber tree node with weight [0, 2, 0] and upwards edge root [0, 0, 0]
        Kleber tree node with weight [1, 0, 1] and upwards edge root [0, 1, 0]
        Kleber tree node with weight [0, 0, 0] and upwards edge root [1, 2, 1]

class sage.combinat.rigged_configurations.kleber_tree.VirtualKleberTree(cartan_type, B)

  Bases: `KleberTree`

  A virtual Kleber tree.

  We can use a modified version of the Kleber algorithm called the virtual Kleber algorithm [OSS03] to compute all admissible rigged configurations for non-simply-laced types. This uses the following embeddings into the simply-laced types:

  \[ \begin{align}\begin{aligned}C_n^{(1)}, A_{2n}^{(2)}, A_{2n}^{(2)\dagger}, D_{n+1}^{(2)} \hookrightarrow A_{2n-1}^{(1)}\\A_{2n-1}^{(2)}, B_n^{(1)} \hookrightarrow D_{n+1}^{(1)}\\E_6^{(2)}, F_4^{(1)} \hookrightarrow E_6^{(1)}\\D_4^{(3)}, G_2^{(1)} \hookrightarrow D_4^{(1)}\end{aligned}\end{align} \]

  One then selects the subset of admissible nodes which are translates of the virtual requirements. In the graph, the selected nodes are indicated by brackets \([]\).

  Note

  Because these are virtual nodes, all information is given in the corresponding simply-laced type.

  See also

  For more on the Kleber algorithm, see `KleberTree`.

  REFERENCES:

  [OSS03]

  Masato Okado, Anne Schilling, and Mark Shimozono. Virtual crystals and Klebers algorithm. Commun. Math. Phys. 238 (2003). 187-209. arXiv math.QA/0209082.

  INPUT:

  - `cartan_type` – an affine non-simply-laced Cartan type

  - `B` – list of dimensions of rectangles by \([r, c]\) where \(r\) is the number of rows and \(c\) is the number of columns

  EXAMPLES:

  Sage

      sage: from sage.combinat.rigged_configurations.kleber_tree import VirtualKleberTree
      sage: KT = VirtualKleberTree(['C', 4, 1], [[2,2]])
      sage: KT.cardinality()
      3
      sage: KT.base_tree().cardinality()
      6
      sage: KT = VirtualKleberTree(['C', 4, 1], [[4,5]])
      sage: KT.cardinality()
      1
      sage: KT = VirtualKleberTree(['D', 5, 2], [[2,1], [1,1]])
      sage: KT.cardinality()
      8
      sage: KT = VirtualKleberTree(CartanType(['A', 4, 2]).dual(), [[1,1], [2,2]])
      sage: KT.cardinality()
      15

  Python

      >>> from sage.all import *
      >>> from sage.combinat.rigged_configurations.kleber_tree import VirtualKleberTree
      >>> KT = VirtualKleberTree(['C', Integer(4), Integer(1)], [[Integer(2),Integer(2)]])
      >>> KT.cardinality()
      3
      >>> KT.base_tree().cardinality()
      6
      >>> KT = VirtualKleberTree(['C', Integer(4), Integer(1)], [[Integer(4),Integer(5)]])
      >>> KT.cardinality()
      1
      >>> KT = VirtualKleberTree(['D', Integer(5), Integer(2)], [[Integer(2),Integer(1)], [Integer(1),Integer(1)]])
      >>> KT.cardinality()
      8
      >>> KT = VirtualKleberTree(CartanType(['A', Integer(4), Integer(2)]).dual(), [[Integer(1),Integer(1)], [Integer(2),Integer(2)]])
      >>> KT.cardinality()
      15

  base_tree()

    Return the underlying virtual Kleber tree associated to `self`.

    EXAMPLES:

    Sage

        sage: from sage.combinat.rigged_configurations.kleber_tree import VirtualKleberTree
        sage: KT = VirtualKleberTree(['C', 4, 1], [[2,2]])
        sage: KT.base_tree()
        Kleber tree of Cartan type ['A', 7, 1] and B = ((2, 2), (6, 2))

    Python

        >>> from sage.all import *
        >>> from sage.combinat.rigged_configurations.kleber_tree import VirtualKleberTree
        >>> KT = VirtualKleberTree(['C', Integer(4), Integer(1)], [[Integer(2),Integer(2)]])
        >>> KT.base_tree()
        Kleber tree of Cartan type ['A', 7, 1] and B = ((2, 2), (6, 2))

  breadth_first_iter(all_nodes=False)

    Iterate over all nodes in the tree following a breadth-first traversal.

    INPUT:

    - `all_nodes` – boolean (default: `False`); if `True`, output all nodes in the tree

    EXAMPLES:

    Sage

        sage: from sage.combinat.rigged_configurations.kleber_tree import VirtualKleberTree
        sage: KT = VirtualKleberTree(['C', 2, 1], [[1,1], [2,1]])
        sage: for x in KT.breadth_first_iter(): x
        Kleber tree node with weight [1, 2, 1] and upwards edge root [0, 0, 0]
        Kleber tree node with weight [1, 0, 1] and upwards edge root [0, 1, 0]
        sage: for x in KT.breadth_first_iter(True): x
        Kleber tree node with weight [1, 2, 1] and upwards edge root [0, 0, 0]
        Kleber tree node with weight [0, 2, 0] and upwards edge root [1, 1, 1]
        Kleber tree node with weight [1, 0, 1] and upwards edge root [0, 1, 0]

    Python

        >>> from sage.all import *
        >>> from sage.combinat.rigged_configurations.kleber_tree import VirtualKleberTree
        >>> KT = VirtualKleberTree(['C', Integer(2), Integer(1)], [[Integer(1),Integer(1)], [Integer(2),Integer(1)]])
        >>> for x in KT.breadth_first_iter(): x
        Kleber tree node with weight [1, 2, 1] and upwards edge root [0, 0, 0]
        Kleber tree node with weight [1, 0, 1] and upwards edge root [0, 1, 0]
        >>> for x in KT.breadth_first_iter(True): x
        Kleber tree node with weight [1, 2, 1] and upwards edge root [0, 0, 0]
        Kleber tree node with weight [0, 2, 0] and upwards edge root [1, 1, 1]
        Kleber tree node with weight [1, 0, 1] and upwards edge root [0, 1, 0]

  depth_first_iter(all_nodes=False)

    Iterate (recursively) over the nodes in the tree following a depth-first traversal.

    INPUT:

    - `all_nodes` – boolean (default: `False`); if `True`, output all nodes in the tree

    EXAMPLES:

    Sage

        sage: from sage.combinat.rigged_configurations.kleber_tree import VirtualKleberTree
        sage: KT = VirtualKleberTree(['C', 2, 1], [[1,1], [2,1]])
        sage: for x in KT.depth_first_iter(): x
        Kleber tree node with weight [1, 2, 1] and upwards edge root [0, 0, 0]
        Kleber tree node with weight [1, 0, 1] and upwards edge root [0, 1, 0]
        sage: for x in KT.depth_first_iter(True): x
        Kleber tree node with weight [1, 2, 1] and upwards edge root [0, 0, 0]
        Kleber tree node with weight [0, 2, 0] and upwards edge root [1, 1, 1]
        Kleber tree node with weight [1, 0, 1] and upwards edge root [0, 1, 0]

    Python

        >>> from sage.all import *
        >>> from sage.combinat.rigged_configurations.kleber_tree import VirtualKleberTree
        >>> KT = VirtualKleberTree(['C', Integer(2), Integer(1)], [[Integer(1),Integer(1)], [Integer(2),Integer(1)]])
        >>> for x in KT.depth_first_iter(): x
        Kleber tree node with weight [1, 2, 1] and upwards edge root [0, 0, 0]
        Kleber tree node with weight [1, 0, 1] and upwards edge root [0, 1, 0]
        >>> for x in KT.depth_first_iter(True): x
        Kleber tree node with weight [1, 2, 1] and upwards edge root [0, 0, 0]
        Kleber tree node with weight [0, 2, 0] and upwards edge root [1, 1, 1]
        Kleber tree node with weight [1, 0, 1] and upwards edge root [0, 1, 0]