passagemath-categories 10.6.32__cp314-cp314t-musllinux_1_2_aarch64.whl

sage/categories/bimodules.py

@@ -0,0 +1,206 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Bimodules
+"""
+#*****************************************************************************
+#  Copyright (C) 2005      David Kohel <kohel@maths.usyd.edu>
+#                          William Stein <wstein@math.ucsd.edu>
+#                2008      Teresa Gomez-Diaz (CNRS) <Teresa.Gomez-Diaz@univ-mlv.fr>
+#                2008-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, CategoryWithParameters
+from sage.categories.left_modules import LeftModules
+from sage.categories.right_modules import RightModules
+
+from sage.categories.rings import Rings
+_Rings = Rings()
+
+#?class Bimodules(Category_over_base_rng, Category_over_base_rng):
+
+
+class Bimodules(CategoryWithParameters):
+    """
+    The category of `(R,S)`-bimodules.
+
+    For `R` and `S` rings, a `(R,S)`-bimodule `X` is a left `R`-module
+    and right `S`-module such that the left and right actions commute:
+    `r*(x*s) = (r*x)*s`.
+
+    EXAMPLES::
+
+        sage: Bimodules(QQ, ZZ)
+        Category of bimodules over Rational Field on the left and Integer Ring on the right
+        sage: Bimodules(QQ, ZZ).super_categories()
+        [Category of left modules over Rational Field, Category of right modules over Integer Ring]
+    """
+
+    def __init__(self, left_base, right_base, name=None):
+        """
+        The ``name`` parameter is ignored.
+
+        EXAMPLES::
+
+            sage: C = Bimodules(QQ, ZZ)
+            sage: TestSuite(C).run()
+        """
+        if not (left_base in Rings() or
+                (isinstance(left_base, Category)
+                 and left_base.is_subcategory(Rings()))):
+            raise ValueError("the left base must be a ring or a subcategory of Rings()")
+        if not (right_base in Rings() or
+                (isinstance(right_base, Category)
+                 and right_base.is_subcategory(Rings()))):
+            raise ValueError("the right base must be a ring or a subcategory of Rings()")
+        self._left_base_ring = left_base
+        self._right_base_ring = right_base
+        Category.__init__(self)
+
+    def _make_named_class_key(self, name):
+        r"""
+        Return what the element/parent/... classes depend on.
+
+        Since :issue:`11935`, the element and parent classes of a
+        bimodule only depend on the categories of the left and right
+        base ring.
+
+        .. SEEALSO::
+
+            - :meth:`CategoryWithParameters`
+            - :meth:`CategoryWithParameters._make_named_class_key`
+
+        EXAMPLES::
+
+            sage: Bimodules(QQ,ZZ)._make_named_class_key('parent_class')
+            (Join of Category of number fields
+                 and Category of quotient fields
+                 and Category of metric spaces,
+             Join of Category of Dedekind domains
+                 and Category of euclidean domains
+                 and Category of noetherian rings
+                 and Category of infinite enumerated sets
+                 and Category of metric spaces)
+
+
+            sage: Bimodules(Fields(), ZZ)._make_named_class_key('element_class')
+            (Category of fields,
+             Join of Category of Dedekind domains
+             and Category of euclidean domains
+             and Category of noetherian rings
+             and Category of infinite enumerated sets
+             and Category of metric spaces)
+
+            sage: Bimodules(QQ, Rings())._make_named_class_key('element_class')
+            (Join of Category of number fields
+                 and Category of quotient fields
+                 and Category of metric spaces,
+             Category of rings)
+
+            sage: Bimodules(Fields(), Rings())._make_named_class_key('element_class')
+            (Category of fields, Category of rings)
+        """
+        return (self._left_base_ring if isinstance(self._left_base_ring, Category) else self._left_base_ring.category(),
+                self._right_base_ring if isinstance(self._right_base_ring, Category) else self._right_base_ring.category())
+
+    @classmethod
+    def an_instance(cls):
+        """
+        Return an instance of this class.
+
+        EXAMPLES::
+
+            sage: Bimodules.an_instance()                                               # needs sage.rings.real_mpfr
+            Category of bimodules over Rational Field on the left and Real Field with 53 bits of precision on the right
+        """
+        from sage.rings.rational_field import QQ
+        try:
+            from sage.rings.real_mpfr import RR
+        except ImportError:
+            from sage.rings.real_double import RDF as RR
+        return cls(QQ, RR)
+
+    def _repr_object_names(self):
+        """
+        EXAMPLES::
+
+            sage: Bimodules(QQ, ZZ) # indirect doctest
+            Category of bimodules over Rational Field on the left and Integer Ring on the right
+        """
+        return "bimodules over %s on the left and %s on the right" \
+            % (self._left_base_ring, self._right_base_ring)
+
+    def left_base_ring(self):
+        """
+        Return the left base ring over which elements of this category are
+        defined.
+
+        EXAMPLES::
+
+            sage: Bimodules(QQ, ZZ).left_base_ring()
+            Rational Field
+        """
+        return self._left_base_ring
+
+    def right_base_ring(self):
+        """
+        Return the right base ring over which elements of this category are
+        defined.
+
+        EXAMPLES::
+
+            sage: Bimodules(QQ, ZZ).right_base_ring()
+            Integer Ring
+        """
+        return self._right_base_ring
+
+    def _latex_(self) -> str:
+        r"""
+        Return a latex representation of ``self``.
+
+        EXAMPLES::
+
+            sage: print(Bimodules(QQ, ZZ)._latex_())
+            {\mathbf{Bimodules}}_{\Bold{Q}, \Bold{Z}}
+        """
+        from sage.misc.latex import latex
+        return "{{{}}}_{{{}, {}}}".format(Category._latex_(self),
+                                          latex(self._left_base_ring),
+                                          latex(self._right_base_ring))
+
+    def super_categories(self):
+        """
+        EXAMPLES::
+
+            sage: Bimodules(QQ, ZZ).super_categories()
+            [Category of left modules over Rational Field, Category of right modules over Integer Ring]
+        """
+        R = self.left_base_ring()
+        S = self.right_base_ring()
+        return [LeftModules(R), RightModules(S)]
+
+    def additional_structure(self):
+        r"""
+        Return ``None``.
+
+        Indeed, the category of bimodules defines no additional
+        structure: a left and right module morphism between two
+        bimodules is a bimodule morphism.
+
+        .. SEEALSO:: :meth:`Category.additional_structure`
+
+        .. TODO:: Should this category be a :class:`CategoryWithAxiom`?
+
+        EXAMPLES::
+
+            sage: Bimodules(QQ, ZZ).additional_structure()
+        """
+        return None
+
+    class ParentMethods:
+        pass
+
+    class ElementMethods:
+        pass

sage/categories/chain_complexes.py

@@ -0,0 +1,268 @@
+# sage_setup: distribution = sagemath-categories
+"""
+Category of chain complexes
+"""
+
+#*****************************************************************************
+#  Copyright (C) 2007 Robert Bradshaw
+#                2009 Mike Hansen
+#                2013 Volker Braun
+#                2013, 2015 Travis Scrimshaw
+#                2021 Michael Jung
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#                  http://www.gnu.org/licenses/
+#*****************************************************************************
+
+from sage.categories.category_types import Category_module
+from sage.categories.commutative_additive_groups import CommutativeAdditiveGroups
+from sage.categories.functor import Functor
+from sage.misc.abstract_method import abstract_method
+
+
+#############################################################
+# ChainComplex
+#############################################################
+class ChainComplexes(Category_module):
+    """
+    The category of all chain complexes over a base ring.
+
+    EXAMPLES::
+
+        sage: ChainComplexes(RationalField())
+        Category of chain complexes over Rational Field
+        sage: ChainComplexes(Integers(9))
+        Category of chain complexes over Ring of integers modulo 9
+
+     TESTS::
+
+        sage: TestSuite(ChainComplexes(RationalField())).run()
+    """
+
+    def super_categories(self):
+        """
+        EXAMPLES::
+
+            sage: ChainComplexes(Integers(9)).super_categories()
+            [Category of modules over Ring of integers modulo 9]
+        """
+        from sage.categories.fields import Fields
+        from sage.categories.modules import Modules
+        from sage.categories.vector_spaces import VectorSpaces
+        base_ring = self.base_ring()
+        if base_ring in Fields():
+            return [VectorSpaces(base_ring)]
+        return [Modules(base_ring)]
+
+    class ParentMethods:
+        @abstract_method
+        def homology(self, n=None):
+            r"""
+            Return the homology of the chain complex.
+
+            INPUT:
+
+            - ``n`` -- (default: ``None``) degree of the homology; if none is
+              provided, the direct sum homology will be used
+
+            EXAMPLES::
+
+                sage: # needs sage.libs.pari sage.modules
+                sage: C = ChainComplex({0: matrix(ZZ, 2, 3, [3, 0, 0, 0, 0, 0])})
+                sage: C.homology(0)
+                Z x Z
+                sage: C.homology(1)
+                Z x C3
+                sage: C.homology(2)
+                0
+
+            ::
+
+                sage: # needs sage.combinat sage.libs.singular sage.modules
+                sage: A.<x,y,z> = GradedCommutativeAlgebra(QQ, degrees=(2, 2, 3))
+                sage: C = A.cdg_algebra({z: x*y})
+                sage: C.homology(0)
+                Free module generated by {[1]} over Rational Field
+                sage: C.homology(1)
+                Free module generated by {} over Rational Field
+                sage: C.homology(2)
+                Free module generated by {[x], [y]} over Rational Field
+                sage: C.homology(3)
+                Free module generated by {} over Rational Field
+                sage: C.homology(4)
+                Free module generated by {[x^2], [y^2]} over Rational Field
+            """
+
+        @abstract_method
+        def differential(self, *args, **kwargs):
+            r"""
+            Return the differentials (or boundary maps) of the chain complex.
+
+            EXAMPLES::
+
+                sage: C = ChainComplex({0: matrix(ZZ, 2, 3, [3, 0, 0, 0, 0, 0])})       # needs sage.modules
+                sage: C.differential(0)                                                 # needs sage.modules
+                [3 0 0]
+                [0 0 0]
+
+            ::
+
+                sage: A.<x,y,z> = GradedCommutativeAlgebra(QQ, degrees=(2, 2, 3))       # needs sage.combinat sage.libs.singular sage.modules
+                sage: C = A.cdg_algebra({z: x*y})                                       # needs sage.combinat sage.libs.singular sage.modules
+                sage: C.differential()                                                  # needs sage.combinat sage.libs.singular sage.modules
+                Differential of Commutative Differential Graded Algebra with
+                 generators ('x', 'y', 'z') in degrees (2, 2, 3) over Rational Field
+                  Defn: x --> 0
+                        y --> 0
+                        z --> x*y
+            """
+
+        @abstract_method(optional=True)
+        def lift_from_homology(self, x):
+            r"""
+            Lift the homology element ``x`` to the corresponding module.
+
+            EXAMPLES::
+
+                sage: # needs sage.symbolic
+                sage: E3 = EuclideanSpace(3)
+                sage: C = E3.de_rham_complex()
+                sage: one = C.homology().one()
+                sage: C.lift_from_homology(one)
+                Mixed differential form one on the Euclidean space E^3
+            """
+
+        def reduce_to_homology(self, x, n=None):
+            r"""
+            Reduce a cycle to the corresponding quotient in homology.
+
+            INPUT:
+
+            - ``x`` -- a cycle
+            - ``n`` -- (default: ``None``) degree of the homology; if none is
+              provided, the direct sum homology will be used
+
+            EXAMPLES::
+
+                sage: # needs sage.symbolic
+                sage: E3 = EuclideanSpace(3)
+                sage: C = E3.de_rham_complex()
+                sage: one = C.one()
+                sage: C.reduce_to_homology(one)
+                [one]
+            """
+            try:
+                # try coercion
+                return self.homology(n)(x)
+            except TypeError:
+                # if not, this methods needs to be overwritten by parent
+                raise NotImplementedError
+
+
+class HomologyFunctor(Functor):
+    r"""
+    Homology functor.
+
+    INPUT:
+
+    - ``domain`` -- must be a category of chain complexes
+    - ``n`` -- (default: ``None``) degree of the homology; if none is provided,
+      the direct sum homology will be used
+
+    EXAMPLES::
+
+        sage: C = ChainComplex({0: matrix(ZZ, 2, 3, [3, 0, 0, 0, 0, 0])})               # needs sage.modules
+        sage: H = HomologyFunctor(ChainComplexes(ZZ), 1)
+        sage: H(C)                                                                      # needs sage.libs.pari sage.modules
+        Z x C3
+
+    ::
+
+        sage: A.<x,y,z> = GradedCommutativeAlgebra(QQ, degrees=(2, 2, 3))               # needs sage.combinat sage.libs.singular sage.modules
+        sage: C = A.cdg_algebra({z: x*y})                                               # needs sage.combinat sage.libs.singular sage.modules
+        sage: H = HomologyFunctor(ChainComplexes(QQ), 2)
+        sage: H(C)                                                                      # needs sage.combinat sage.libs.singular sage.modules
+        Free module generated by {[x], [y]} over Rational Field
+
+    Applying to a chain map::
+
+        sage: # needs sage.graphs sage.modules
+        sage: S = simplicial_complexes.Sphere(1); S
+        Minimal triangulation of the 1-sphere
+        sage: SCC = S.chain_complex()
+        sage: SCC.differential()
+        {0: [],
+         1: [-1 -1  0]
+            [ 1  0 -1]
+            [ 0  1  1],
+         2: []}
+        sage: f = {0: zero_matrix(ZZ,3,3), 1: zero_matrix(ZZ,3,3)}
+        sage: G = Hom(SCC, SCC)
+        sage: x = G(f)
+        sage: H = HomologyFunctor(ChainComplexes(ZZ), 1)
+        sage: H(SCC)
+        Z
+        sage: H(x)
+        Generic morphism:
+          From: Z
+          To:   Z
+    """
+    def __init__(self, domain, n=None):
+        r"""
+        Construct the homology functor.
+
+        TESTS::
+
+            sage: H = HomologyFunctor(ChainComplexes(QQ), 1); H
+            Functor from Category of chain complexes over Rational Field to
+             Category of commutative additive groups
+        """
+        if not isinstance(domain, ChainComplexes):
+            raise TypeError(f'{domain} must be a category of chain complexes')
+        codomain = CommutativeAdditiveGroups()
+        super().__init__(domain, codomain)
+        self._n = n
+
+    def _apply_functor(self, x):
+        r"""
+        Apply ``self`` to a chain complex.
+
+        TESTS::
+
+            sage: C = ChainComplex({0: matrix(ZZ, 2, 3, [3, 0, 0, 0, 0, 0])})           # needs sage.modules
+            sage: H = HomologyFunctor(ChainComplexes(ZZ), 1)
+            sage: H._apply_functor(C)                                                   # needs sage.libs.pari sage.modules
+            Z x C3
+        """
+        return x.homology(self._n)
+
+    def _apply_functor_to_morphism(self, f):
+        r"""
+        Apply ``self`` to a chain map.
+
+        TESTS::
+
+            sage: # needs sage.symbolic
+            sage: E3 = EuclideanSpace(3)
+            sage: C = E3.de_rham_complex()
+            sage: id = Hom(C, C).identity()
+            sage: H = HomologyFunctor(ChainComplexes(SR))
+            sage: id_star = H(id); id_star
+            Generic endomorphism of De Rham cohomology ring on the
+             Euclidean space E^3
+            sage: one = H(C).one()
+            sage: id_star(one)
+            [one]
+        """
+        from sage.categories.homset import Hom
+        from sage.categories.morphism import SetMorphism
+
+        domain = f.domain()
+        codomain = f.codomain()
+        lift = domain.lift_from_homology
+        reduce = codomain.reduce_to_homology
+        apply_f_star = lambda x: reduce(f(lift(x)), self._n)
+        return SetMorphism(Hom(domain.homology(self._n),
+                               codomain.homology(self._n),
+                               CommutativeAdditiveGroups()),
+                           apply_f_star)