Ticket #3664: trac_3664-1.patch

a/sage/combinat/crystals/crystals.py

@@ -145 +145 @@
-        EXAMPLES:
-            sage: C = CrystalOfLetters(['A', 5])
-            sage: C.weight_lattice_realization()
-lattice of the r
+space for the R
-        """
-latti
+spa
-
-    def Lambda(self):
-        """

a/sage/combinat/root_system/all.py

@@ -1 +1 @@
-from cartan_type import CartanType
-
+DynkinDiagram, 
-from cartan_matrix import cartan_matrix
-from coxeter_matrix import coxeter_matrix
-from root_system import RootSystem, WeylDim

/dev/null

@@ +1 @@
+from sage.combinat.free_module import CombinatorialFreeModule, CombinatorialFreeModuleElement
+from root_lattice_realization import RootLatticeRealizationElement
+from weight_lattice_realization import WeightLatticeRealization
+from sage.modules.free_module import FreeModule
+from sage.rings.all import ZZ, QQ
+from sage.modules.free_module_element import vector
+
+class AmbientSpace(CombinatorialFreeModule, WeightLatticeRealization):
+    r"""
+    Abstract class for ambient spaces
+
+    Any implementation of this class should implement a class method
+    smallest_base_ring as described below, and a method dimension
+    working on a partially initialized instance with just root_system
+    as attribute. There is no safe default implementation for the later,
+    so none is provided.
+    """
+
+    # FIXME: attribute or method?
+    def dimension(self):
+        """
+        Returns the dimension of this ambient space
+        """
+        raise NotImplementedError
+    
+    @classmethod
+    def smallest_base_ring(cls):
+        """
+        Returns the smallest ground ring over which the ambient space can be realized
+        """
+        return QQ;
+
+    def __init__(self, root_system, base_ring):
+        """
+        EXAMPLES:
+            sage: e = RootSystem(['A',3]).ambient_lattice()
+            sage: e == loads(dumps(e))
+            True
+        """
+        self.root_system = root_system
+        basis_name = "alphacheck" if root_system.dualSide else "alpha"
+        CombinatorialFreeModule.__init__(self, base_ring,\
+                                         #range(1,self.dimension()+1),\
+                                         range(0,self.dimension()),\
+                                         element_class = AmbientSpaceElement,\
+                                         prefix='e')
+
+        # FIXME: here for backward compatibility;
+        # Should we use dimension everywhere?
+        self.n = self.dimension()
+
+    def __repr__(self):
+        """
+        TEST:
+            sage: RootSystem(['A',4]).ambient_lattice()
+            Ambient lattice for the Root system of type ['A', 4]
+            sage: RootSystem(['B',4]).ambient_space()
+            Ambient space for the Root system of type ['B', 4]
+
+        """
+        if self.base_ring() == ZZ:
+            space = "lattice"
+        else:
+            space = "space"
+        return "Ambient "+space+" for the %s"%self.root_system
+
+    def __call__(self, v):
+        """
+        TESTS:
+            sage: R = RootSystem(['A',4]).ambient_lattice()
+            sage: R([1,2,3,4,5])
+            (1, 2, 3, 4, 5)
+        """
+        # This adds coercion from a list
+        if isinstance(v, list) or isinstance(v, tuple):
+            K = self.base_ring()
+            return self._from_dict(dict([(i,K(v[i])) for i in range(len(v))]))
+        else:
+            return CombinatorialFreeModule.__call__(self, v)
+
+    # For backward compatibility
+    def _term(self, i):
+        self.term(i)
+
+    def __getitem__(self,i):
+        """
+        Note that indexing starts at 1.
+        
+        EXAMPLES:
+            sage: e = RootSystem(['A',2]).ambient_lattice()
+            sage: e[1]
+            (1, 0, 0)
+        """
+        return self.term(i-1)
+
+    def coroot_lattice(self):
+        return self
+
+    def simple_coroot(self, i):
+        r"""
+        Returns the i-th simple coroot, as an element of this space
+
+        EXAMPLE:
+        sage: R = RootSystem(["A",3])
+        sage: L = R.ambient_lattice ()
+        sage: L.simple_coroot(1)
+        (1, -1, 0, 0)
+        sage: L.simple_coroot(2)
+        (0, 1, -1, 0)
+        sage: L.simple_coroot(3)
+        (0, 0, 1, -1)
+        """        
+        return self.simple_root(i).associated_coroot()
+
+    def reflection(self, root, coroot=None):
+        # TODO: get rid of this as one can use the generic implementation
+        # (i.e. scalar and associated coroot are implemented)
+        return lambda v: v-2*root.inner_product(v)/root.inner_product(root)*root
+
+    def _term(self, i):
+        """
+        Note that indexing starts at 0.
+
+        EXAMPLES:
+            sage: e = RootSystem(['A',2]).ambient_lattice()
+            sage: e._term(0)
+            (1, 0, 0)
+        """
+        return self.term(i)
+
+    def __cmp__(self, other):
+        """
+        EXAMPLES:
+            sage: e1 = RootSystem(['A',3]).ambient_lattice()
+            sage: e2 = RootSystem(['B',3]).ambient_lattice()
+            sage: e1 == e1
+            True
+            sage: e1 == e2
+            False
+        """
+        if self.__class__ != other.__class__:
+            return cmp(self.__class__, other.__class__)
+        if self.root_system != other.root_system:
+            return cmp(self.root_system, other.root_system)
+        return 0
+
+class AmbientSpaceElement(CombinatorialFreeModuleElement, RootLatticeRealizationElement):
+
+    # For backward compatibility
+    def __repr__(self):
+        return str(self.to_vector())
+    
+    def inner_product(self, lambdacheck):
+        """
+        The scalar product with elements of the coroot lattice
+        embedded in the ambient space
+        """
+        assert(lambdacheck.parent() == self.parent())
+        return sum((c*self[t] for (t,c) in lambdacheck),
+                   self.parent().base_ring().zero_element())
+
+    scalar = inner_product
+    dot_product = inner_product
+
+    def associated_coroot(self):
+        # FIXME: make it work over ZZ!
+        return self * (2/self.inner_product(self))
+

