Ticket #13838: trac_13871-virtual_cartan_type-ts.patch

sage/combinat/root_system/all.py

@@ -2 +2 @@
 lazy_import('sage.combinat.root_system.associahedron', 'Associahedron')
 
 from cartan_type import CartanType
+from virtual_cartan_type import VirtualCartanType
 from dynkin_diagram import DynkinDiagram, dynkin_diagram
 from cartan_matrix import cartan_matrix
 from coxeter_matrix import coxeter_matrix

sage/combinat/root_system/cartan_type.py

@@ -400 +400 @@
             t = args
         if isinstance(t, CartanType_abstract):
             return t
+        from sage.combinat.root_system.virtual_cartan_type import VirtualCartanType
+        if isinstance(t, VirtualCartanType):
+            return t.cartan_type
         if hasattr(t, "cartan_type"):
             return  t.cartan_type()
 
@@ -1235 +1238 @@
             O---O---O---O=<=O
             2   2   2   2   4
 
+        TESTS:
+
+        Check that this is compatible with :class:`VirtualCartanType`::
+
+            sage: vct = VirtualCartanType(['C', 4, 1])
+            sage: CartanType(vct)
+            ['C', 4, 1]
         """
         from sage.matrix.constructor import matrix, diagonal_matrix
         m = self.cartan_matrix()

sage/combinat/root_system/type_relabel.py

@@ -79 +79 @@
             B4
 
         And relabel its nodes::
-        
+
             sage: cycle = {1:2, 2:3, 3:4, 4:1}
 
             sage: T = T.relabel(cycle)
@@ -229 +229 @@
         """
         EXAMPLES::
 
-           sage: ct = CartanType(['F', 4]).dual()
-           sage: ct.is_irreducible()
-           True
+            sage: ct = CartanType(['G', 2]).relabel({1:2,2:1})
+            sage: ct.is_irreducible()
+            True
         """
         return self._type.is_irreducible()
         
@@ -239 +239 @@
         """
         EXAMPLES::
 
-           sage: ct = CartanType(['F', 4]).dual()
-           sage: ct.is_finite()
-           True
+            sage: ct = CartanType(['G', 2]).relabel({1:2,2:1})
+            sage: ct.is_finite()
+            True
         """
         return self._type.is_finite()
 
@@ -249 +249 @@
         """
         EXAMPLES::
 
-           sage: ct = CartanType(['F', 4]).dual()
-           sage: ct.is_crystalographic()
-           True
+            sage: ct = CartanType(['G', 2]).relabel({1:2,2:1})
+            sage: ct.is_crystalographic()
+            True
         """
         return self._type.is_crystalographic()
 
@@ -259 +259 @@
         """
         EXAMPLES::
 
-           sage: ct = CartanType(['F', 4]).dual()
-           sage: ct.is_affine()
-           False
+            sage: ct = CartanType(['G', 2]).relabel({1:2,2:1})
+            sage: ct.is_affine()
+            False
         """
         return self._type.is_affine()
 
@@ -269 +269 @@
         """
         EXAMPLES::
 
-           sage: ct = CartanType(['F', 4]).dual()
-           sage: ct.rank()
-           4
+            sage: ct = CartanType(['G', 2]).relabel({1:2,2:1})
+            sage: ct.rank()
+            2
         """
         return self._type.rank()
 
@@ -279 +279 @@
         """
         EXAMPLES::
 
-           sage: ct = CartanType(['F', 4]).dual()
-           sage: ct.index_set()
-           [1, 2, 3, 4]
+            sage: ct = CartanType(['G', 2]).relabel({1:2,2:1})
+            sage: ct.index_set()
+            [1, 2]
         """
         return self._index_set
 
@@ -304 +304 @@
             BC3~* relabelled by {0: 1, 1: 2, 2: 3, 3: 0}
         """
         return self._type.dual().relabel(self._relabelling)
+    
+    def type(self):
+        """
+        Return the type of ``self`` or ``None`` if unknown.
+
+        EXAMPLES::
+
+            sage: ct = CartanType(['G', 2]).relabel({1:2,2:1})
+            sage: ct.type()
+            'G'
+        """
+        return self._type.type()
 
 
 ###########################################################################

new file sage/combinat/root_system/virtual_cartan_type.py

