Folded Cartan Types

AUTHORS:

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

Bases: sage.structure.sage_object.SageObject, sage.structure.unique_representation.UniqueRepresentation

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 [FOS09] 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}

Previous topic

Coxeter matrices

Next topic

Root systems

This Page