Ticket #12882: trac_12882-matrix_as_dynkin_diagram-ts.patch

File trac_12882-matrix_as_dynkin_diagram-ts.patch, 13.8 KB (added by tscrim, 9 years ago)
  • sage/combinat/root_system/all.py

    # HG changeset patch
    # User Christian Stump <christian.stump at gmail.com>
    # Date 1352623639 -3600
    # Node ID 79ce1f7cd3129cb2207af0607b4012ea77251484
    # Parent 4b443ee014320597ee2a9cf6c14bf267c177b4a4
    #12882: Allows a generalized Cartan matrix as input for Dynkin diagrams
    
    diff --git a/sage/combinat/root_system/all.py b/sage/combinat/root_system/all.py
    a b from sage.misc.lazy_import import lazy_i 
    22lazy_import('sage.combinat.root_system.associahedron', 'Associahedron')
    33
    44from cartan_type import CartanType
    5 from dynkin_diagram import DynkinDiagram, dynkin_diagram
     5from dynkin_diagram import DynkinDiagram
    66from cartan_matrix import CartanMatrix, cartan_matrix
    77from coxeter_matrix import coxeter_matrix
    88from root_system import RootSystem, WeylDim
  • sage/combinat/root_system/cartan_matrix.py

    diff --git a/sage/combinat/root_system/cartan_matrix.py b/sage/combinat/root_system/cartan_matrix.py
    a b class CartanMatrix(Matrix_integer_sparse 
    228228            cartan_type = None
    229229            dynkin_diagram = None
    230230            subdivisions = None
    231             try:
    232                 cartan_type = CartanType(args[0])
    233                 dynkin_diagram = cartan_type.dynkin_diagram()
    234             except (TypeError, ValueError):
    235                 pass
     231
     232            from sage.combinat.root_system.dynkin_diagram import DynkinDiagram_class
     233            if isinstance(args[0], DynkinDiagram_class):
     234                dynkin_diagram = args[0]
     235                cartan_type = args[0]._cartan_type
     236            else:
     237                try:
     238                    cartan_type = CartanType(args[0])
     239                    dynkin_diagram = cartan_type.dynkin_diagram()
     240                except (TypeError, ValueError):
     241                    pass
    236242
    237243            if dynkin_diagram is not None:
    238                 n = cartan_type.rank()
     244                n = dynkin_diagram.rank()
    239245                index_set = dynkin_diagram.index_set()
    240246                reverse = dict((index_set[i], i) for i in range(len(index_set)))
    241247                data = {(i, i): 2 for i in range(n)}
    class CartanMatrix(Matrix_integer_sparse 
    259265                if cartan_type is not None:
    260266                    index_set = tuple(cartan_type.index_set())
    261267                else:
    262                     index_set = tuple(range(M.ncols()))
     268                    index_set = tuple(range(n))
    263269            elif len(args) == 2:
    264270                index_set = tuple(args[1])
    265271                if len(index_set) != n and len(set(index_set)) != n:
    class CartanMatrix(Matrix_integer_sparse 
    410416        from sage.combinat.root_system.dynkin_diagram import DynkinDiagram
    411417        if self._cartan_type is not None:
    412418            return DynkinDiagram(self._cartan_type)
    413 
    414         from dynkin_diagram import DynkinDiagram_class
    415         n = self.nrows()
    416         g = DynkinDiagram_class(self)
    417         for i in range(n):
    418             for j in range(n):
    419                 if self[i,j] == -1:
    420                     g.add_edge(i, j)
    421                 elif self[i,j] < -1:
    422                     g.add_edge(i, j, -self[i,j])
    423         return g
     419        return DynkinDiagram(self)
    424420
    425421    def cartan_matrix(self):
    426422        r"""
    class CartanMatrix(Matrix_integer_sparse 
    509505            sage: M = CartanMatrix(['D',4,1])
    510506            sage: M.is_finite()
    511507            False
     508            sage: M = CartanMatrix([[2, -4], [-3, 2]])
     509            sage: M.is_finite()
     510            False
    512511        """
    513512        if self._cartan_type is None:
    514             return False
     513            return self.det() > 0
    515514        return self._cartan_type.is_finite()
    516515
    517516    def is_affine(self):
    class CartanMatrix(Matrix_integer_sparse 
    526525            sage: M = CartanMatrix(['D',4,1])
    527526            sage: M.is_affine()
    528527            True
     528            sage: M = CartanMatrix([[2, -4], [-3, 2]])
     529            sage: M.is_affine()
     530            False
    529531        """
    530532        if self._cartan_type is None:
    531             return False
     533            return self.det() == 0
    532534        return self._cartan_type.is_affine()
    533535
    534536def is_generalized_cartan_matrix(M):
  • sage/combinat/root_system/dynkin_diagram.py

    diff --git a/sage/combinat/root_system/dynkin_diagram.py b/sage/combinat/root_system/dynkin_diagram.py
    a b AUTHORS: 
    88
    99- Travis Scrimshaw (2013-06-11): Changed inputs of Dynkin diagrams to handle
    1010  other Dynkin diagrams and graphs. Implemented remaining Cartan type methods.
     11
     12- Christian Stump, Travis Scrimshaw (2013-04-11): Added Cartan matrix as
     13  possible input for Dynkin diagrams.
    1114"""
    1215#*****************************************************************************
    13 #       Copyright (C) 2007 Mike Hansen <mhansen@gmail.com>,
     16#       Copyright (C) 2007 Mike Hansen <mhansen@gmail.com>,
     17#       Copyright (C) 2013 Travis Scrimshaw <tscrim@ucdavis.edu>
    1418#
    1519#  Distributed under the terms of the GNU General Public License (GPL)
    1620#
    AUTHORS: 
    2428#                  http://www.gnu.org/licenses/
    2529#*****************************************************************************
    2630from sage.misc.cachefunc import cached_method
     31from sage.matrix.matrix import is_Matrix
     32from sage.functions.generalized import sgn
    2733from sage.graphs.digraph import DiGraph
    28 from cartan_type import CartanType, CartanType_abstract
     34from sage.combinat.root_system.cartan_type import CartanType, CartanType_abstract
    2935from sage.combinat.root_system.cartan_matrix import CartanMatrix
    3036from sage.misc.superseded import deprecated_function_alias
    3137
    32 def DynkinDiagram(*args):
     38def DynkinDiagram(*args, **kwds):
    3339    r"""
    34     Return a Dynkin diagram for type ``ct``.
     40    Return the Dynkin diagram corresponding to the input.
    3541
    3642    INPUT:
    3743
    38     -  ``ct`` -- a Cartan Type
     44    The input can be one of the following:
     45
     46    - empty to obtain an empty Dynkin diagram
     47    - a Cartan type
     48    - a Cartan matrix
     49    - a Cartan matrix and an indexing set
     50
     51    Also one can input an index_set by
    3952   
    4053    The edge multiplicities are encoded as edge labels. This uses the
    4154    convention in Hong and Kang, Kac, Fulton Harris, and crystals. This is the
    def DynkinDiagram(*args): 
    90103        5   6   7   8
    91104        A2xB2xF4
    92105
     106        sage: R = RootSystem("A2xB2xF4")
     107        sage: CM = R.cartan_matrix(); CM
     108        [ 2 -1| 0  0| 0  0  0  0]
     109        [-1  2| 0  0| 0  0  0  0]
     110        [-----+-----+-----------]
     111        [ 0  0| 2 -1| 0  0  0  0]
     112        [ 0  0|-2  2| 0  0  0  0]
     113        [-----+-----+-----------]
     114        [ 0  0| 0  0| 2 -1  0  0]
     115        [ 0  0| 0  0|-1  2 -1  0]
     116        [ 0  0| 0  0| 0 -2  2 -1]
     117        [ 0  0| 0  0| 0  0 -1  2]
     118        sage: DD = DynkinDiagram(CM); DD
     119        O---O
     120        1   2
     121        O=>=O
     122        3   4
     123        O---O=>=O---O
     124        5   6   7   8
     125        A2xB2xF4
     126        sage: DD.cartan_matrix()
     127        [ 2 -1  0  0  0  0  0  0]
     128        [-1  2  0  0  0  0  0  0]
     129        [ 0  0  2 -1  0  0  0  0]
     130        [ 0  0 -2  2  0  0  0  0]
     131        [ 0  0  0  0  2 -1  0  0]
     132        [ 0  0  0  0 -1  2 -1  0]
     133        [ 0  0  0  0  0 -2  2 -1]
     134        [ 0  0  0  0  0  0 -1  2]
     135
     136    We can also create Dynkin diagrams from arbitrary Cartan matrices::
     137
     138        sage: C = CartanMatrix([[2, -3], [-4, 2]])
     139        sage: DynkinDiagram(C)
     140        Dynkin diagram of rank 2
     141        sage: C.index_set()
     142        (0, 1)
     143        sage: CI = CartanMatrix([[2, -3], [-4, 2]], [3, 5])
     144        sage: DI = DynkinDiagram(CI)
     145        sage: DI.index_set()
     146        (3, 5)
     147        sage: CII = CartanMatrix([[2, -3], [-4, 2]])
     148        sage: DII = DynkinDiagram(CII, ('y', 'x'))
     149        sage: DII.index_set()
     150        ('x', 'y')
     151
    93152    .. SEEALSO::
    94153
    95154        :func:`CartanType` for a general discussion on Cartan
    96155        types and in particular node labeling conventions.
    97156    """
    98157    if len(args) == 0:
    99        return DynkinDiagram_class()
     158        return DynkinDiagram_class()
     159    mat = args[0]
     160    if is_Matrix(mat):
     161        mat = CartanMatrix(*args)
     162    if isinstance(mat, CartanMatrix):
     163        if mat.cartan_type() is not None:
     164            try:
     165                return mat.cartan_type().dynkin_diagram()
     166            except AttributeError:
     167                raise ValueError("Dynkin diagram data not yet hardcoded for type %s"%ct)
     168        if len(args) > 1:
     169            index_set = tuple(args[1])
     170        elif "index_set" in kwds:
     171            index_set = tuple(kwds["index_set"])
     172        else:
     173            index_set = mat.index_set()
     174        D = DynkinDiagram_class(index_set=index_set)
     175        n = mat.nrows()
     176        for i in range(n):
     177            for j in range(n):
     178                if i != j:
     179                    D.add_edge(index_set[i], index_set[j], -mat[j,i])
     180        return D
    100181    ct = CartanType(*args)
    101     if hasattr(ct, "dynkin_diagram"):
     182    try:
    102183        return ct.dynkin_diagram()
    103     else:
    104         raise ValueError, "Dynkin diagram data not yet hardcoded for type %s"%ct
     184    except AttributeError:
     185        raise ValueError("Dynkin diagram data not yet hardcoded for type %s"%ct)
    105186
    106 def dynkin_diagram(t):
     187
     188class DynkinDiagram_class(DiGraph, CartanType_abstract):
    107189    """
    108     Return the Dynkin diagram of type ``t``.
     190    A Dynkin diagram.
    109191
    110     Note that this function is deprecated, and that you should use
    111     :func:`DynkinDiagram` instead as this will be disappearing in the
    112     near future.
     192    .. SEEALSO::
     193
     194        :func:`DynkinDiagram()`
     195
     196    INPUT:
     197
     198    - ``t`` -- a Cartan type, Cartan matrix, or ``None``
    113199
    114200    EXAMPLES::
    115201
    116         sage: dynkin_diagram(["A", 3])
    117         doctest:1: DeprecationWarning: dynkin_diagram is deprecated, use DynkinDiagram instead!
    118         See http://trac.sagemath.org/3654 for details.
     202        sage: DynkinDiagram(['A', 3])
    119203        O---O---O
    120204        1   2   3
    121205        A3
     206        sage: C = CartanMatrix([[2, -3], [-4, 2]])
     207        sage: DynkinDiagram(C)
     208        Dynkin diagram of rank 2
     209        sage: C.dynkin_diagram().cartan_matrix() == C
     210        True
     211
     212    TESTS:
     213
     214    Check that the correct type is returned when copied::
     215
     216        sage: d = DynkinDiagram(['A', 3])
     217        sage: type(copy(d))
     218        <class 'sage.combinat.root_system.dynkin_diagram.DynkinDiagram_class'>
     219
     220    We check that :trac:`14655` is fixed::
     221
     222        sage: cd = copy(d)
     223        sage: cd.add_vertex(4)
     224        sage: d.vertices() != cd.vertices()
     225        True
     226
     227    Implementation note: if a Cartan type is given, then the nodes
     228    are initialized from the index set of this Cartan type.
    122229    """
    123     from sage.misc.superseded import deprecation
    124     deprecation(3654, "dynkin_diagram is deprecated, use DynkinDiagram instead!")
    125     return DynkinDiagram(t)
    126 
    127 
    128 class DynkinDiagram_class(DiGraph, CartanType_abstract):
    129     def __init__(self, t = None, **options):
     230    def __init__(self, t=None, index_set=None, **options):
    130231        """
    131         INPUT:
    132 
    133         - ``t`` -- a Cartan type or ``None``
     232        Initialize ``self``.
    134233
    135234        EXAMPLES::
    136        
     235
    137236            sage: d = DynkinDiagram(["A", 3])
    138237            sage: TestSuite(d).run()
    139 
    140         Check that the correct type is returned when copied::
    141 
    142             sage: d = DynkinDiagram(["A", 3])
    143             sage: type(copy(d))
    144             <class 'sage.combinat.root_system.dynkin_diagram.DynkinDiagram_class'>
    145 
    146         We check that :trac:`14655` is fixed::
    147 
    148             sage: cd = copy(d)
    149             sage: cd.add_vertex(4)
    150             sage: d.vertices() != cd.vertices()
    151             True
    152 
    153         Implementation note: if a Cartan type is given, then the nodes
    154         are initialized from the index set of this Cartan type.
    155238        """
    156239        if isinstance(t, DiGraph):
    157240            if isinstance(t, DynkinDiagram_class):
    class DynkinDiagram_class(DiGraph, Carta 
    163246
    164247        DiGraph.__init__(self, **options)
    165248        self._cartan_type = t
    166         if t is not None:
     249        if index_set is not None:
     250            self.add_vertices(index_set)
     251        elif t is not None:
    167252            self.add_vertices(t.index_set())
    168253
    169254    def _repr_(self):
    class DynkinDiagram_class(DiGraph, Carta 
    211296        ret += "\n\\end{tikzpicture}"
    212297        return ret
    213298
     299    def _matrix_(self):
     300        """
     301        Return a regular matrix from ``self``.
     302
     303        EXAMPLES::
     304
     305            sage: M = DynkinDiagram(['C',3])._matrix_(); M
     306            [ 2 -1  0]
     307            [-1  2 -2]
     308            [ 0 -1  2]
     309            sage: type(M)
     310            <class 'sage.combinat.root_system.cartan_matrix.CartanMatrix'>
     311        """
     312        return self.cartan_matrix()._matrix_()
     313
    214314    def add_edge(self, i, j, label=1):
    215315        """
    216316        EXAMPLES::
    217        
     317
    218318            sage: from sage.combinat.root_system.dynkin_diagram import DynkinDiagram_class
    219319            sage: d = DynkinDiagram_class(CartanType(['A',3]))
    220320            sage: list(sorted(d.edges()))
    class DynkinDiagram_class(DiGraph, Carta 
    383483
    384484            sage: CartanType(['F',4]).dynkin_diagram().is_finite()
    385485            True
     486            sage: D = DynkinDiagram(CartanMatrix([[2, -4], [-3, 2]]))
     487            sage: D.is_finite()
     488            False
    386489        """
    387         return self._cartan_type.is_finite()
     490        if self._cartan_type is not None:
     491            return self._cartan_type.is_finite()
     492        return self.cartan_matrix().is_finite()
    388493
    389494    def is_affine(self):
    390495        """
    class DynkinDiagram_class(DiGraph, Carta 
    394499
    395500            sage: CartanType(['F',4]).dynkin_diagram().is_affine()
    396501            False
     502            sage: D = DynkinDiagram(CartanMatrix([[2, -4], [-3, 2]]))
     503            sage: D.is_affine()
     504            False
    397505        """
    398         return self._cartan_type.is_affine()
     506        if self._cartan_type is not None:
     507            return self._cartan_type.is_affine()
     508        return self.cartan_matrix().is_affine()
    399509
    400510    def is_irreducible(self):
    401511        """