a/sage/combinat/root_system/cartan_matrix.py

@@ -15 +15 @@
-#
-#                  http://www.gnu.org/licenses/
-#*****************************************************************************
-from dynkin_diagram import dynkin_diagram_as_function
-import cartan_type 
-from sage.matrix.all import MatrixSpace
-from sage.rings.all import ZZ
-
-def cartan_matrix_as_function(t):
-    """
-    Returns a function that represents the Cartan matrix
-    of type t.
-
-    EXAMPLES:
-        sage: from sage.combinat.root_system.cartan_matrix import cartan_matrix_as_function
-        sage: f = cartan_matrix_as_function(['A',4])
-        sage: matrix([[f(i,j) for j in range(1,5)] for i in range(1,5)])
-        [ 2 -1  0  0]
-        [-1  2 -1  0]
-        [ 0 -1  2 -1]
-        [ 0  0 -1  2]    
-    """
-    ct = cartan_type.CartanType(t)    
-    f = dynkin_diagram_as_function(ct)
-    cmf = lambda i,j: 2 if i == j else -f(j,i)
-    return cmf
-
-def cartan_matrix(t):
-    """
@@ -54 +34 @@
-        [-1  2 -1  0  0  0]
-        [ 0 -1  2 -1  0  0]
-        [ 0  0 -1  2 -1  0]
-2
-1
+1
+2
-        sage: cartan_matrix(['C', 4])
-        [ 2 -1  0  0]
-        [-1  2 -1  0]
-1
-2
+2
+1
-        sage: cartan_matrix(['D', 6])
-        [ 2 -1  0  0  0  0]
-        [-1  2 -1  0  0  0]
@@ -68 +48 @@
-        [ 0  0 -1  2 -1 -1]
-        [ 0  0  0 -1  2  0]
-        [ 0  0  0 -1  0  2]
+        sage: cartan_matrix(['E',6])
+        [ 2  0 -1  0  0  0]
+        [ 0  2  0 -1  0  0]
+        [-1  0  2 -1  0  0]
+        [ 0 -1 -1  2 -1  0]
+        [ 0  0  0 -1  2 -1]
+        [ 0  0  0  0 -1  2]
+        sage: cartan_matrix(['E',7])
+        [ 2  0 -1  0  0  0  0]
+        [ 0  2  0 -1  0  0  0]
+        [-1  0  2 -1  0  0  0]
+        [ 0 -1 -1  2 -1  0  0]
+        [ 0  0  0 -1  2 -1  0]
+        [ 0  0  0  0 -1  2 -1]
+        [ 0  0  0  0  0 -1  2]
-        sage: cartan_matrix(['E', 8])
-        [ 2  0 -1  0  0  0  0  0]
-        [ 0  2  0 -1  0  0  0  0]
@@ -79 +74 @@
-        [ 0  0  0  0  0  0 -1  2]
-        sage: cartan_matrix(['F', 4])
-        [ 2 -1  0  0]
-
+
+
+
+
+
+
+
+
+
+
+
+
-        [ 0 -1  2 -1]
+        [-1  0 -1  2]
+        sage: cartan_matrix(['B', 3, 1])
+        [ 2  0 -1  0]
+        [ 0  2 -1  0]
+        [-1 -1  2 -1]
+        [ 0  0 -2  2]
+        sage: cartan_matrix(['C', 3, 1])
+        [ 2 -1  0  0]
+        [-2  2 -1  0]
+        [ 0 -1  2 -2]
-        [ 0  0 -1  2]
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    """
-c
-index_set = ct.index_set
-cmf = cartan_matrix_as_function(ct
+
+dynkin_diagram = t.dynkin_diagram
+index_set = t.index_set(
-    MS = MatrixSpace(ZZ, len(index_set), sparse=True)
-    m = MS(0)
-    for i in range(len(index_set)):
-        for j in range(len(index_set)):
-cmf(index_set[i],index_set[j])
+dynkin_diagram[index_set[i],index_set[j]]
-    return m

a/sage/combinat/root_system/cartan_type.py

@@ -15 +15 @@
-#
-#                  http://www.gnu.org/licenses/
-#*****************************************************************************
-
+
+
-from cartan_matrix import cartan_matrix
+from sage.rings.all import ZZ
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    """
-    Returns an object corresponding to the Cartan type t.
+    INPUT:
+       [letter, rank]
+    where letter is one of 'A','B','C','D','E','F','G' and rank
+    is the rank. An alternative string notation is allowed.
+    A third optional parameter is permitted for affine
+    types. Reducible types may be entered by giving a list of
+    irreducible types or by a single string 
-
-    EXAMPLES:
-        sage: CartanType(['A',4])
-        ['A', 4]
+        sage: CartanType("A4")
+        ['A', 4]
+        sage: CartanType(['A',2],['B',2])
+        A2xB2
+        sage: CartanType(['A',2],['B',2]).is_reducible()
+        True
+        sage: CartanType("A2xB2")
+        A2xB2
+        sage: CartanType("A2","B2") == CartanType("A2xB2")
+        True
+        sage: CartanType(['A',4,1])
+        ['A', 4, 1]
+        sage: CartanType(['A',4,1]).is_affine()
+        True
-    """
-
+
+
+
+
+
-        return t
-    else:
-        return CartanType_simple(t)
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        """
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
-
-    def rank(self):
-        """
@@ -174 +168 @@
-            sage: CartanType(['I', 8]).rank()
-            2
-        """
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-    def index_set(self):
-        """
@@ -213 +301 @@
-            sage: CartanType(['A',4]).root_system()
-            Root system of type ['A', 4]
-        """
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-    def cartan_matrix(self):
-        """
@@ -227 +368 @@
-            [ 0  0 -1  2]
-
-        """
-
+root_system.cartan_matrix.
-
-    def type(self):
-        """
@@ -236 +377 @@
-        EXAMPLES:
-            sage: CartanType(['A', 4]).type()
-            'A'
+            sage: CartanType(['A', 4, 1]).type()
+            'A'
-        """
-        return self.letter
+
+    def type_string(self):
+        """
+        Returns a string suitable for type-specific code dispatch
+
+        EXAMPLES:
+            sage: CartanType(['A', 4]).type_string()
+            'type_A'
+            sage: CartanType(['A', 4, 1]).type_string()
+            'type_A_affine'
+        """
+        if self.is_affine():
+            return "type_%s_affine"%self.letter
+        else:
+            return "type_%s"%self.letter
+
+    def dual(self):
+        if self.type() in ["A", "D", "E"]:
+            return self
+        else:
+            return CartanType_abstract.dual(self)
+
+    def is_irreducible(self):
+        """
+        Report that this Cartan type is irreducible.
+        """
+        return True
+
+class CartanType_simple_finite(CartanType_simple):
+    r"""
+    A class for finite simple Cartan types
+    """
+
+    def __init__(self, t):
+        """
+        EXAMPLES:
+            sage: ct = CartanType(['A',4])
+            sage: ct == loads(dumps(ct))
+            True
+        """
+        assert(len(t) == 2)
+        assert(t[0] in ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I'])
+        assert(t[1] in ZZ and t[1] >= 0)
+        if t[0] in ['B', 'C']:
+            assert(t[1] >= 2)
+        if t[0] == 'D':
+            assert(t[1] >= 3)
+        if t[0] == 'E':
+            assert(t[1] <= 8)
+        if t[0] == 'F':
+            assert(t[1] <= 4)
+        if t[0] == 'G':
+            assert(t[1] <= 2)
+        if t[0] == 'H':
+            assert(t[1] <= 4)
+
+        self.t = t
+        self.letter = t[0]
+        self.n = t[1]
+
+
+    def __repr__(self):
+        """
+        TESTS:
+            sage: ct = CartanType(['A',3])
+            sage: repr(ct)
+            "['A', 3]"
+        """
+        return "['%s', %s]"%(self.letter, self.n)
+
+    def __len__(self):
+        """
+        EXAMPLES:
+            sage: len(CartanType(['A',4]))
+            2
+        """
+        return 2
+
+    def __cmp__(self, other):
+        if other.__class__ != self.__class__:
+            return cmp(self.__class__, other.__class__)
+        if other.letter != self.letter:
+            return cmp(self.letter, other.letter)
+        return cmp(self.n, other.n)
+
+    def rank(self):
+        if self.letter == "I":
+            return 2
+        else:
+            return self.n
+    def is_finite(self):
+        return True
+
+    def is_affine(self):
+        return False
+
+    def is_crystalographic(self):
+        return self.letter in ["A", "B", "C", "D", "E", "F", "G"]
+
+    def is_simply_laced(self):
+        return self.letter in  ["A", "D", "E"]
+
+    def affine(self):
+        """
+        Returns the corresponding untwisted affine Cartan type
+
+        EXAMPLES:
+            sage: CartanType(['A',3]).affine()
+            ['A', 3, 1]
+        """
+        return CartanType([self.letter, self.n, 1])
+
+    def dual(self):
+        if self.type() == "B":
+            return CartanType(["C",self.n])
+        elif self.type() == "C":
+            return CartanType(["B",self.n])
+        else:
+            return CartanType_simple.dual(self)
+
+##########################################################################
+class CartanType_simple_affine(CartanType_simple):
+    r"""
+    A class for affine simple Cartan types
+    """
+
+    def __init__(self, t):
+        """
+        EXAMPLES:
+            sage: ct = CartanType(['A',4])
+            sage: ct == loads(dumps(ct))
+            True
+        """
+        assert(len(t) == 3)
+        assert(t[0] in ['A', 'B', 'C', 'D', 'E', 'F', 'G'])
+        assert(t[1] in ZZ and t[1] >= 1)
+        assert(t[2] in [1,2,3])
+        if t[0] in ['B', 'C']:
+            assert(t[1] >= 2)
+        if t[0] == 'D':
+            assert(t[1] >= 4)
+        if t[0] == 'E':
+            assert(t[1] <= 8)
+        if t[0] == 'F':
+            assert(t[1] <= 4)
+        if t[0] == 'G':
+            assert(t[1] <= 2)
+        if t[2] == 3:
+            assert(t[0] == "D")
+            assert(t[1] == 4)
+        if t[2] == 2:
+            assert(t[0] in ['A', 'D', 'E'])
+            if t[0] == 'E':
+                assert(t[1] == 6)
+
+        self.t = t
+        self.letter = t[0]
+        self.n = t[1]
+        self.affine = t[2]
+
+    def __repr__(self):
+        """
+        TESTS:
+            sage: ct = CartanType(['A',3, 1])
+            sage: repr(ct)
+            "['A', 3, 1]"
+        """
+        return "['%s', %s, %s]"%(self.letter, self.n, self.affine)
+
+    def __cmp__(self, other):
+        c = CartanType_simple_finite.cmp(self, other)
+        if c != 0:
+            return c
+        else:
+            return cmp(self.affine, other.affine)
+
+    def __len__(self):
+        """
+        EXAMPLES:
+            sage: len(CartanType(['A',4,1]))
+            3
+        """
+        return 3
+
+    def rank(self):
+        if self.affine == 3 and self.letter == 'D':
+            return self.n-1
+        elif self.affine == 2 and self.letter == 'A':
+            ## FIXME: check in the literature what should be the
+            ## appropriate definition for rank
+            return int(self.n+1)/2
+        else:
+            return self.n
+
+    def is_finite(self):
+        return False
+
+    def is_affine(self):
+        return True
+
+    def is_crystalographic(self):
+        return True
+
+    def is_simply_laced(self):
+        if self.affine != 1:
+            return False
+        if self.letter == "A":
+            return self.n > 1
+        return self.letter in  ["D", "E"]
+
+    def classical(self):
+        r"""
+        Returns the classical Cartan type associated with self (which should be affine)
+
+        Caveat: only implemented for untwisted
+
+        EXAMPLES:
+            sage: CartanType(['A', 3, 1]).classical()
+            ['A', 3]
+            sage: CartanType(['B', 3, 1]).classical()
+            ['B', 3]