Ticket #5794: trac_5794-exceptional.patch

File trac_5794-exceptional.patch, 8.9 KB (added by bump, 12 years ago)
  • sage/combinat/root_system/root_system.py

    exporting patch:
    # HG changeset patch
    # User Daniel Bump <bump@match.stanford.edu>
    # Date 1242190595 25200
    # Node ID 4446b9f501f12fb5d9d99cf1c0126f9004a34229
    # Parent  e93055225d61b81bee7f8882fde262a9a34b03cb
    some branching rules for F4 and E6
    
    diff --git a/sage/combinat/root_system/root_system.py b/sage/combinat/root_system/root_system.py
    a b  
    229229        # The root system can be defined as dual of another root system. This will
    230230        # only affects the pretty printing
    231231        if as_dual_of is None:
    232             self.dual = RootSystem(self._cartan_type.dual(), as_dual_of=self);
     232            # still fails for CartanType G2xA1
     233            try:
     234                self.dual = RootSystem(self._cartan_type.dual(), as_dual_of=self);
     235            except:
     236                pass
    233237            self.dual_side = False
    234238        else:
    235239            self.dual = as_dual_of
  • sage/combinat/root_system/weyl_characters.py

    diff --git a/sage/combinat/root_system/weyl_characters.py b/sage/combinat/root_system/weyl_characters.py
    a b  
    1717#*****************************************************************************
    1818import cartan_type
    1919from sage.combinat.root_system.root_system import RootSystem
     20from sage.combinat.root_system.dynkin_diagram import DynkinDiagram
    2021from sage.combinat.root_system.cartan_type import CartanType
    2122from sage.modules.free_module import VectorSpace
    2223from sage.modules.free_module_element import vector
     
    828829        """
    829830        return self._space.positive_roots()
    830831
     832    def dynkin_diagram(self):
     833        """
     834        Returns the Dynkin diagram.
     835
     836        EXAMPLES::
     837
     838            sage: WeylCharacterRing("E7").dynkin_diagram()
     839                    O 2
     840                    |
     841                    |
     842            O---O---O---O---O---O
     843            1   3   4   5   6   7   
     844            E7
     845        """
     846        return self.space().dynkin_diagram()
     847
     848    def extended_dynkin_diagram(self):
     849        """
     850        Returns the extended Dynkin diagram, which is the Dynkin diagram
     851        of the corresponding untwisted affine type.
     852
     853        EXAMPLES::
     854
     855            sage: WeylCharacterRing("E7").extended_dynkin_diagram()
     856                        O 2
     857                        |
     858                        |
     859            O---O---O---O---O---O---O
     860            0   1   3   4   5   6   7
     861            E7~
     862        """
     863        return DynkinDiagram([self.cartan_type()[0],self.cartan_type()[1],1])
     864
    831865    def rank(self):
    832866        """
    833867        Returns the rank.
     
    11471181
    11481182    and these may be obtained using the rule "symmetric_power".
    11491183
    1150     MISCELLANEOUS: Use rule="miscellaneous" for the following rule,
    1151     which does not fit into the above framework.
     1184    MISCELLANEOUS: Use rule="miscellaneous" for the following rules.
    11521185   
    11531186    B3 => G2
     1187    F4 => G2xA1 (not implemented yet)
    11541188   
    11551189    BRANCHING RULES FROM PLETHYSMS
    11561190
     
    13021336         B4(1,1,0,0) + B4(1,1,1,0) + B4(3/2,1/2,1/2,1/2) + B4(3/2,3/2,1/2,1/2) + B4(2,1,1,0),
    13031337         B4(1/2,1/2,1/2,1/2) + B4(1,0,0,0) + B4(1,1,0,0) + B4(1,1,1,0) + B4(3/2,1/2,1/2,1/2),
    13041338         B4(0,0,0,0) + B4(1/2,1/2,1/2,1/2) + B4(1,0,0,0)]
     1339
     1340        sage: E6 = WeylCharacterRing("E6", style="coroots")
     1341        sage: A2xA2xA2=WeylCharacterRing("A2xA2xA2",style="coroots")
     1342        sage: A5xA1=WeylCharacterRing("A5xA1",style="coroots")
    13051343        sage: G2 = WeylCharacterRing("G2", style="coroots")
    13061344        sage: A1xA1 = WeylCharacterRing("A1xA1", style="coroots")
    1307         sage: G2(1,0).branch(A1xA1, rule="extended")
    1308          A1xA1(1,1) + A1xA1(2,0)
     1345        sage: F4 = WeylCharacterRing("F4",style="coroots")
     1346        sage: A3xA1 = WeylCharacterRing("A3xA1", style="coroots")
     1347        sage: A2xA2 = WeylCharacterRing("A2xA2", style="coroots")
     1348        sage: A1xC3 = WeylCharacterRing("A1xC3",style="coroots")
     1349
     1350        sage: E6(1,0,0,0,0,0).branch(A5xA1,rule="extended") # long time
     1351         A5xA1(0,0,0,1,0,0) + A5xA1(1,0,0,0,0,1)
     1352        sage: E6(1,0,0,0,0,0).branch(A2xA2xA2, rule="extended") # long time
     1353         A2xA2xA2(0,0,0,1,1,0) + A2xA2xA2(0,1,1,0,0,0) + A2xA2xA2(1,0,0,0,0,1)
     1354        sage: F4(1,0,0,0).branch(A1xC3,rule="extended") # long time
     1355         A1xC3(0,2,0,0) + A1xC3(1,0,0,1) + A1xC3(2,0,0,0)
    13091356        sage: G2(0,1).branch(A1xA1, rule="extended")
    13101357         A1xA1(0,2) + A1xA1(2,0) + A1xA1(3,1)
    1311 
    1312     For example we can get the branching rule D4 => A1xA1xA1xA1 by remembering
    1313     that A1xA1 = D2.
    1314 
     1358        sage: F4(0,0,0,1).branch(A2xA2, rule="extended") # long time
     1359         A2xA2(0,0,1,1) + A2xA2(0,1,0,1) + A2xA2(1,0,1,0)
     1360        sage: F4(0,0,0,1).branch(A3xA1,rule="extended") # long time
     1361         A3xA1(0,0,0,0) + A3xA1(0,0,0,2) + A3xA1(0,0,1,1) + A3xA1(0,1,0,0) + A3xA1(1,0,0,1)
    13151362        sage: D4=WeylCharacterRing("D4",style="coroots")
    1316         sage: D2xD2=WeylCharacterRing("D2xD2",style="coroots")
     1363        sage: D2xD2=WeylCharacterRing("D2xD2",style="coroots") # We get D4 => A1xA1xA1xA1 by remembering that A1xA1 = D2.
    13171364        sage: [D4(fw).branch(D2xD2, rule="extended") for fw in D4.fundamental_weights()]
    13181365        [D2xD2(0,0,1,1) + D2xD2(1,1,0,0),
    13191366         D2xD2(0,0,2,0) + D2xD2(0,0,0,2) + D2xD2(2,0,0,0) + D2xD2(1,1,1,1) + D2xD2(0,2,0,0),
     
    13231370
    13241371    EXAMPLES: (Tensor type)
    13251372
     1373    ::
    13261374        sage: A5=WeylCharacterRing("A5", style="coroots")
    13271375        sage: A2xA1=WeylCharacterRing("A2xA1", style="coroots")
    13281376        sage: [A5(hwv).branch(A2xA1, rule="tensor") for hwv in A5.fundamental_weights()]
     
    16641712            elif Rtype[0] == 'C'  and s == r:
    16651713                if all(t[0] == Rtype[0] for t in stypes):
    16661714                    return lambda x : x
     1715            elif Rtype[0] == 'E' and s == r:
     1716                if r == 6:
     1717                    if stypes[0][0] == 'A' and stypes[0][1] == 5:
     1718                        if stypes[1][0] == 'A' and stypes[1][1] == 1:
     1719                            M = matrix(QQ,[(-3, -3, -3, -3, -3, -5, -5, 5), \
     1720                                           (-9, 3, 3, 3, 3, 1, 1, -1), \
     1721                                           (3, -9, 3, 3, 3, 1, 1, -1), \
     1722                                           (3, 3, -9, 3, 3, 1, 1, -1), \
     1723                                           (3, 3, 3, -9, 3, 1, 1, -1), \
     1724                                           (3, 3, 3, 3, -9, 9, -3, 3), \
     1725                                           (-3, -3, -3, -3, -3, -1, 11, 1), \
     1726                                           (3, 3, 3, 3, 3, 1, 1, 11)])/12
     1727                            return lambda x : tuple(M*vector(x))                       
     1728                    if len(stypes) == 3 and all(x[0] == 'A' and x[1] == 2 for x in stypes):
     1729                        M = matrix(QQ,[(0, 0, -2, -2, -2, -2, -2, 2), \
     1730                                       (-3, 3, 1, 1, 1, 1, 1, -1), \
     1731                                       (3, -3, 1, 1, 1, 1, 1, -1), \
     1732                                       (0, 0, -2, -2, 4, 0, 0, 0), \
     1733                                       (0, 0, -2, 4, -2, 0, 0, 0), \
     1734                                       (0, 0, 4, -2, -2, 0, 0, 0), \
     1735                                       (0, 0, -2, -2, -2, 2, 2, -2), \
     1736                                       (3, 3, 1, 1, 1, -1, -1, 1), \
     1737                                       (-3, -3, 1, 1, 1, -1, -1, 1)])/6
     1738                        return lambda x : tuple(M*vector(x))                       
     1739            elif Rtype[0] == 'F' and s == r:
     1740                if stypes[0][0] == 'C' and stypes[0][1] == 3:
     1741                    if stypes[1][0] == 'A' and stypes[1][1] == 1:
     1742                        return lambda x : [x[0]-x[1],x[2]+x[3],x[2]-x[3],(-x[0]-x[1])/2,(x[0]+x[1])/2]
     1743                if stypes[0][0] == 'A' and stypes[0][1] == 1:
     1744                    if stypes[1][0] == 'C' and stypes[1][1] == 3:
     1745                        return lambda x : [(-x[0]-x[1])/2,(x[0]+x[1])/2,x[0]-x[1],x[2]+x[3],x[2]-x[3]]
     1746                if stypes[0][0] == 'A' and stypes[1][0] == 'A':
     1747                    if stypes[0][1] == 2 and stypes[1][1] == 2:
     1748                        M = matrix(QQ,[(-2, -1, -1, 0), (1, 2, -1, 0), (1, -1, 2, 0), (1, -1, -1, 3), (1, -1, -1, -3), (-2, 2, 2, 0)])/3
     1749                    elif stypes[0][1] == 3 and stypes[1][1] == 1:
     1750                        M = matrix(QQ,[(-3, -1, -1, -1), (1, 3, -1, -1), (1, -1, 3, -1), (1, -1, -1, 3), (2, -2, -2, -2), (-2, 2, 2, 2)])/4
     1751                    elif stypes[0][1] == 1 and stypes[1][1] == 3:
     1752                        M = matrix(QQ,[(2, -2, -2, -2), (-2, 2, 2, 2), (-3, -1, -1, -1), (1, 3, -1, -1), (1, -1, 3, -1), (1, -1, -1, 3)])/4
     1753                    return lambda x : tuple(M*vector(x))
     1754                else:
     1755                    raise ValueError, "Rule not found"
    16671756            elif Rtype[0] == 'G' and s == r:
    16681757                if all(t[0] == 'A' and t[1] == 1 for t in stypes):
    16691758                    return lambda x : [(x[1]-x[2])/2,-(x[1]-x[2])/2, x[0]/2, -x[0]/2]