Reviewer changes with Darij.

Author: Travis Scrimshaw

src/sage/algebras/associated_graded.py

@@ -178,14 +178,16 @@ def __init__(self, A, category=None):
         base_ring = A.base_ring()
         base_one = base_ring.one()
 
-        if category is None:
-            category = A.category().Graded()
-        opts = copy(A.print_options())
-        if not opts['prefix'] and not opts['bracket']:
-            opts['bracket'] = '('
-        opts['prefix'] = opts['prefix'] + 'bar'
-
-        CombinatorialFreeModule.__init__(self, base_ring, A.indices(),
+        category = A.category().Graded().or_subcategory(category)
+        try:
+            opts = copy(A.print_options())
+            if not opts['prefix'] and not opts['bracket']:
+                opts['bracket'] = '('
+            opts['prefix'] = opts['prefix'] + 'bar'
+        except AttributeError:
+            opts = {'prefix': 'Abar'}
+
+        CombinatorialFreeModule.__init__(self, base_ring, A.basis().keys(),
                                          category=category, **opts)
 
         # Setup the conversion back

src/sage/algebras/clifford_algebra.py

@@ -426,12 +426,9 @@ class CliffordAlgebra(CombinatorialFreeModule):
     (where `\ZZ_2 = \ZZ / 2 \ZZ`); this grading is determined by
     placing all elements of `V` in degree `1`. It is also an
     `\NN`-filtered algebra, with the filtration too being defined
-    by placing all elements of `V` in degree `1`. Due to current
-    limitations of the category framework, Sage can consider
-    either the grading or the filtration but not both at the same
-    time (though one can introduce two equal Clifford algebras,
-    one filtered and the other graded); the ``graded`` parameter
-    determines which of them is to be used.
+    by placing all elements of `V` in degree `1`. The :meth:`degree` gives
+    the `\NN`-*filtration* degree, and to get the super degree use instead
+    :meth:`~sage.categories.super_modules.SuperModules.ElementMethods.is_even_odd`.
 
     The Clifford algebra also can be considered as a covariant functor
     from the category of vector spaces equipped with quadratic forms
@@ -466,8 +463,6 @@ class CliffordAlgebra(CombinatorialFreeModule):
 
     - ``Q`` -- a quadratic form
     - ``names`` -- (default: ``'e'``) the generator names
-    - ``graded`` -- (default: ``True``) if ``True``, then use the `\ZZ / 2\ZZ`
-      grading, otherwise use the `\ZZ` filtration
 
     EXAMPLES:
 
@@ -528,6 +523,9 @@ def __init__(self, Q, names, category=None):
 
             sage: Q = QuadraticForm(ZZ, 3, [1,2,3,4,5,6])
             sage: Cl = CliffordAlgebra(Q)
+            sage: Cl.category()
+            Category of finite dimensional super algebras with basis
+             over (euclidean domains and infinite enumerated sets)
             sage: TestSuite(Cl).run()
 
         TESTS:
@@ -1125,7 +1123,8 @@ def lift_isometry(self, m, names=None):
         f = lambda x: Cl.prod(Cl._from_dict( {(j,): m[j,i] for j in range(n)},
                                              remove_zeros=True )
                               for i in x)
-        return self.module_morphism(on_basis=f, codomain=Cl)
+        return self.module_morphism(on_basis=f, codomain=Cl,
+                                    category=AlgebrasWithBasis(self.base_ring()).Super())
 
     # This is a general method for finite dimensional algebras with bases
     #   and should be moved to the corresponding category once there is
@@ -1348,7 +1347,7 @@ class ExteriorAlgebra(CliffordAlgebra):
     `Q(v) = 0` for all vectors `v \in V`. See :class:`CliffordAlgebra`
     for the notion of a Clifford algebra.
 
-    The exterior algebra of an `R`-module `V` is a super connected
+    The exterior algebra of an `R`-module `V` is a connected `\ZZ`-graded
     Hopf superalgebra. It is commutative in the super sense (i.e., the
     odd elements anticommute and square to `0`).
 
@@ -1422,6 +1421,9 @@ def __init__(self, R, names):
         EXAMPLES::
 
             sage: E.<x,y,z> = ExteriorAlgebra(QQ)
+            sage: E.category()
+            Category of finite dimensional super hopf algebras with basis
+             over Rational Field
             sage: TestSuite(E).run()
         """
         cat = HopfAlgebrasWithBasis(R).Super()
@@ -1569,7 +1571,7 @@ def lift_morphism(self, phi, names=None):
         f = lambda x: E.prod(E._from_dict( {(j,): phi[j,i] for j in range(n)},
                                            remove_zeros=True )
                              for i in x)
-        return self.module_morphism(on_basis=f, codomain=E)
+        return self.module_morphism(on_basis=f, codomain=E, category=AlgebrasWithBasis(R).Super())
 
     def volume_form(self):
         """

src/sage/algebras/weyl_algebra.py

@@ -589,6 +589,7 @@ def __init__(self, R, names=None):
             raise ValueError("variable names cannot differ by a leading 'd'")
         # TODO: Make this into a filtered algebra under the natural grading of
         #   x_i and dx_i have degree 1
+        # Filtered is not included because it is a supercategory of super
         if R.is_field():
             cat = AlgebrasWithBasis(R).NoZeroDivisors().Super()
         else:

src/sage/categories/filtered_algebras_with_basis.py

@@ -461,14 +461,14 @@ def induced_graded_map(self, other, f):
                 sage: Q = QuadraticForm(ZZ, 2, [1,2,3])
                 sage: B = CliffordAlgebra(Q, names=['u','v']); B
                 The Clifford algebra of the Quadratic form in 2
-                 variables over Integer Ring with coefficients: 
+                 variables over Integer Ring with coefficients:
                 [ 1 2 ]
                 [ * 3 ]
                 sage: m = Matrix(ZZ, [[1, 2], [1, -1]])
                 sage: f = B.lift_module_morphism(m, names=['x','y'])
                 sage: A = f.domain(); A
                 The Clifford algebra of the Quadratic form in 2
-                 variables over Integer Ring with coefficients: 
+                 variables over Integer Ring with coefficients:
                 [ 6 0 ]
                 [ * 3 ]
                 sage: x, y = A.gens()
@@ -521,7 +521,7 @@ def on_basis(m):
                 lifted_img_of_m = f(from_gr(grA.monomial(m)))
                 return other.projection(i)(lifted_img_of_m)
             return grA.module_morphism(on_basis=on_basis,
-                                       codomain=grB, category=cat)    
+                                       codomain=grB, category=cat)
             # If we could assume that the projection of the basis
             # element of ``self`` indexed by an index ``m`` is the
             # basis element of ``grA`` indexed by ``m``, then this