@@ +1 @@
+r"""
+Virtual Cartan types
+
+AUTHORS:
+
+- Travis Scrimshaw (2013-01-12) - Initial version
+"""
+#*****************************************************************************
+#       Copyright (C) 2013 Travis Scrimshaw <tscrim@ucdavis.edu>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#
+#    This code is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#    General Public License for more details.
+#
+#  The full text of the GPL is available at:
+#
+#                  http://www.gnu.org/licenses/
+#*****************************************************************************
+
+from sage.misc.cachefunc import cached_method
+from sage.misc.abstract_method import abstract_method
+from sage.rings.all import ZZ
+from sage.structure.unique_representation import UniqueRepresentation
+from sage.combinat.root_system.cartan_type import CartanType
+
+class VirtualCartanType(UniqueRepresentation):
+    """
+    A virtual Cartan type.
+
+    Given an affine Cartan type `X`, we say `\hat{X}` is a virtual Cartan
+    type of `X` if there exists am affine folding of the Dynkin diagram of
+    `\hat{X}` onto `X`.
+
+    An affine folding of (the Dynkin diagram of) `X` is an automorphism
+    `\sigma` of `X` which fixes the `0` node. The resulting Dynkin diagram
+    induced by `I / \sigma` where `I` is the index set of `X`. By abuse of
+    notation, we will denote the folding by `\sigma`.
+
+    We also have multiplication factors `\gamma_i` where `i \in I` induced
+    by the folding `\sigma`. We define `\gamma_i` as follows:
+
+    1. There exists a unique arrow (multiple bond) in `X`.
+
+        a. Suppose the arrow points towards 0. Then `\gamma_i = 1` for all
+           `i \in I`.
+        b. 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 indicent to `i` points away and is `1`
+       otherwise.
+
+    The default embeddings we consider here are:
+
+    .. MATH::
+
+        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)}
+
+    and were chosen based on virtual crystals.
+
+    If the Cartan type is simply laced, this is the folding induced from the
+    identity map.
+
+    For more information in Cartan types, see
+    :mod:`sage.combinat.root_system.cartan_type`.
+
+    To consider a folding that is not one of the default embeddings, one may
+    pass in an optional second argument ``virtual_data``. See below.
+
+    INPUT:
+
+    - ``cartan_type`` -- The Cartan type `X` to create a virtual crystal of
+
+    - ``virtual_data`` -- (Optional, default: ``None``) A tuple
+      ``(virtual, gamma, sigma)`` where:
+
+      - ``virtual`` -- the codomain of the embedding,
+      - ``gamma`` -- the multiplication factors,
+      - ``sigma`` -- the Dynkin diagram automorphism.
+
+    EXAMPLES::
+
+        sage: vct = VirtualCartanType(['C',4,1]); vct
+        Virtual Cartan type of ['C', 4, 1] in ['A', 7, 1]
+
+    If the Cartan type is simply-laced, then just consider it a virtual type
+    of itself::
+
+        sage: vct = VirtualCartanType(['A',4,1]); vct
+        Virtual Cartan type of ['A', 4, 1] in ['A', 4, 1]
+    """
+    @staticmethod
+    def __classcall_private__(cls, cartan_type, virtual_data=None):
+        """
+        Normalize input to ensure a unique representation.
+
+        EXAMPLES::
+
+            sage: vct1 = VirtualCartanType(['C',4,1])
+            sage: vct2 = VirtualCartanType(CartanType(['C',4,1]))
+            sage: vct3 = VirtualCartanType(vct2)
+            sage: vct1 is vct2, vct1 is vct3
+            (True, True)
+        """
+        if isinstance(cartan_type, VirtualCartanType):
+            return cartan_type
+        cartan_type = CartanType(cartan_type)
+        if virtual_data is not None:
+            virtual_data = (CartanType(virtual_data[0]), tuple(virtual_data[1]), tuple(virtual_data[2]))
+        return super(VirtualCartanType, cls).__classcall__(cls, cartan_type, virtual_data)
+
+    def __init__(self, cartan_type, virtual_data):
+        """
+        Initialize ``self``.
+
+        EXAMPLES::
+
+            sage: vct = VirtualCartanType(['C',4,1]); vct
+            Virtual Cartan type of ['C', 4, 1] in ['A', 7, 1]
+            sage: TestSuite(vct).run()
+        """
+        if not cartan_type.is_affine():
+            raise ValueError("%s must be an affine type"%cartan_type)
+
+        gamma = None # Embedding multiplier
+        sigma = None # Dynkin diagram cosets
+
+        # Determine if this is a virtual crystal
+        type = cartan_type.type()
+        if virtual_data is not None:
+            virtual = virtual_data[0]
+            gamma = virtual_data[1]
+            sigma = virtual_data[2]
+            #raise ValueError("%s is not a virtual Cartan type of %s"%cartan_type, virtual)
+        elif cartan_type.is_simply_laced():
+            virtual = cartan_type
+            rank = cartan_type.rank()
+            gamma = [1]*rank
+            sigma = [[i] for i in range(rank)]
+        elif cartan_type.is_untwisted_affine():
+            if type == 'B':
+                n = cartan_type.n
+                virtual = CartanType(['D', n + 1, 1]) 
+                gamma = [2]*n + [1]
+                sigma = [[i] for i in range(n)] + [[n, n+1]]
+            elif type == 'C':
+                n = cartan_type.n
+                virtual = CartanType(['A', 2*n - 1, 1])
+                gamma = [2] + [1]*(n-1) + [2]
+                sigma = [[0]] + [[i, 2*n-i] for i in range(1, n)] + [[n]]
+            elif type == 'F':
+                virtual = CartanType(['E', 6, 1])
+                gamma = [2, 2, 2, 1, 1]
+                sigma = [[0], [2], [4], [3, 5], [1, 6]]
+            elif type == 'G':
+                virtual = CartanType(['D', 4, 1])
+                gamma = [3, 1, 3]
+                sigma = [[0], [1, 3, 4], [2]]
+        else:
+            if type == 'BC': # A_{2n}^{(2)}
+                n = cartan_type.classical().n
+                virtual = CartanType(['A', 2*n - 1, 1])
+                gamma = [1]*n + [2]
+                sigma = [[0]] + [[i, 2*n-i] for i in range(1, n)] + [[n]]
+            elif cartan_type.dual().type() == 'BC': # A_{2n}^{(2)\dagger}
+                n = cartan_type.classical().n
+                virtual = CartanType(['A', 2*n - 1, 1])
+                gamma = [2] + [1]*n
+                sigma = [[0]] + [[i, 2*n-i] for i in range(1, n)] + [[n]]
+            elif cartan_type.dual().type() == 'B': # A_{2n-1}^{(2)}
+                n = cartan_type.classical().n
+                virtual = CartanType(['D', n + 1, 1])
+                gamma = [1]*(n+1)
+                sigma = [[i] for i in range(n)] + [[n, n+1]]
+            elif cartan_type.dual().type() == 'C': # D_{n+1}^{(2)}
+                n = cartan_type.classical().n
+                virtual = CartanType(['A', 2*n-1, 1])
+                gamma = [1]*(n+1)
+                sigma = [[0]] + [[i, 2*n-i] for i in range(1, n)] + [[n]]
+            elif cartan_type.dual().type() == 'F': # E_6^{(2)}
+                virtual = CartanType(['E', 6, 1])
+                gamma = [1, 1, 1, 1, 1]
+                sigma = [[0], [2], [4], [3, 5], [1, 6]]
+            elif cartan_type.dual().type() == 'G': # D_4^{(3)}
+                # Get rid of the relabeling...
+                cartan_type = CartanType(['G',2,1]).dual()
+                virtual = CartanType(['D', 4, 1])
+                gamma = [1, 1, 1]
+                sigma = [[0], [1, 3, 4], [2]]
+
+        self.cartan_type = cartan_type
+        self.virtual = virtual
+        self.gamma = gamma
+        self.sigma = sigma
+
+    def __repr__(self):
+        """
+        Return a string representation of ``self``.
+
+        EXAMPLES::
+
+            sage: vct = VirtualCartanType(['C',4,1]); vct # indirect doctest
+            Virtual Cartan type of ['C', 4, 1] in ['A', 7, 1]
+        """
+        return "Virtual Cartan type of %s in %s"%(self.cartan_type,self.virtual)