Root system data for folded Cartan types - Combinatorics

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

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

  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:

  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

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

  Python

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

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

  [Python]

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

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

  Python

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

  - Wikipedia article Dynkin_diagram#Folding

  [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

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

    Python

        >>> from sage.all import *
        >>> fct = CartanType(['C', Integer(4), Integer(1)]).as_folding()
        >>> fct.cartan_type()
        ['C', 4, 1]

  folding_of()

    Return the Cartan type of the virtual space.

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> fct = CartanType(['C', Integer(4), Integer(1)]).as_folding()
        >>> fct.folding_of()
        ['A', 7, 1]

  folding_orbit()

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

    EXAMPLES:

    Sage

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

    Python

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

    Return the scaling factors of `self`.

    EXAMPLES:

    Sage

        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}

    Python

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