src/sage/categories/filtered_modules_with_basis.py

@@ -562,7 +562,7 @@ def on_basis(m):
                 lifted_img_of_m = f(from_gr(grA.monomial(m)))
                 return other.projection(i)(lifted_img_of_m)
             return grA.module_morphism(on_basis=on_basis,
-                                       codomain=grB, category=cat)    
+                                       codomain=grB, category=cat)
             # If we could assume that the projection of the basis
             # element of ``self`` indexed by an index ``m`` is the
             # basis element of ``grA`` indexed by ``m``, then this

src/sage/categories/modules_with_basis.py

@@ -126,8 +126,8 @@ class ModulesWithBasis(CategoryWithAxiom_over_base_ring):
     .. NOTE::
 
         This category currently requires an implementation of an
-        element method ``support``. Once :trac:`18066`, an implementation
-        of an ``items`` method will be required.
+        element method ``support``. Once :trac:`18066` is merged, an
+        implementation of an ``items`` method will be required.
 
     TESTS::
 

src/sage/categories/super_algebras.py

@@ -48,3 +48,20 @@ def extra_super_categories(self):
         """
         return [self.base_category().Graded()]
 
+    class ParentMethods:
+        def graded_algebra(self):
+            r"""
+            Return the associated graded algebra to ``self``.
+
+            .. WARNING::
+
+                Because a super module `M` is naturally `\ZZ / 2 \ZZ`-graded, and
+                graded modules have a natural filtration induced by the grading, if
+                `M` has a different filtration, then the associated graded module
+                `\operatorname{gr} M \neq M`. This is most apparent with super
+                algebras, such as the :class:`differential Weyl algebra
+                <sage.algebras.weyl_algebra.DifferentialWeylAlgebra>`, and the
+                multiplication may not coincide.
+            """
+            raise NotImplementedError
+

src/sage/categories/super_algebras_with_basis.py

@@ -37,3 +37,25 @@ def extra_super_categories(self):
         """
         return [self.base_category().Graded()]
 
+    class ParentMethods:
+        def graded_algebra(self):
+            r"""
+            Return the associated graded module to ``self``.
+
+            See :class:`~sage.algebras.associated_graded.AssociatedGradedAlgebra`
+            for the definition and the properties of this.
+
+            .. SEEALSO::
+
+                :meth:`~sage.categories.filtered_modules_with_basis.ParentMethods.graded_algebra`
+
+            EXAMPLES::
+
+                sage: W.<x,y> = algebras.DifferentialWeyl(QQ)
+                sage: W.graded_algebra()
+                Graded Algebra of Differential Weyl algebra of
+                 polynomials in x, y over Rational Field
+            """
+            from sage.algebras.associated_graded import AssociatedGradedAlgebra
+            return AssociatedGradedAlgebra(self)
+

src/sage/categories/super_modules.py

@@ -87,7 +87,7 @@ def _repr_object_names(self):
         return "super {}".format(self.base_category()._repr_object_names())
 
 class SuperModules(SuperModulesCategory):
-    """
+    r"""
     The category of super modules.
 
     An `R`-*super module* (where `R` is a ring) is an `R`-module `M` equipped