passagemath-objects 10.6.46__cp314-cp314t-macosx_13_0_x86_64.whl

sage/categories/homsets.py

@@ -0,0 +1,364 @@
+# sage_setup: distribution = sagemath-objects
+r"""
+Homset categories
+"""
+# ****************************************************************************
+#  Copyright (C) 2014 Nicolas M. Thiery <nthiery at users.sf.net>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#                  https://www.gnu.org/licenses/
+# *****************************************************************************
+
+from sage.misc.cachefunc import cached_method
+from sage.categories.category import Category, JoinCategory, CategoryWithParameters
+from sage.categories.category_singleton import Category_singleton
+from sage.categories.category_with_axiom import CategoryWithAxiom
+from sage.categories.covariant_functorial_construction import FunctorialConstructionCategory
+
+
+class HomsetsCategory(FunctorialConstructionCategory, CategoryWithParameters):
+
+    _functor_category = "Homsets"
+
+    @classmethod
+    def default_super_categories(cls, category):
+        """
+        Return the default super categories of ``category.Homsets()``.
+
+        INPUT:
+
+        - ``cls`` -- the category class for the functor `F`
+        - ``category`` -- a category `Cat`
+
+        OUTPUT: a category
+
+        As for the other functorial constructions, if ``category``
+        implements a nested ``Homsets`` class, this method is used in
+        combination with ``category.Homsets().extra_super_categories()``
+        to compute the super categories of ``category.Homsets()``.
+
+        EXAMPLES:
+
+        If ``category`` has one or more full super categories, then
+        the join of their respective homsets category is returned. In
+        this example, this join consists of a single category::
+
+            sage: from sage.categories.homsets import HomsetsCategory
+            sage: from sage.categories.additive_groups import AdditiveGroups
+
+            sage: C = AdditiveGroups()
+            sage: C.full_super_categories()
+            [Category of additive inverse additive unital additive magmas,
+             Category of additive monoids]
+            sage: H = HomsetsCategory.default_super_categories(C); H
+            Category of homsets of additive monoids
+            sage: type(H)
+            <class 'sage.categories.additive_monoids.AdditiveMonoids.Homsets_with_category'>
+
+        and, given that nothing specific is currently implemented for
+        homsets of additive groups, ``H`` is directly the category
+        thereof::
+
+            sage: C.Homsets()
+            Category of homsets of additive monoids
+
+        Similarly for rings: a ring homset is just a homset of unital
+        magmas and additive magmas::
+
+            sage: Rings().Homsets()
+            Category of homsets of unital magmas and additive unital additive magmas
+
+        Otherwise, if ``category`` implements a nested class
+        ``Homsets``, this method returns the category of all homsets::
+
+            sage: AdditiveMagmas.Homsets
+            <class 'sage.categories.additive_magmas.AdditiveMagmas.Homsets'>
+            sage: HomsetsCategory.default_super_categories(AdditiveMagmas())
+            Category of homsets
+
+        which gives one of the super categories of
+        ``category.Homsets()``::
+
+            sage: AdditiveMagmas().Homsets().super_categories()
+            [Category of additive magmas, Category of homsets]
+            sage: AdditiveMagmas().AdditiveUnital().Homsets().super_categories()
+            [Category of additive unital additive magmas, Category of homsets]
+
+        the other coming from ``category.Homsets().extra_super_categories()``::
+
+            sage: AdditiveMagmas().Homsets().extra_super_categories()
+            [Category of additive magmas]
+
+        Finally, as a last resort, this method returns a stub category
+        modelling the homsets of this category::
+
+            sage: hasattr(Posets, "Homsets")
+            False
+            sage: H = HomsetsCategory.default_super_categories(Posets()); H
+            Category of homsets of posets
+            sage: type(H)
+            <class 'sage.categories.homsets.HomsetsOf_with_category'>
+            sage: Posets().Homsets()
+            Category of homsets of posets
+
+        TESTS::
+
+            sage: Objects().Homsets().super_categories()
+            [Category of homsets]
+            sage: Sets().Homsets().super_categories()
+            [Category of homsets]
+            sage: (Magmas() & Posets()).Homsets().super_categories()
+            [Category of homsets]
+        """
+        if category.full_super_categories():
+            return Category.join([getattr(cat, cls._functor_category)()
+                                  for cat in category.full_super_categories()])
+        else:
+            functor_category = getattr(category.__class__, cls._functor_category)
+            if isinstance(functor_category, type) and issubclass(functor_category, Category):
+                return Homsets()
+            else:
+                return HomsetsOf(Category.join(category.structure()))
+
+    def _test_homsets_category(self, **options):
+        r"""
+        Run generic tests on this homsets category.
+
+        .. SEEALSO:: :class:`TestSuite`.
+
+        EXAMPLES::
+
+            sage: Sets().Homsets()._test_homsets_category()
+        """
+        # TODO: remove if unneeded
+        #from sage.categories.objects    import Objects
+        #from sage.categories.sets_cat import Sets
+        tester = self._tester(**options)
+        tester.assertTrue(self.is_subcategory(Category.join(self.base_category().structure()).Homsets()))
+        tester.assertTrue(self.is_subcategory(Homsets()))
+
+    @cached_method
+    def base(self):
+        """
+        If this homsets category is subcategory of a category with a base, return that base.
+
+        .. TODO:: Is this really useful?
+
+        EXAMPLES::
+
+            sage: ModulesWithBasis(ZZ).Homsets().base()
+            Integer Ring
+        """
+        from sage.categories.category_types import Category_over_base
+        for C in self._all_super_categories_proper:
+            if isinstance(C,Category_over_base):
+                return C.base()
+        raise AttributeError("This hom category has no base")
+
+    def _make_named_class_key(self, name):
+        r"""
+        Return what the element/parent/... classes depend on.
+
+        .. SEEALSO::
+
+            - :meth:`CategoryWithParameters`
+            - :meth:`CategoryWithParameters._make_named_class_key`
+
+        TESTS::
+
+            sage: ModulesWithBasis(ZZ).Homsets()._make_named_class_key('parent_class')
+            <class 'sage.categories.modules_with_basis.ModulesWithBasis.parent_class'>
+        """
+        return getattr(self.base_category(), name)
+
+
+class HomsetsOf(HomsetsCategory):
+    """
+    Default class for homsets of a category.
+
+    This is used when a category `C` defines some additional structure
+    but not a homset category of its own. Indeed, unlike for covariant
+    functorial constructions, we cannot represent the homset category
+    of `C` by just the join of the homset categories of its super
+    categories.
+
+    EXAMPLES::
+
+        sage: C = (Magmas() & Posets()).Homsets(); C
+        Category of homsets of magmas and posets
+        sage: type(C)
+        <class 'sage.categories.homsets.HomsetsOf_with_category'>
+
+    TESTS::
+
+        sage: TestSuite(C).run()
+        sage: C = Rings().Homsets()
+        sage: TestSuite(C).run(skip=['_test_category_graph'])
+        sage: TestSuite(C).run()
+    """
+    _base_category_class = (Category,)
+
+    def _repr_object_names(self):
+        """
+        EXAMPLES::
+
+            sage: Semigroups().Homsets()
+            Category of homsets of magmas
+            sage: (Magmas() & AdditiveMagmas() & Posets()).Homsets()
+            Category of homsets of magmas and additive magmas and posets
+            sage: Rings().Homsets()
+            Category of homsets of unital magmas and additive unital additive magmas
+        """
+        base_category = self.base_category()
+        try:
+            object_names = base_category._repr_object_names()
+        except ValueError:
+            assert isinstance(base_category, JoinCategory)
+            object_names = ' and '.join(cat._repr_object_names() for cat in base_category.super_categories())
+        return "homsets of %s" % (object_names)
+
+    def super_categories(self):
+        r"""
+        Return the super categories of ``self``.
+
+        A stub homset category admits a single super category, namely
+        the category of all homsets.
+
+        EXAMPLES::
+
+            sage: C = (Magmas() & Posets()).Homsets(); C
+            Category of homsets of magmas and posets
+            sage: type(C)
+            <class 'sage.categories.homsets.HomsetsOf_with_category'>
+            sage: C.super_categories()
+            [Category of homsets]
+        """
+        return [Homsets()]
+
+
+class Homsets(Category_singleton):
+    """
+    The category of all homsets.
+
+    EXAMPLES::
+
+        sage: from sage.categories.homsets import Homsets
+        sage: Homsets()
+        Category of homsets
+
+    This is a subcategory of ``Sets()``::
+
+        sage: Homsets().super_categories()
+        [Category of sets]
+
+    By this, we assume that all homsets implemented in Sage are sets,
+    or equivalently that we only implement locally small categories.
+    See :wikipedia:`Category_(mathematics)`.
+
+    :issue:`17364`: every homset category shall be a subcategory of the
+    category of all homsets::
+
+        sage: Schemes().Homsets().is_subcategory(Homsets())
+        True
+        sage: AdditiveMagmas().Homsets().is_subcategory(Homsets())
+        True
+        sage: AdditiveMagmas().AdditiveUnital().Homsets().is_subcategory(Homsets())
+        True
+
+    This is tested in :meth:`HomsetsCategory._test_homsets_category`.
+    """
+    def super_categories(self):
+        """
+        Return the super categories of ``self``.
+
+        EXAMPLES::
+
+            sage: from sage.categories.homsets import Homsets
+            sage: Homsets()
+            Category of homsets
+        """
+        from .sets_cat import Sets
+        return [Sets()]
+
+    class SubcategoryMethods:
+
+        def Endset(self):
+            """
+            Return the subcategory of the homsets of ``self`` that are endomorphism sets.
+
+            EXAMPLES::
+
+                sage: Sets().Homsets().Endset()
+                Category of endsets of sets
+
+                sage: Posets().Homsets().Endset()
+                Category of endsets of posets
+            """
+            return self._with_axiom("Endset")
+
+    class Endset(CategoryWithAxiom):
+        """
+        The category of all endomorphism sets.
+
+        This category serves too purposes: making sure that the
+        ``Endset`` axiom is implemented in the category where it's
+        defined, namely ``Homsets``, and specifying that ``Endsets``
+        are monoids.
+
+        EXAMPLES::
+
+            sage: from sage.categories.homsets import Homsets
+            sage: Homsets().Endset()
+            Category of endsets
+        """
+        def extra_super_categories(self):
+            """
+            Implement the fact that endsets are monoids.
+
+            .. SEEALSO:: :meth:`CategoryWithAxiom.extra_super_categories`
+
+            EXAMPLES::
+
+                sage: from sage.categories.homsets import Homsets
+                sage: Homsets().Endset().extra_super_categories()
+                [Category of monoids]
+            """
+            from .monoids import Monoids
+            return [Monoids()]
+
+        class ParentMethods:
+            def is_endomorphism_set(self):
+                """
+                Return ``True`` as ``self`` is in the category
+                of ``Endsets``.
+
+                EXAMPLES::
+
+                    sage: P.<t> = ZZ[]
+                    sage: E = End(P)
+                    sage: E.is_endomorphism_set()
+                    True
+                """
+                return True
+
+    class ParentMethods:
+        def is_endomorphism_set(self):
+            """
+            Return ``True`` if the domain and codomain of ``self`` are the same
+            object.
+
+            EXAMPLES::
+
+                sage: P.<t> = ZZ[]
+                sage: f = P.hom([1/2*t])
+                sage: f.parent().is_endomorphism_set()
+                False
+                sage: g = P.hom([2*t])
+                sage: g.parent().is_endomorphism_set()
+                True
+            """
+            sD = self.domain()
+            sC = self.codomain()
+            if sC is None or sD is None:
+                raise RuntimeError("Domain or codomain of this homset have been deallocated")
+            return sD is sC

