Merge commit '4f3f1b8b' into public/categories/tensor_maps-15832

Conflicts:
	src/sage/categories/algebras_with_basis.py
	src/sage/categories/modules_with_basis.py
	src/sage/combinat/free_module.py

Author: Travis Scrimshaw

src/sage/categories/algebras_with_basis.py

@@ -11,6 +11,9 @@
 
 from sage.misc.cachefunc import cached_method
 from sage.misc.lazy_attribute import lazy_attribute
+from sage.misc.abstract_method import abstract_method
+from sage.misc.constant_function import ConstantFunction
+from sage.misc.misc import compose
 from sage.misc.lazy_import import LazyImport
 from sage.categories.tensor import TensorProductsCategory, tensor
 from sage.categories.cartesian_product import CartesianProductsCategory
@@ -193,6 +196,91 @@ def _product_from_combinatorial_algebra_multiply(self,left,right):
         #    tester.assert_(self.product is not None)
         #    could check that self.product is in Hom( self x self, self)
 
+        def _product_on_basis_tuple(self, tup):
+            return self.product_on_basis(*tup)
+
+        def _product_on_tensor_basis(self):
+            r"""
+            Return the function whose sole input is an index for the tensor square of ``self``,
+            and whose output is the product of monomials indexed by the corresponding pair of basis elements.
+
+            EXAMPLES::
+
+                sage: W=WeylGroup("A2",prefix="s")
+                sage: A = W.algebra(ZZ)
+                sage: AA = tensor([A,A])
+                sage: k = AA.basis().keys().an_element(); k
+                (s1*s2*s1, s1*s2*s1)
+                sage: A._product_on_tensor_basis()(k)
+                B[1]
+                sage: AAAA = tensor([AA,AA])
+                sage: kk = AAAA.basis().keys().an_element(); kk
+                (s1*s2*s1, s1*s2*s1, s1*s2*s1, s1*s2*s1)
+                sage: AA._product_on_tensor_basis()(kk)
+                B[1] # B[1]
+
+            """
+            # The algebra tensor product has functions which handle basis indices
+            AA = tensor([self,self])
+            return compose(self._product_on_basis_tuple, AA.index_to_indices())
+
+        def _product_morphism(self):
+            r"""
+            The multiplication map as a module morphism from the twofold tensor of ``self``, to ``self``.
+
+            EXAMPLES::
+
+                sage: W = WeylGroup(CartanType(['A',2]),prefix="s")
+                sage: A = W.algebra(ZZ); A.rename("A")
+                sage: mA = A._product_morphism(); mA
+                Generic morphism:
+                From: A # A
+                To:   A
+                sage: a = A.monomial(W.from_reduced_word([1,2])); a
+                B[s1*s2]
+                sage: b = A.an_element(); b
+                B[s1*s2*s1] + 3*B[s1*s2] + 3*B[s2*s1]
+                sage: ab = tensor([a,b]); ab
+                B[s1*s2] # B[s1*s2*s1] + 3*B[s1*s2] # B[s1*s2] + 3*B[s1*s2] # B[s2*s1]
+                sage: mA(mA.domain()(ab))
+                3*B[s2*s1] + B[s2] + 3*B[1]
+                sage: a*b
+                3*B[s2*s1] + B[s2] + 3*B[1]
+                sage: AA = tensor([A,A])
+                sage: mAA = AA._product_morphism()
+                sage: mAA(mAA.domain()(tensor([a,b,b,b])))
+                27*B[s2*s1] # B[s1*s2] + 27*B[s2*s1] # B[s2*s1] + 18*B[s2*s1] # B[s1] + 18*B[s2*s1] # B[s2] + 57*B[s2*s1] # B[1] + 9*B[s2] # B[s1*s2] + 9*B[s2] # B[s2*s1] + 6*B[s2] # B[s1] + 6*B[s2] # B[s2] + 19*B[s2] # B[1] + 27*B[1] # B[s1*s2] + 27*B[1] # B[s2*s1] + 18*B[1] # B[s1] + 18*B[1] # B[s2] + 57*B[1] # B[1]
+
+            """
+            from sage.categories.modules_with_basis import ModulesWithBasis
+            module_category = ModulesWithBasis(self.base_ring())
+            AA = tensor([self, self], category=module_category)
+            return AA.module_morphism(on_basis=self._product_on_tensor_basis(), codomain=self, category=module_category)
+
+        def _unit_morphism(self):
+            r"""
+            The unit map as a module morphism from the base ring to ``self``.
+
+            Note that the domain is the tensor unit module,
+            the base ring viewed as a free module.
+
+            EXAMPLES::
+
+                sage: W = WeylGroup(CartanType(['A',2]),prefix="s")
+                sage: A = W.algebra(ZZ); A.rename("A")
+                sage: unit = A._unit_morphism(); unit
+                Generic morphism:
+                From: The unit object in Category of tensor products of hopf algebras with basis over Integer Ring
+                To:   A
+                sage: unit(3*unit.domain().one())
+                3*B[1]
+
+            """
+            from sage.categories.modules_with_basis import ModulesWithBasis
+            U = self.tensor_unit()
+            one_func = ConstantFunction(self.one())
+            return U.module_morphism(on_basis=one_func, codomain=self, category=ModulesWithBasis(self.base_ring()))
+
     class ElementMethods:
 
         def __invert__(self):
