Ticket #5891: categories-fixsagelib-nt.patch

sage/structure/element.pyx

@@ -329 +329 @@
         return self._parent.base_ring()
 
     def category(self):
-        from sage.categories.category_types import Elements
+        from sage.categories.all import Elements
         return Elements(self._parent)
 
     def parent(self, x=None):

sage/structure/wrapper_parent.pyx

@@ -47 +47 @@
 
 import copy
 import inspect
-from sage.categories.category_types import Objects
+from sage.categories.all import Objects
 from sage.categories.homset import Hom
 from sage.rings.ring import Ring
 from sage.categories.morphism import CallMorphism

sage/combinat/species/series.py

@@ -36 +36 @@
 from sage.algebras.algebra import Algebra
 from sage.algebras.algebra_element import AlgebraElement
 import sage.structure.parent_base
-
+from sage.categories.all import Rings
 
 class LazyPowerSeriesRing(Algebra):
     def __init__(self, R, element_class = None, names=None):
@@ -49 +49 @@
             Lazy Power Series Ring over Rational Field
         """
         #Make sure R is a ring with unit element
-        if not isinstance(R, Ring):
+        if not R in Rings():
             raise TypeError, "Argument R must be a ring."
         try:
             z = R(Integer(1))

sage/modules/matrix_morphism.py

@@ -50 +50 @@
 """
 
 
-import sage.categories.all
+import sage.categories.morphism
 import sage.categories.homset
 import sage.matrix.all as matrix
 import sage.misc.misc as misc
@@ -60 +60 @@
 def is_MatrixMorphism(x):
     return isinstance(x, MatrixMorphism_abstract)
 
-class MatrixMorphism_abstract(sage.categories.all.Morphism):
+class MatrixMorphism_abstract(sage.categories.morphism.Morphism):
     def __init__(self, parent):
         """
         INPUT:
@@ -83 +83 @@
         """
         if not sage.categories.homset.is_Homset(parent):
             raise TypeError, "parent must be a Hom space"
-        sage.categories.all.Morphism.__init__(self, parent)
+        sage.categories.morphism.Morphism.__init__(self, parent)
 
     def __cmp__(self, other):
         return cmp(self.matrix(), other.matrix())

sage/modules/module.pyx

@@ -23 +23 @@
     """
     Generic module class.
     """
+#    def __call__(self, x):
+#        """
+#        Coerce x into the ring.
+#        """
+#        raise NotImplementedError
+    # Should be deprecated as soon as all modules declare their
+    # category properly at initialization
     def category(self):
         """
         Return the category to which this module belongs.
         """
-        import sage.categories.all
-        return sage.categories.all.Modules(self.base_ring())
+        category = sage.structure.category_object.CategoryObject.category(self)
+        from sage.categories.all import Objects, Modules
+        if category == Objects():
+            return Modules(self.base_ring())
+        else:
+            return category
 
     def endomorphism_ring(self):
         """

sage/probability/random_variable.py

@@ -15 +15 @@
 #                  http://www.gnu.org/licenses/
 #*****************************************************************************
 
-import sage.categories.all
-
 from sage.structure.parent_base import ParentWithBase
 from sage.misc.functional import sqrt, log
 from sage.rings.all import RealField, RationalField, is_RealField, is_RationalField

sage/rings/homset.py

@@ -10 +10 @@
 #                  http://www.gnu.org/licenses/
 #*****************************************************************************
 
-from sage.categories.all import HomsetWithBase, Rings
+from sage.categories.homset import HomsetWithBase
 from sage.structure.parent_base import ParentWithBase
 
 import morphism
 import quotient_ring
 
-RINGS = Rings()
-
-
 def is_RingHomset(H):
     return isinstance(H, RingHomset_generic)
 
-def RingHomset(R, S):
+def RingHomset(R, S, category = None):
     if quotient_ring.is_QuotientRing(R):
-        return RingHomset_quo_ring(R, S)
-    return RingHomset_generic(R, S)
+        return RingHomset_quo_ring(R, S, category = category)
+    return RingHomset_generic(R, S, category = category)
 
 
 class RingHomset_generic(HomsetWithBase):
-    def __init__(self, R, S):
-        HomsetWithBase.__init__(self, R, S, RINGS)
+    def __init__(self, R, S, category = None):
+        if category is None:
+            from sage.categories.rings import Rings
+            category = Rings()
+        HomsetWithBase.__init__(self, R, S, category)
 
     def _repr_(self):
         return "Set of Homomorphisms from %s to %s"%(self.domain(), self.codomain())

sage/rings/integer.pyx

@@ -345 +345 @@
     # overhead can be significant. The difficulty is that then we can't
     # guarantee that the initialization will be performed exactly once.
 
-    def __cinit__(self, x=None, unsigned int base=0):
+    def __cinit__(self, x=None, unsigned int base=0, parent=None):
         mpz_init(self.value)
-        self._parent = <SageObject>the_integer_ring
+        if parent is None:
+            self._parent = <SageObject>the_integer_ring 
+        else:
+            self._parent = <SageObject>parent
         
     def __pyxdoc__init__(self):
         """