sage/categories/isomorphic_objects.py

@@ -0,0 +1,73 @@
+# sage_setup: distribution = sagemath-objects
+"""
+Isomorphic Objects Functorial Construction
+
+AUTHORS:
+
+ - Nicolas M. Thiery (2010): initial revision
+"""
+#*****************************************************************************
+#  Copyright (C) 2009 Nicolas M. Thiery <nthiery at users.sf.net>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#                  http://www.gnu.org/licenses/
+#*****************************************************************************
+
+from sage.categories.category import Category
+from sage.categories.covariant_functorial_construction import RegressiveCovariantConstructionCategory
+
+
+class IsomorphicObjectsCategory(RegressiveCovariantConstructionCategory):
+
+    _functor_category = "IsomorphicObjects"
+
+    @classmethod
+    def default_super_categories(cls, category):
+        """
+        Return the default super categories of ``category.IsomorphicObjects()``.
+
+        Mathematical meaning: if `A` is the image of `B` by an
+        isomorphism in the category `C`, then `A` is both a subobject
+        of `B` and a quotient of `B` in the category `C`.
+
+        INPUT:
+
+        - ``cls`` -- the class ``IsomorphicObjectsCategory``
+        - ``category`` -- a category `Cat`
+
+        OUTPUT: a (join) category
+
+        In practice, this returns ``category.Subobjects()`` and
+        ``category.Quotients()``, joined together with the result of the method
+        :meth:`RegressiveCovariantConstructionCategory.default_super_categories() <sage.categories.covariant_functorial_construction.RegressiveCovariantConstructionCategory.default_super_categories>`
+        (that is the join of ``category`` and
+        ``cat.IsomorphicObjects()`` for each ``cat`` in the super
+        categories of ``category``).
+
+        EXAMPLES:
+
+        Consider ``category=Groups()``, which has ``cat=Monoids()`` as
+        super category. Then, the image of a group `G'` by a group
+        isomorphism is simultaneously a subgroup of `G`, a subquotient
+        of `G`, a group by itself, and the image of `G` by a monoid
+        isomorphism::
+
+            sage: Groups().IsomorphicObjects().super_categories()
+            [Category of groups,
+             Category of subquotients of monoids,
+             Category of quotients of semigroups,
+             Category of isomorphic objects of sets]
+
+        Mind the last item above: there is indeed currently nothing
+        implemented about isomorphic objects of monoids.
+
+        This resulted from the following call::
+
+            sage: sage.categories.isomorphic_objects.IsomorphicObjectsCategory.default_super_categories(Groups())
+            Join of Category of groups and
+            Category of subquotients of monoids and
+            Category of quotients of semigroups and
+            Category of isomorphic objects of sets
+        """
+        return Category.join([category.Subobjects(), category.Quotients(),
+                              super().default_super_categories(category)])

sage/categories/map.pxd

@@ -0,0 +1,34 @@
+# sage_setup: distribution = sagemath-objects
+from sage.structure.parent cimport Parent
+from sage.structure.element cimport Element
+
+cdef class Map(Element):
+    cdef object __weakref__
+
+    cdef public int _coerce_cost
+    # a rough measure of the cost of using this morphism in the coercion system.
+    # 10 by default, 100 if a DefaultCoercionMorphism, 10000 if inexact.
+
+    cdef _update_slots(self, dict)
+    cdef dict _extra_slots(self)
+
+    # these methods require x is an element of domain, and returns an element with parent codomain
+    cpdef Element _call_(self, x)
+    cpdef Element _call_with_args(self, x, args=*, kwds=*)
+
+    cdef public domain     # will be either a weakref or a constant map
+    cdef public codomain   # will be a constant map
+    cdef Parent _codomain  # for accessing the codomain directly
+    cdef object _category_for  # category in which this is a morphism
+
+    cdef public _repr_type_str
+    cdef public bint _is_coercion
+
+    cpdef _pow_int(self, n)
+
+
+cdef class Section(Map):
+    cdef Map _inverse
+
+cdef class FormalCompositeMap(Map):
+    cdef __list