Root system data for folded Cartan types¶

AUTHORS:

• Travis Scrimshaw (2013-01-12) - Initial version
class sage.combinat.root_system.type_folded.CartanTypeFolded(cartan_type, folding_of, orbit)

A Cartan type realized from a (Dynkin) diagram folding.

Given a Cartan type $$X$$, we say $$\hat{X}$$ is a folded Cartan type of $$X$$ if there exists a diagram folding of the Dynkin diagram of $$\hat{X}$$ onto $$X$$.

A folding of a simply-laced Dynkin diagram $$D$$ with index set $$I$$ is an automorphism $$\sigma$$ of $$D$$ where all nodes any orbit of $$\sigma$$ are not connected. The resulting Dynkin diagram $$\hat{D}$$ is induced by $$I / \sigma$$ where we identify edges in $$\hat{D}$$ which are not incident and add a $$k$$-edge if we identify $$k$$ incident edges and the arrow is pointing towards the indicent note. We denote the index set of $$\hat{D}$$ by $$\hat{I}$$, and by abuse of notation, we denote the folding by $$\sigma$$.

We also have scaling factors $$\gamma_i$$ for $$i \in \hat{I}$$ and defined as the unique numbers such that the map $$\Lambda_j \mapsto \gamma_j \sum_{i \in \sigma^{-1}(j)} \Lambda_i$$ is the smallest proper embedding of the weight lattice of $$X$$ to $$\hat{X}$$.

If the Cartan type is simply laced, the default folding is the one induced from the identity map on $$D$$.

If $$X$$ is affine type, the default embeddings we consider here are:

$\begin{split}\begin{array}{ccl} 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{array}\end{split}$

and were chosen based on virtual crystals. In particular, the diagram foldings extend to crystal morphisms and gives a realization of Kirillov-Reshetikhin crystals for non-simply-laced types as simply-laced types. See [OSShimo03] and [FOS2009] for more details. Here we can compute $$\gamma_i = \max(c) / c_i$$ where $$(c_i)_i$$ are the translation factors of the root system. In a more type-dependent way, we can define $$\gamma_i$$ as follows:

1. There exists a unique arrow (multiple bond) in $$X$$.
1. Suppose the arrow points towards 0. Then $$\gamma_i = 1$$ for all $$i \in I$$.
2. Otherwise $$\gamma_i$$ is the order of $$\sigma$$ for all $$i$$ in the connected component of 0 after removing the arrow, else $$\gamma_i = 1$$.
2. There is not a unique arrow. Thus $$\hat{X} = A_{2n-1}^{(1)}$$ and $$\gamma_i = 1$$ for all $$1 \leq i \leq n-1$$. If $$i \in \{0, n\}$$, then $$\gamma_i = 2$$ if the arrow incident to $$i$$ points away and is $$1$$ otherwise.

We note that $$\gamma_i$$ only depends upon $$X$$.

If the Cartan type is finite, then we consider the classical foldings/embeddings induced by the above affine foldings/embeddings:

\begin{split}\begin{aligned} C_n & \hookrightarrow A_{2n-1}, \\ B_n & \hookrightarrow D_{n+1}, \\ F_4 & \hookrightarrow E_6, \\ G_2 & \hookrightarrow D_4. \end{aligned}\end{split}

For more information on Cartan types, see sage.combinat.root_system.cartan_type.

Other foldings may be constructed by passing in an optional folding_of second argument. See below.

INPUT:

• cartan_type – the Cartan type $$X$$ to create the folded type
• folding_of – the Cartan type $$\hat{X}$$ which $$X$$ is a folding of
• orbit – the orbit of the Dynkin diagram automorphism $$\sigma$$ given as a list of lists where the $$a$$-th list corresponds to the $$a$$-th entry in $$I$$ or a dictionary with keys in $$I$$ and values as lists

Note

If $$X$$ is an affine type, we assume the special node is fixed under $$\sigma$$.

EXAMPLES:

sage: fct = CartanType(['C',4,1]).as_folding(); fct
['C', 4, 1] as a folding of ['A', 7, 1]
sage: fct.scaling_factors()
Finite family {0: 2, 1: 1, 2: 1, 3: 1, 4: 2}
sage: fct.folding_orbit()
Finite family {0: (0,), 1: (1, 7), 2: (2, 6), 3: (3, 5), 4: (4,)}


A simply laced Cartan type can be considered as a virtual type of itself:

sage: fct = CartanType(['A',4,1]).as_folding(); fct
['A', 4, 1] as a folding of ['A', 4, 1]
sage: fct.scaling_factors()
Finite family {0: 1, 1: 1, 2: 1, 3: 1, 4: 1}
sage: fct.folding_orbit()
Finite family {0: (0,), 1: (1,), 2: (2,), 3: (3,), 4: (4,)}


Finite types:

sage: fct = CartanType(['C',4]).as_folding(); fct
['C', 4] as a folding of ['A', 7]
sage: fct.scaling_factors()
Finite family {1: 1, 2: 1, 3: 1, 4: 2}
sage: fct.folding_orbit()
Finite family {1: (1, 7), 2: (2, 6), 3: (3, 5), 4: (4,)}

sage: fct = CartanType(['F',4]).dual().as_folding(); fct
['F', 4] relabelled by {1: 4, 2: 3, 3: 2, 4: 1} as a folding of ['E', 6]
sage: fct.scaling_factors()
Finite family {1: 1, 2: 1, 3: 2, 4: 2}
sage: fct.folding_orbit()
Finite family {1: (1, 6), 2: (3, 5), 3: (4,), 4: (2,)}


REFERENCES:

 [OSShimo03] M. Okado, A. Schilling, M. Shimozono. “Virtual crystals and fermionic formulas for type $$D_{n+1}^{(2)}$$, $$A_{2n}^{(2)}$$, and $$C_n^{(1)}$$”. Representation Theory. 7 (2003). 101-163. doi:10.1.1.192.2095, arXiv 0810.5067.
cartan_type()

Return the Cartan type of self.

EXAMPLES:

sage: fct = CartanType(['C', 4, 1]).as_folding()
sage: fct.cartan_type()
['C', 4, 1]

folding_of()

Return the Cartan type of the virtual space.

EXAMPLES:

sage: fct = CartanType(['C', 4, 1]).as_folding()
sage: fct.folding_of()
['A', 7, 1]

folding_orbit()

Return the orbits under the automorphism $$\sigma$$ as a dictionary (of tuples).

EXAMPLES:

sage: fct = CartanType(['C', 4, 1]).as_folding()
sage: fct.folding_orbit()
Finite family {0: (0,), 1: (1, 7), 2: (2, 6), 3: (3, 5), 4: (4,)}

scaling_factors()

Return the scaling factors of self.

EXAMPLES:

sage: fct = CartanType(['C', 4, 1]).as_folding()
sage: fct.scaling_factors()
Finite family {0: 2, 1: 1, 2: 1, 3: 1, 4: 2}
sage: fct = CartanType(['BC', 4, 2]).as_folding()
sage: fct.scaling_factors()
Finite family {0: 1, 1: 1, 2: 1, 3: 1, 4: 2}
sage: fct = CartanType(['BC', 4, 2]).dual().as_folding()
sage: fct.scaling_factors()
Finite family {0: 2, 1: 1, 2: 1, 3: 1, 4: 1}
sage: CartanType(['BC', 4, 2]).relabel({0:4, 1:3, 2:2, 3:1, 4:0}).as_folding().scaling_factors()
Finite family {0: 2, 1: 1, 2: 1, 3: 1, 4: 1}