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 (non-zero) positive root. The edges are labeled by the coefficients of the roots of the difference.

AUTHORS:

Travis Scrimshaw (2011-05-03): Initial version
Travis Scrimshaw (2013-02-13): Added support for virtual trees and improved \(\LaTeX\) output

EXAMPLES:

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

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

Bases: sage.structure.unique_representation.UniqueRepresentation, sage.structure.parent.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 (non-zero) 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 – a 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: 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

From [Kleber2]:

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

We check that relabelled types work (trac ticket #16876):

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

Element#: alias of KleberTreeNode

breadth_first_iter()#

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

EXAMPLES:

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]

cartan_type()#

Return the Cartan type of this Kleber tree.

EXAMPLES:

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]

depth_first_iter()#

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

EXAMPLES:

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]

digraph()#

Return a DiGraph representation of this Kleber tree.

EXAMPLES:

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

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 – (default: True) display edge labels
use_vector_notation – (default: False) display edge labels using vector notation instead of a linear combination

EXAMPLES:

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

plot(**options)#

Return the plot of self as a directed graph.

EXAMPLES:

sage: from sage.combinat.rigged_configurations.kleber_tree import KleberTree
sage: KT = KleberTree(['D', 4, 1], [[2, 2]])
sage: print(KT.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: sage.structure.element.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: 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

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

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

Bases: sage.combinat.rigged_configurations.kleber_tree.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}\).