@@ -366 +369 @@
             8
         """
         
-    def __init__(self, x=None, unsigned int base=0):
+    def __init__(self, x=None, unsigned int base=0, parent=None):
         """
         EXAMPLES::
         

sage/rings/morphism.pyx

@@ -384 +384 @@
 include "../ext/cdefs.pxi"
 include "../ext/stdsage.pxi"
 
-from sage.categories.all import is_Homset, Sets
 import ideal
 
 import homset
@@ -468 +467 @@
             sage: type(f)
             <type 'sage.rings.morphism.RingMap_lift'>
         """
+        from sage.categories.sets_cat import Sets
         H = R.Hom(S, Sets())
         RingMap.__init__(self, H)
         self.S = S  # for efficiency

sage/rings/number_field/class_group.py

@@ -35 +35 @@
         EXAMPLES::
 
             sage: K.<a> = NumberField(x^2 + 23)
-            sage: K.class_group()
+            sage: G = K.class_group(); G
             Class group of order 3 with structure C3 of Number Field in a with defining polynomial x^2 + 23
+
+            sage: G.category()
+            Category of groups
+            sage: G.check(verbose = True)  # todo: not implemented (test_an_element fails!)
         """
         self.__number_field = number_field
         self.__gens = Sequence([FractionalIdealClass(x, self) for x in gens], immutable=True,

sage/rings/number_field/number_field_rel.py

@@ -532 +532 @@
             sage: K.Hom(K)
             Automorphism group of Number Field in a with defining polynomial x^3 - 2 over its base field
             sage: type(K.Hom(K))
-            <class 'sage.rings.number_field.morphism.RelativeNumberFieldHomset'>
+            <class 'sage.rings.number_field.morphism.RelativeNumberFieldHomset_with_category'>
         """
         import morphism
         return morphism.RelativeNumberFieldHomset(self, codomain)

sage/rings/residue_field.pyx

@@ -102 +102 @@
 from sage.rings.field import Field
 from sage.rings.integer import Integer
 from sage.categories.homset import Hom
-from sage.categories.category_types import Fields, Rings
+from sage.categories.basic import Fields, Rings
 from sage.rings.all import ZZ, QQ, Integers
 from sage.rings.number_field.number_field_ideal import is_NumberFieldIdeal
 import weakref

sage/rings/ring.pyx

@@ -202 +202 @@
         Return the category to which this ring belongs.
 
         EXAMPLES:
-            sage: QQ['x,y'].category()
+            sage: FreeAlgebra(QQ, 3, 'x').category() # todo: put in a real ring, not an algebra!
             Category of rings
+
         """
-        from sage.categories.all import Rings
+        from sage.categories.rings import Rings
         return Rings()
 
     def ideal(self, *x, **kwds):
@@ -326 +327 @@
             return x
         return self._zero_element
 
+    zero = zero_element # transitional
+
     def one_element(self):
         """
         Return the one element of this ring (cached), if it exists.
@@ -348 +351 @@
             return x
         return self._one_element
 
+    one = one_element # Transitional
+
     def is_atomic_repr(self):
         """
         True if the elements have atomic string representations, in the sense
@@ -756 +761 @@
         """
         import sage.modules.all 
         return sage.modules.all.FreeModule(self, n)
+
+    def category(self):
+        """
+        Return the category to which this ring belongs.
+
+        EXAMPLES:
+            sage: QQ['x,y'].category()
+            Category of commutative rings
+        """
+        from sage.categories.commutative_rings import CommutativeRings
+        return CommutativeRings()
     
     def is_commutative(self):
         """
@@ -1326 +1342 @@
             sage: F.category()
             Category of number fields
         """
-        from sage.categories.all import Fields
+        from sage.categories.fields import Fields
         return Fields()
         
     def fraction_field(self):
@@ -2128 +2144 @@
         sage: is_Ring(ZZ)
         True
     """
-    return isinstance(x, Ring)
+    from sage.categories.rings import Rings
+    return isinstance(x, Ring) or x in Rings()
 
 
 from sage.structure.parent_gens import _certify_names

sage/schemes/elliptic_curves/ell_torsion.py

@@ -111 +111 @@
         sage: T = EK.torsion_subgroup(); T
         Torsion Subgroup isomorphic to Multiplicative Abelian Group isomorphic to C5 associated to the Elliptic Curve defined by y^2 + y = x^3 + (-1)*x^2 + (-10)*x + (-20) over Number Field in i with defining polynomial x^2 + 1
         sage: type(T)
-        <class 'sage.schemes.elliptic_curves.ell_torsion.EllipticCurveTorsionSubgroup'>
+        <class 'sage.schemes.elliptic_curves.ell_torsion.EllipticCurveTorsionSubgroup_with_category'>
 
 
     AUTHORS:
@@ -149 +149 @@
             sage: T = EK.torsion_subgroup(); T
             Torsion Subgroup isomorphic to Multiplicative Abelian Group isomorphic to C5 associated to the Elliptic Curve defined by y^2 + y = x^3 + (-1)*x^2 + (-10)*x + (-20) over Number Field in i with defining polynomial x^2 + 1
             sage: type(T)
-            <class 'sage.schemes.elliptic_curves.ell_torsion.EllipticCurveTorsionSubgroup'>
+            <class 'sage.schemes.elliptic_curves.ell_torsion.EllipticCurveTorsionSubgroup_with_category'>
         """
         self.__E = E
         self.__K = E.base_field()

sage/schemes/generic/homset.py

@@ -143 +143 @@
 
 import sage.structure.parent_old as parent_old
 
-from sage.categories.all import HomsetWithBase, Schemes
-from sage.rings.all      import (
-    is_FiniteField, is_RationalField, is_RingHomomorphism, ZZ)
+from sage.categories.homset import HomsetWithBase
+from sage.rings.integer_ring import ZZ
+from sage.rings.ring import is_FiniteField
+from sage.rings.rational_field import is_RationalField
+from sage.rings.morphism import is_RingHomomorphism
 import spec
 
 import morphism
 
-SCH = Schemes()
-
 def is_SchemeHomset(H):
     return isinstance(H, SchemeHomset_generic)
 
-def SchemeHomset(R, S, cat=None, check=True):
+def SchemeHomset(R, S, category=None, check=True):
     if spec.is_Spec(R) and spec.is_Spec(S):
-        return SchemeHomset_spec(R, S, cat=cat, check=check)
+        return SchemeHomset_spec(R, S, category=category, check=check)
     else:
-        return SchemeHomset_generic(R, S, cat=cat, check=check)
+        return SchemeHomset_generic(R, S, category=category, check=check)
 
 class SchemeHomset_generic(parent_old.Parent, HomsetWithBase):
-    def __init__(self, X, Y, cat=None, check=True, base=ZZ):
-        HomsetWithBase.__init__(self, X, Y, cat=cat, check=check, base=base)
+    def __init__(self, X, Y, category=None, check=True, base=ZZ):
+        HomsetWithBase.__init__(self, X, Y, category=category, check=check, base=base)
 
     def has_coerce_map_from_impl(self, S):
         if self == S:   # an obvious case
@@ -320 +320 @@
             raise TypeError, "Unable to enumerate points over %s."%R
 
 class SchemeHomsetModule_abelian_variety_coordinates_field(SchemeHomset_projective_coordinates_field):
-    def __init__(self, X, S, cat=None, check=True):
+    def __init__(self, X, S, category=None, check=True):
         r"""
         EXAMPLES: The bug reported at trac #1785 is fixed::
         
@@ -341 +341 @@
         if R != S:
             X = X.base_extend(S)
         Y = spec.Spec(S, R)
-        HomsetWithBase.__init__(self, Y, X, cat=cat,
+        HomsetWithBase.__init__(self, Y, X, category=category,
                                 check = check,
                                 base = sage.rings.integer_ring.ZZ)
 

sage/schemes/generic/scheme.py

@@ -19 +19 @@
 #*******************************************************************************
 
 from sage.structure.parent_base import ParentWithBase
-from sage.categories.all import Schemes
 from sage.rings.all import (IntegerRing, is_CommutativeRing, is_Field,
                             ZZ, is_RingHomomorphism, GF, PowerSeriesRing,
                             Rationals)
 
-SCH = Schemes()
-
 import homset
 
 import morphism
@@ -354 +351 @@
         try:
             return self._base_morphism
         except AttributeError:
+            from sage.categories.schemes import Schemes
+            SCH = Schemes()
             if hasattr(self, '_base_scheme'):
-                self._base_morphism = self.Hom(self._base_scheme, cat=SCH).natural_map()
+                self._base_morphism = self.Hom(self._base_scheme, category=SCH).natural_map()
             elif hasattr(self, '_base_ring'):
-                self._base_morphism = self.Hom(spec.Spec(self._base_ring), cat=SCH).natural_map()
+                self._base_morphism = self.Hom(spec.Spec(self._base_ring), category=SCH).natural_map()
             else:
-                self._base_morphism = self.Hom(spec.SpecZ, cat=SCH).natural_map()
+                self._base_morphism = self.Hom(spec.SpecZ, category=SCH).natural_map()
             return self._base_morphism
 
     structure_morphism = base_morphism
@@ -374 +373 @@
             sage: ProjectiveSpace(4, QQ).category()
             Category of schemes over Spectrum of Rational Field
         """
+        from sage.categories.schemes import Schemes
         return Schemes(self.base_scheme())
 
     def coordinate_ring(self):
@@ -468 +468 @@
                 raise TypeError, "unable to determine codomain"
         return self.Hom(Y)(x)
 
-    def _Hom_(self, Y, cat=None, check=True):
+    def _Hom_(self, Y, category=None, check=True):
         """
         Return the set of scheme morphisms from self to Y.
         
@@ -479 +479 @@
             sage: S._Hom_(P)
             Set of points of Projective Space of dimension 3 over Integer Ring defined over Integer Ring
         """
-        return homset.SchemeHomset(self, Y, cat=cat, check=check)
+        return homset.SchemeHomset(self, Y, category=category, check=check)
 
     point_set = point_homset
 

sage/schemes/generic/spec.py

@@ -8 +8 @@
 #                  http://www.gnu.org/licenses/
 #*******************************************************************************
 
-from sage.rings.all import is_CommutativeRing, ZZ
+from sage.rings.commutative_ring import is_CommutativeRing
+from sage.rings.integer_ring import ZZ
 import scheme
 import point
 

sage/schemes/hyperelliptic_curves/kummer_surface.py

@@ -12 +12 @@
 from sage.schemes.generic.algebraic_scheme \
      import AlgebraicScheme_subscheme_projective
 from sage.categories.homset import Hom
-from sage.categories.category_types import Schemes
+from sage.categories.all import Schemes
 
 # The generic genus 2 curve in Weierstrass form:
 #

sage/categories/action.pyx

@@ -39 +39 @@
 cdef class Action(Functor):
     
     def __init__(self, G, S, bint is_left = 1, op=None):
-        from category_types import Groupoid
+        from groupoid import Groupoid
         Functor.__init__(self, Groupoid(G), S.category())
         self.G = G
         self.S = S

sage/categories/functor.pyx

@@ -151 +151 @@
         sage: F
         The forgetful functor from Rings to AbelianGroups
     """
-    from category_types import category_hierarchy
     if domain == codomain:
         return IdentityFunctor(domain, codomain)
     if not domain.is_subcategory(codomain):

sage/categories/pushout.py

@@ -1 +1 @@
 from functor import Functor
-from category_types import *
+from basic import *
 
 # TODO, think through the rankings, and override pushout where necessary. 
 
@@ -107 +107 @@
     rank = 9
 
     def __init__(self, var, multi_variate=False):
+        from rings import Rings
         Functor.__init__(self, Rings(), Rings())
         self.var = var
         self.multi_variate = multi_variate

sage/groups/abelian_gps/abelian_group.py

@@ -160 +160 @@
 from abelian_group_element import AbelianGroupElement,is_AbelianGroupElement
 from sage.misc.misc import add, prod
 from sage.misc.mrange import mrange
+#from sage.categories.commutative_groups import CommutativeGroups
 import sage.groups.group as group
 from sage.rings.integer_ring import IntegerRing
 ZZ = IntegerRing()
@@ -399 +400 @@
         [1]
         sage: AbelianGroup(3, [2, 1, 2], names=list('abc')).list()
         [1, b, a, a*b]
+
+        sage: F.category()
+        Category of groups
+
     """
     def __init__(self, n, invfac, names="f"):
         #invfac.sort()
@@ -422 +427 @@
         # *now* define ngens
         self.__ngens = len(self.__invariants)
         self._assign_names(names[:n])
+        from sage.categories.groups import Groups
+        group.Group.__init__(self, category = Groups()) # should be CommutativeGroups()
 
     def __call__(self, x):
         """

sage/groups/group.pyx

@@ -30 +30 @@
     """
     Generic group class
     """
-    def __init__(self):
+    def __init__(self, category = None):
+        """
+
+        TESTS::
+            sage: from sage.groups.group import Group
+            sage: G = Group()
+            sage: G.category()
+            Category of groups
+            sage: G = Group(category = Groups()) # todo: do the same test with some subcategory of Groups when there will exist one
+            sage: G.category()
+            Category of groups
+            sage: G = Group(category = AbelianGroups())
+            Traceback (most recent call last):
+            ...
+            AssertionError: Category of abelian groups is not a subcategory of Category of groups
+            
+        """
+        from sage.categories.basic import Groups
+        if category is None:
+            category = Groups()
+        else:
+            assert category.is_subcategory(Groups()), "%s is not a subcategory of %s"%(category, Groups())
+            
         sage.structure.parent_gens.ParentWithGens.__init__(self,
-                sage.rings.integer_ring.ZZ)
+                sage.rings.integer_ring.ZZ, category = category)
     
     def __call__(self, x):
         """
@@ -50 +72 @@
             return False
         return True
 
-    def category(self):
-        """
-        The category of all groups
-        """
-        import sage.categories.all
-        return sage.categories.all.Groups()
+#    def category(self):
+#        """
+#        The category of all groups
+#        """
+#        import sage.categories.all
+#        return sage.categories.all.Groups()
 
     def is_atomic_repr(self):
         """

sage/groups/matrix_gps/homset.py

@@ -18 +18 @@
 
 from sage.groups.group_homset import GroupHomset_generic
 from sage.categories.homset import HomsetWithBase
-from sage.categories.category_types import Groups
+from sage.categories.all import Groups
 GROUPS = Groups()
 
 import matrix_group_morphism

sage/groups/perm_gps/permgroup.py

@@ -319 +319 @@
             Permutation Group with generators [(2,3,4), (1,2,3)]
             sage: A4.center()
             Permutation Group with generators [()]
+            sage: A4.category()
+            Category of groups
             sage: loads(A4.dumps()) == A4
             True
         """
+        super(PermutationGroup_generic, self).__init__()
         if (gens is None and gap_group is None):
             raise ValueError, "you must specify gens or gap_group"
 

sage/groups/perm_gps/permgroup_named.py

@@ -76 +76 @@
 import sage.structure.coerce as coerce
 from sage.rings.finite_field import FiniteField as GF
 from sage.rings.arith import factor
+from sage.groups.group import FiniteGroup
 from sage.groups.abelian_gps.abelian_group import AbelianGroup
 from sage.misc.functional import is_even, log
 from sage.groups.perm_gps.permgroup import PermutationGroup, PermutationGroup_generic
@@ -181 +182 @@
             Symmetric group of order 4! as a permutation group
             sage: G.set()
             [1, 2, 3, 4]
+
+            sage: G.category()
+            Category of groups
         """
         self._set = self._get_set(n)
         self._deg = max(self._set)
@@ -194 +198 @@
             if n > 2:
                 gens.append( tuple(self._set[:2]) )
 
-        #Note that we don't call the superclass initializer in order to
+        #Note that we skip the call to the superclass initializer in order to
         #avoid infinite recursion since SymmetricGroup is called by
         #PermutationGroupElement
+        FiniteGroup.__init__(self)
+
         gens = [PermutationGroupElement(g, self, check=False) for g in gens]
         self._gap_string = '%s(%s)'%(self._gap_name, n)
         self._gens = gens
@@ -250 +256 @@
             Alternating group of order 4!/2 as a permutation group
             sage: G.set()
             [1, 2, 4, 5]
+            sage: G.category()
+            Category of groups
         """
         self._set = self._get_set(n)
         self._deg = max(self._set)
@@ -289 +297 @@
             8
             sage: G
             Cyclic group of order 8 as a permutation group
+            sage: G.category()
+            Category of groups
             sage: loads(G.dumps()) == G
             True
             sage: C = CyclicPermutationGroup(10)
@@ -297 +307 @@
             sage: C = CyclicPermutationGroup(10)
             sage: C.as_AbelianGroup()
             Multiplicative Abelian Group isomorphic to C2 x C5
-
         """
         n = Integer(n)
         if n < 1:
@@ -367 +376 @@
             [(), (3,4), (1,2), (1,2)(3,4)]        
 
         TESTS:
+            sage: G.category()
+            Category of groups
             sage: G == loads(dumps(G))
             True
      
@@ -429 +440 @@
             ValueError: n must be positive
 
         TESTS:
+            sage: G.category()
+            Category of groups
             sage: G == loads(dumps(G))
             True
         """        
@@ -479 +492 @@
             Mathieu group of degree 12 and order 95040 as a permutation group
 
         TESTS:
+            sage: G.category()
+            Category of groups
             sage: G == loads(dumps(G))
             True
         """        
@@ -517 +532 @@
             sage: G.gens()                             # requires optional database_gap 
             [(1,2,3,4,5), (1,4)(2,3)]
             
+            sage: G.category()
+            Category of groups
             sage: loads(G.dumps()) == G                # requires optional database_gap 
             True
         """
@@ -588 +605 @@
             Permutation Group with generators [(3,10,9,8,4,7,6,5), (1,2,4)(5,6,8)(7,9,10)]
             sage: G.base_ring()
             Finite Field in b of size 3^2           
+
+            sage: G.category()
+            Category of groups
         """
         from sage.groups.perm_gps.permgroup import PermutationGroup, PermutationGroup_generic
         id = 'Group([()])' if n == 1 else 'PGL(%s,%s)'%(n,q)
@@ -639 +659 @@
             sage: G.base_ring()
             Finite Field in a of size 2^3
             
+            sage: G.category()
+            Category of groups
         """
         if n == 1:
             id = 'Group([()])'

sage/matrix/matrix_space.py

@@ -85 +85 @@
 import sage.modules.free_module
 from sage.structure.sequence import Sequence
 
+from sage.categories.rings import Rings
+
 def is_MatrixSpace(x):
     """
     Returns True if self is an instance of MatrixSpace returns false if
@@ -183 +185 @@
         sage: loads(M.dumps()) == M
         True
     """
-    if not sage.rings.ring.is_Ring(base_ring):
+    if not base_ring in Rings():
         raise TypeError, "base_ring (=%s) must be a ring"%base_ring
     
     if ncols is None: ncols = nrows
@@ -208 +210 @@
     
         sage: MatrixSpace(ZZ,10,5)
         Full MatrixSpace of 10 by 5 dense matrices over Integer Ring
+        sage: MatrixSpace(ZZ,10,5).category()
+        Category of modules over Integer Ring
+
         sage: MatrixSpace(ZZ,10,2^31)
         Traceback (most recent call last):                                   # 32-bit
         ...                                                                  # 32-bit
         ValueError: number of rows and columns must be less than 2^31 (on a 32-bit computer -- use a 64-bit computer for matrices with up to 2^63-1 rows and columns)           # 32-bit
         Full MatrixSpace of 10 by 2147483648 dense matrices over Integer Ring   # 64-bit
     """
+
     def __init__(self,  base_ring,             
                         nrows, 
                         ncols=None, 
                         sparse=False):
-        parent_gens.ParentWithGens.__init__(self, base_ring)
-        if not isinstance(base_ring, ring.Ring):
+
+        from sage.categories.all import Modules
+        parent_gens.ParentWithGens.__init__(self, base_ring) # category = Modules(base_ring)
+        # Temporary until the inheritance glitches are fixed
+        sage.structure.category_object.CategoryObject.__init_category__(self, Modules(base_ring))
+
+        if not base_ring in Rings():
             raise TypeError, "base_ring must be a ring"
         if ncols == None: ncols = nrows
         nrows = int(nrows)
@@ -552 +563 @@
         return "\\mathrm{Mat}_{%s\\times %s}(%s)"%(self.nrows(), self.ncols(),
                                                       latex.latex(self.base_ring()))
 
+    # This should eventually be inherited from the EnumeratedSets() category
+    def list(self): return self._list_from_iterator_cached()
+
     def __iter__(self):
         r"""
         Returns a generator object which iterates through the elements of

sage/modular/abvar/homspace.py

@@ -216 +216 @@
             sage: Hom(J0(11), J0(11))
             Endomorphism ring of Abelian variety J0(11) of dimension 1
             sage: type(H)
-            <class 'sage.modular.abvar.homspace.Homspace'>
+            <class 'sage.modular.abvar.homspace.Homspace_with_category'>
             sage: H.homset_category()
             Category of modular abelian varieties over Rational Field
         """
@@ -698 +698 @@
             sage: sage.modular.abvar.homspace.EndomorphismSubring(J0(25))
             Endomorphism ring of Abelian variety J0(25) of dimension 0
             sage: type(J0(11).endomorphism_ring())
-            <class 'sage.modular.abvar.homspace.EndomorphismSubring'>
+            <class 'sage.modular.abvar.homspace.EndomorphismSubring_with_category'>
         """
         self._J = A.ambient_variety()
         self._A = A

sage/modular/hecke/degenmap.py

@@ -60 +60 @@
     """
     def __init__(self, matrix, domain, codomain, t):
         self.__t = t
-        H = homspace.HeckeModuleHomspace(domain, codomain)
+        H = domain.Hom(codomain)
         if t == 1:
             pow = ""
         else:

sage/modular/hecke/hecke_operator.py

@@ -22 +22 @@
 import operator
 
 import sage.algebras.algebra_element
-import sage.categories.all as cat
+from sage.categories.homset import End
 import sage.misc.latex as latex
 import sage.misc.misc as misc
 import sage.modules.module
@@ -74 +74 @@
         except AttributeError:
             T = self.matrix()
             M = self.domain()
-            H = cat.End(M)
+            H = End(M)
             if isinstance(self, HeckeOperator):
                 name = "T_%s"%self.index()
             else:

sage/modular/hecke/homspace.py

@@ -25 +25 @@
     return isinstance(x, HeckeModuleHomspace)
 
 class HeckeModuleHomspace(sage.categories.homset.HomsetWithBase):
-    def __init__(self, X, Y):
+    def __init__(self, X, Y, category = None):
         if not module.is_HeckeModule(X) or not module.is_HeckeModule(Y):
             raise TypeError, "X and Y must be Hecke modules"
         if X.base_ring() != Y.base_ring():
             raise TypeError, "X and Y must have the same base ring"
-        sage.categories.homset.HomsetWithBase.__init__(self, X, Y, X.category())
+        if category is None:
+            category = X.category()
+        sage.categories.homset.HomsetWithBase.__init__(self, X, Y, category)
 
     def __call__(self, A, name=''):
         try:

sage/modular/hecke/module.py

@@ -1131 +1131 @@
             i = (A.decomposition()).index(self)
             n = sum([A[j].rank() for j in range(i)])
             C = B.matrix_from_columns(range(n,n+self.rank()))
-            H = homspace.HeckeModuleHomspace(A, self)
+            H = A.Hom(self)
             pi = H(C, "Projection"%self)
             self.__projection = pi
             return self.__projection

sage/modular/hecke/morphism.py

@@ -25 +25 @@
 
 
 import sage.misc.misc as misc
-import sage.categories.all as cat
 from sage.modules.matrix_morphism import MatrixMorphism
+from sage.categories.morphism import Morphism
 
 # We also define other types of Hecke-module morphisms that aren't
 # specified by a matrix.  E.g., Hecke operators, or maybe morphisms on
@@ -39 +39 @@
 def is_HeckeModuleMorphism_matrix(x):
     return isinstance(x, HeckeModuleMorphism_matrix)
 
-class HeckeModuleMorphism(cat.Morphism):
+class HeckeModuleMorphism(Morphism):
     pass
 
 class HeckeModuleMorphism_matrix(MatrixMorphism, HeckeModuleMorphism):

sage/modular/modsym/ambient.py

@@ -715 +715 @@
         """
         
         MS = matrix_space.MatrixSpace(self.base_ring(), self.dimension(), M.dimension())
-        hom = hecke.HeckeModuleHomspace(self, M)
+        hom = self.Hom(M)
         if self.dimension() == 0 or M.dimension() == 0:
             A = MS(0)
             phi = hom(A, "Heilbronn operator(%s,%s)"%(H,t))