@@ -328,8 +416,41 @@ def extra_super_categories(self):
 
         class ParentMethods:
             """
-            implements operations on tensor products of algebras with basis
+            Implements operations on tensor products of algebras with basis.
             """
+            @abstract_method
+            def factors(self):
+                r"""
+                The tensor factor algebras of `self`.
+
+                EXAMPLES::
+
+                    sage: W = WeylGroup("A2",prefix="s")
+                    sage: A = W.algebra(ZZ); A.rename("A")
+                    sage: A2 = tensor([A,A])
+                    sage: A22 = tensor([A2,A2])
+                    sage: A22.factors()
+                    (A # A, A # A)
+                    sage: A4 = tensor([A,A,A,A])
+                    sage: A4.factors()
+                    (A, A, A, A)
+
+                """
+                pass
+
+            @abstract_method
+            def index_to_indices(self):
+                r"""
+                The function which maps a basis index of ``self`` to a tuple of basis indices for ``self.factors()``.
+                """
+                pass
+
+            @abstract_method
+            def indices_to_index(self):
+                r"""
+                The function which maps a tuple of basis indices for ``self.factors()`` to an index of ``self.basis()``.
+                """
+                pass
 
             @cached_method
             def one_basis(self):
@@ -353,11 +474,11 @@ def one_basis(self):
                     sage: B.one()
                     B[word: ] # B[word: ] # B[word: ]
                 """
-                # FIXME: this method should be conditionaly defined,
+                # FIXME: this method should be conditionally defined,
                 # so that B.one_basis returns NotImplemented if not
                 # all modules provide one_basis
-                if all(hasattr(module, "one_basis") for module in self._sets):
-                    return tuple(module.one_basis() for module in self._sets)
+                if all(hasattr(module, "one_basis") for module in self.factors()):
+                    return self.indices_to_index()(*tuple(module.one_basis() for module in self.factors()))
                 else:
                     raise NotImplementedError
 
@@ -386,10 +507,12 @@ def product_on_basis(self, t1, t2):
                     sage: x*y
                     B[word: a] # B[word: c] + B[word: ac] # B[word: ca] + 2*B[word: b] # B[word: c] + 2*B[word: bc] # B[word: ca]
 
-
                 TODO: optimize this implementation!
+
+                FIX THIS EXAMPLE!!!
+
                 """
-                return tensor( (module.monomial(x1)*module.monomial(x2) for (module, x1, x2) in zip(self._sets, t1, t2)) ) #.
+                return tensor( (module.monomial(x1)*module.monomial(x2) for (module, x1, x2) in zip(self.factors(), self.index_to_indices()(t1), self.index_to_indices()(t2)))) #.
 
         class ElementMethods:
             """

src/sage/categories/covariant_functorial_construction.py

@@ -140,7 +140,8 @@ def category_from_parents(self, parents):
             Category of tensor products of vector spaces with basis over Rational Field
         """
         from sage.structure.parent import Parent
-        assert(all(isinstance(parent, Parent) for parent in parents))
+        if not all(isinstance(parent, Parent) for parent in parents):
+            raise TypeError, "Not all items are parents"
         # Should we pass a set of categories to reduce the cache size?
         # But then this would impose that, for any constructor, the
         # category of the result does not depend on the order/repetition
@@ -170,7 +171,8 @@ def category_from_categories(self, categories):
             sage: cartesian_product.category_from_categories((Cat1, Cat2))
             Category of Cartesian products of monoids
         """
-        assert(len(categories) > 0)
+        if not len(categories) > 0:
+            raise ValueError, "There should be at least one category"
         return self.category_from_category(Category.meet(categories))
 
     def category_from_category(self, category):
@@ -201,13 +203,14 @@ def _repr_(self):
         """
         return "The %s functorial construction"%self._functor_name
 
-    def __call__(self, args):
+    def __call__(self, args, **keywords):
         """
         Functorial construction application
 
         INPUT:
          - ``self``: a covariant functorial construction `F`
          - ``args``: a tuple (or iterable) of parents or elements
+         - ``keywords``: a dictionary of keyword=value arguments
 
         Returns `F(args)`
 
@@ -216,11 +219,14 @@ def __call__(self, args):
             sage: E = CombinatorialFreeModule(QQ, ["a", "b", "c"]); E.rename("E")
             sage: tensor((E, E, E))
             E # E # E
+
         """
         args = tuple(args) # a bit brute force; let's see if this becomes a bottleneck later
-        assert(all( hasattr(arg, self._functor_name) for arg in args))
-        assert(len(args) > 0)
-        return getattr(args[0], self._functor_name)(*args[1:])
+        if not all(hasattr(arg, self._functor_name) for arg in args):
+            raise TypeError, "Some item cannot apply the functor %s"%self._functor_name
+        if not len(args) > 0:
+            raise ValueError, "There should be at least one item"
+        return getattr(args[0], self._functor_name)(*args[1:], **keywords)
 
 class FunctorialConstructionCategory(Category): # Should this be CategoryWithBase?
     """
@@ -421,7 +427,8 @@ def __init__(self, category, *args):
             sage: import __main__; __main__.FooBars = FooBars # Fake FooBars being defined in a python module
             sage: TestSuite(C).run()
         """
-        assert isinstance(category, Category)
+        if not isinstance(category, Category):
+            raise TypeError, "Should be a category"
         self._base_category = category
         self._args = args
         super(FunctorialConstructionCategory, self).__init__(*args)