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)[source]¶
- Bases: - UniqueRepresentation,- SageObject- 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: - There exists a unique arrow (multiple bond) in \(X\). - Suppose the arrow points towards 0. Then \(\gamma_i = 1\) for all \(i \in I\). 
- 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\). 
 
- 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_ofsecond 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() # needs sage.graphs 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,)} - >>> from sage.all import * >>> fct = CartanType(['C',Integer(4),Integer(1)]).as_folding(); fct ['C', 4, 1] as a folding of ['A', 7, 1] >>> fct.scaling_factors() # needs sage.graphs Finite family {0: 2, 1: 1, 2: 1, 3: 1, 4: 2} >>> 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() # needs sage.graphs 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,)} - >>> from sage.all import * >>> fct = CartanType(['A',Integer(4),Integer(1)]).as_folding(); fct ['A', 4, 1] as a folding of ['A', 4, 1] >>> fct.scaling_factors() # needs sage.graphs Finite family {0: 1, 1: 1, 2: 1, 3: 1, 4: 1} >>> 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,)} - >>> from sage.all import * >>> fct = CartanType(['C',Integer(4)]).as_folding(); fct ['C', 4] as a folding of ['A', 7] >>> fct.scaling_factors() Finite family {1: 1, 2: 1, 3: 1, 4: 2} >>> fct.folding_orbit() Finite family {1: (1, 7), 2: (2, 6), 3: (3, 5), 4: (4,)} >>> fct = CartanType(['F',Integer(4)]).dual().as_folding(); fct ['F', 4] relabelled by {1: 4, 2: 3, 3: 2, 4: 1} as a folding of ['E', 6] >>> fct.scaling_factors() Finite family {1: 1, 2: 1, 3: 2, 4: 2} >>> 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()[source]¶
- Return the Cartan type of - self.- EXAMPLES: - sage: fct = CartanType(['C', 4, 1]).as_folding() sage: fct.cartan_type() ['C', 4, 1] - >>> from sage.all import * >>> fct = CartanType(['C', Integer(4), Integer(1)]).as_folding() >>> fct.cartan_type() ['C', 4, 1] 
 - folding_of()[source]¶
- Return the Cartan type of the virtual space. - EXAMPLES: - sage: fct = CartanType(['C', 4, 1]).as_folding() sage: fct.folding_of() ['A', 7, 1] - >>> from sage.all import * >>> fct = CartanType(['C', Integer(4), Integer(1)]).as_folding() >>> fct.folding_of() ['A', 7, 1] 
 - folding_orbit()[source]¶
- 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,)} - >>> from sage.all import * >>> fct = CartanType(['C', Integer(4), Integer(1)]).as_folding() >>> fct.folding_orbit() Finite family {0: (0,), 1: (1, 7), 2: (2, 6), 3: (3, 5), 4: (4,)} 
 - scaling_factors()[source]¶
- Return the scaling factors of - self.- EXAMPLES: - sage: # needs sage.graphs 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} - >>> from sage.all import * >>> # needs sage.graphs >>> fct = CartanType(['C', Integer(4), Integer(1)]).as_folding() >>> fct.scaling_factors() Finite family {0: 2, 1: 1, 2: 1, 3: 1, 4: 2} >>> fct = CartanType(['BC', Integer(4), Integer(2)]).as_folding() >>> fct.scaling_factors() Finite family {0: 1, 1: 1, 2: 1, 3: 1, 4: 2} >>> fct = CartanType(['BC', Integer(4), Integer(2)]).dual().as_folding() >>> fct.scaling_factors() Finite family {0: 2, 1: 1, 2: 1, 3: 1, 4: 1} >>> CartanType(['BC', Integer(4), Integer(2)]).relabel({Integer(0):Integer(4), Integer(1):Integer(3), Integer(2):Integer(2), Integer(3):Integer(1), Integer(4):Integer(0)}).as_folding().scaling_factors() Finite family {0: 2, 1: 1, 2: 1, 3: 1, 4: 1}