Ticket #12882: trac_12882-generalized_cartan_matrix_as_dynkin_diagram_input-cs.2.patch

File trac_12882-generalized_cartan_matrix_as_dynkin_diagram_input-cs.2.patch, 9.1 KB (added by tscrim, 9 years ago)
  • sage/combinat/root_system/dynkin_diagram.py

    # HG changeset patch
    # User Christian Stump <christian.stump at gmail.com>
    # Date 1352623639 -3600
    # Node ID 79ce1f7cd3129cb2207af0607b4012ea77251484
    # Parent d6172b786bffcff29765e8b323b3b2964ece57be
    #12882: Allows a generalized Cartan matrix as input for Dynkin diagrams
    
    diff --git a/sage/combinat/root_system/dynkin_diagram.py b/sage/combinat/root_system/dynkin_diagram.py
    a b AUTHORS: 
    66- Travis Scrimshaw (2012-04-22): Nicolas M. Thiery moved Cartan matrix creation
    77  to here and I cached results for speed.
    88
     9- Christian Stump, Travis Scrimshaw (2013-04-11): Added Cartan matrix as
     10  possible input for Dynkin diagrams.
    911"""
    1012#*****************************************************************************
    11 #       Copyright (C) 2007 Mike Hansen <mhansen@gmail.com>,
     13#       Copyright (C) 2007 Mike Hansen <mhansen@gmail.com>,
     14#       Copyright (C) 2013 Travis Scrimshaw <tscrim@ucdavis.edu>,
    1215#
    1316#  Distributed under the terms of the GNU General Public License (GPL)
    1417#
    AUTHORS: 
    2225#                  http://www.gnu.org/licenses/
    2326#*****************************************************************************
    2427from sage.misc.cachefunc import cached_method
     28from sage.matrix.matrix import is_Matrix
     29from sage.functions.generalized import sgn
    2530from sage.graphs.digraph import DiGraph
    26 from cartan_type import CartanType, CartanType_abstract
     31from sage.combinat.root_system.cartan_type import CartanType, CartanType_abstract
    2732from sage.combinat.root_system.cartan_matrix import CartanMatrix
    2833
    2934def DynkinDiagram(*args):
    3035    r"""
    31     Return a Dynkin diagram for type ``ct``.
     36    Return the Dynkin diagram corresponding to the input.
    3237
    3338    INPUT:
    3439
    35     -  ``ct`` -- a Cartan Type
     40    The input can be one of the following:
     41
     42    - empty to obtain an empty Dynkin diagram
     43    - a Cartan type
     44    - a Cartan matrix
     45    - a Cartan matrix and an indexing set
    3646   
    3747    The edge multiplicities are encoded as edge labels. This uses the
    3848    convention in Hong and Kang and crystals. This is the **opposite**
    def DynkinDiagram(*args): 
    8797        5   6   7   8
    8898        A2xB2xF4
    8999
     100        sage: R = RootSystem("A2xB2xF4")
     101        sage: CM = R.cartan_matrix(); CM
     102        [ 2 -1| 0  0| 0  0  0  0]
     103        [-1  2| 0  0| 0  0  0  0]
     104        [-----+-----+-----------]
     105        [ 0  0| 2 -1| 0  0  0  0]
     106        [ 0  0|-2  2| 0  0  0  0]
     107        [-----+-----+-----------]
     108        [ 0  0| 0  0| 2 -1  0  0]
     109        [ 0  0| 0  0|-1  2 -1  0]
     110        [ 0  0| 0  0| 0 -2  2 -1]
     111        [ 0  0| 0  0| 0  0 -1  2]
     112        sage: DD = DynkinDiagram(CM); DD
     113        O---O
     114        1   2
     115        O=>=O
     116        3   4
     117        O---O=>=O---O
     118        5   6   7   8
     119        A2xB2xF4
     120        sage: DD.cartan_matrix()
     121        [ 2 -1  0  0  0  0  0  0]
     122        [-1  2  0  0  0  0  0  0]
     123        [ 0  0  2 -1  0  0  0  0]
     124        [ 0  0 -2  2  0  0  0  0]
     125        [ 0  0  0  0  2 -1  0  0]
     126        [ 0  0  0  0 -1  2 -2  0]
     127        [ 0  0  0  0  0 -1  2 -1]
     128        [ 0  0  0  0  0  0 -1  2]
     129
    90130    .. SEEALSO::
    91131
    92132        :func:`CartanType` for a general discussion on Cartan
    93133        types and in particular node labeling conventions.
    94134    """
    95135    if len(args) == 0:
    96        return DynkinDiagram_class()
     136        return DynkinDiagram_class()
     137    mat = args[0]
     138    if is_Matrix(mat):
     139        mat = CartanMatrix(*args)
     140    if isinstance(mat, CartanMatrix):
     141        if mat.cartan_type() is not None:
     142            try:
     143                return mat.cartan_type().dynkin_diagram()
     144            except AttributeError:
     145                raise ValueError("Dynkin diagram data not yet hardcoded for type %s"%ct)
     146        D = DynkinDiagram_class()
     147        index_set = mat.index_set()
     148        for i in range(n):
     149            for j in range(n):
     150                if i != j:
     151                    D.add_edge(index_set[i], index_set[j], -mat._M[i,j])
     152        return D
    97153    ct = CartanType(*args)
    98     if hasattr(ct, "dynkin_diagram"):
     154    try:
    99155        return ct.dynkin_diagram()
    100     else:
    101         raise ValueError, "Dynkin diagram data not yet hardcoded for type %s"%ct
     156    except AttributeError:
     157        raise ValueError("Dynkin diagram data not yet hardcoded for type %s"%ct)
    102158
    103159def dynkin_diagram(t):
    104160    """
    class DynkinDiagram_class(DiGraph, Carta 
    130186        - ``t`` -- a Cartan type or ``None``
    131187
    132188        EXAMPLES::
    133        
     189
    134190            sage: d = DynkinDiagram(["A", 3])
    135191            sage: d == loads(dumps(d))
    136192            True
    class DynkinDiagram_class(DiGraph, Carta 
    146202    def __copy__(self):
    147203        """
    148204        EXAMPLES::
    149        
     205
    150206            sage: d = DynkinDiagram(["A", 3])
    151207            sage: type(copy(d))
    152208            <class 'sage.combinat.root_system.dynkin_diagram.DynkinDiagram_class'>
    153209        """
    154         import copy 
     210        import copy
    155211        # we have to go back to the generic copy method because the DiGraph one returns a DiGraph, not a DynkinDiagram
    156212        return copy._reconstruct(self,self.__reduce_ex__(2),0)
    157213
    class DynkinDiagram_class(DiGraph, Carta 
    199255        ret += "\n\\end{tikzpicture}"
    200256        return ret
    201257
     258    def _matrix_(self):
     259        """
     260        Return a regular matrix from ``self``.
     261
     262        EXAMPLES::
     263
     264            sage: M = DynkinDiagram(['C',3])._matrix_(); M
     265            [ 2 -1  0]
     266            [-1  2 -2]
     267            [ 0 -1  2]
     268            sage: type(M)
     269            <type 'sage.matrix.matrix_integer_sparse.Matrix_integer_sparse'>
     270        """
     271        return self.cartan_matrix()._matrix_()
     272
    202273    def add_edge(self, i, j, label=1):
    203274        """
    204275        EXAMPLES::
    205        
     276
    206277            sage: from sage.combinat.root_system.dynkin_diagram import DynkinDiagram_class
    207278            sage: d = DynkinDiagram_class(CartanType(['A',3]))
    208279            sage: list(sorted(d.edges()))
    class DynkinDiagram_class(DiGraph, Carta 
    246317            [ 2 -1 -1]
    247318            [-2  2 -1]
    248319            [-1 -1  2]
    249        
     320
    250321        """
    251322        # hyperbolic Dynkin diagram of Exercise 4.9 p. 57 of Kac Infinite Dimensional Lie Algebras.
    252323        g = DynkinDiagram()
    class DynkinDiagram_class(DiGraph, Carta 
    262333    def index_set(self):
    263334        """
    264335        EXAMPLES::
    265        
     336
    266337            sage: DynkinDiagram(['C',3]).index_set()
    267338            [1, 2, 3]
    268339            sage: DynkinDiagram("A2","B2","F4").index_set()
    269340            [1, 2, 3, 4, 5, 6, 7, 8]
    270341        """
    271342        return self.vertices()
    272        
     343
    273344    def cartan_type(self):
    274345        """
    275346        EXAMPLES::
    276        
     347
    277348            sage: DynkinDiagram("A2","B2","F4").cartan_type()
    278349            A2xB2xF4
    279350        """
    class DynkinDiagram_class(DiGraph, Carta 
    282353    def rank(self):
    283354        r"""
    284355        Returns the index set for this Dynkin diagram
    285        
     356
    286357        EXAMPLES::
    287        
     358
    288359            sage: DynkinDiagram(['C',3]).rank()
    289360            3
    290361            sage: DynkinDiagram("A2","B2","F4").rank()
    class DynkinDiagram_class(DiGraph, Carta 
    295366    def dynkin_diagram(self):
    296367        """
    297368        EXAMPLES::
    298        
     369
    299370            sage: DynkinDiagram(['C',3]).dynkin_diagram()
    300371            O---O=<=O
    301372            1   2   3
    class DynkinDiagram_class(DiGraph, Carta 
    334405            [(1, 2, 1), (2, 1, 1), (2, 3, 2), (3, 2, 1)]
    335406            sage: D.dual() == DynkinDiagram(['B',3])
    336407            True
    337        
     408
    338409        TESTS::
    339        
     410
    340411            sage: D = DynkinDiagram(['A',0]); D
    341412            A0
    342413            sage: D.edges()
    class DynkinDiagram_class(DiGraph, Carta 
    375446        """
    376447        return True
    377448
    378 
    379449    def __getitem__(self, i):
    380450        r"""
    381451        With a tuple (i,j) as argument, returns the scalar product
    382452        `\langle
    383453                \alpha^\vee_i, \alpha_j\rangle`.
    384        
     454
    385455        Otherwise, behaves as the usual DiGraph.__getitem__
    386        
     456
    387457        EXAMPLES: We use the `C_4` dynkin diagram as a cartan
    388458        matrix::
    389        
     459
    390460            sage: g = DynkinDiagram(['C',4])
    391461            sage: matrix([[g[i,j] for j in range(1,5)] for i in range(1,5)])
    392462            [ 2 -1  0  0]
    393463            [-1  2 -1  0]
    394464            [ 0 -1  2 -2]
    395465            [ 0  0 -1  2]
    396        
     466
    397467        The neighbors of a node can still be obtained in the usual way::
    398        
     468
    399469            sage: [g[i] for i in range(1,5)]
    400470            [[2], [1, 3], [2, 4], [3]]
    401471        """
    class DynkinDiagram_class(DiGraph, Carta 
    414484        Returns the `j^{th}` column `(a_{i,j})_i` of the
    415485        Cartan matrix corresponding to this Dynkin diagram, as a container
    416486        (or iterator) of tuples `(i, a_{i,j})`
    417        
     487
    418488        EXAMPLES::
    419        
     489
    420490            sage: g = DynkinDiagram(["B",4])
    421491            sage: [ (i,a) for (i,a) in g.column(3) ]
    422492            [(3, 2), (2, -1), (4, -2)]
    def precheck(t, letter=None, length=None 
    471541    if length is not None:
    472542        if len(t) != length:
    473543            raise ValueError, "len(t) must be = %s"%length
    474        
     544
    475545    if affine is not None:
    476546        try:
    477547            if t[2] != affine: