passagemath-categories 10.6.32__cp314-cp314t-musllinux_1_2_aarch64.whl

sage/categories/commutative_additive_groups.py

@@ -0,0 +1,104 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Commutative additive groups
+"""
+#*****************************************************************************
+#  Copyright (C) 2008 Teresa Gomez-Diaz (CNRS) <Teresa.Gomez-Diaz@univ-mlv.fr>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#                  http://www.gnu.org/licenses/
+#******************************************************************************
+
+from sage.categories.category_types import AbelianCategory
+from sage.categories.category_with_axiom import CategoryWithAxiom
+from sage.categories.algebra_functor import AlgebrasCategory
+from sage.categories.cartesian_product import CartesianProductsCategory
+from sage.categories.additive_groups import AdditiveGroups
+
+
+class CommutativeAdditiveGroups(CategoryWithAxiom, AbelianCategory):
+    """
+    The category of abelian groups, i.e. additive abelian monoids
+    where each element has an inverse.
+
+    EXAMPLES::
+
+        sage: C = CommutativeAdditiveGroups(); C
+        Category of commutative additive groups
+        sage: C.super_categories()
+        [Category of additive groups, Category of commutative additive monoids]
+        sage: sorted(C.axioms())
+        ['AdditiveAssociative', 'AdditiveCommutative', 'AdditiveInverse', 'AdditiveUnital']
+        sage: C is CommutativeAdditiveMonoids().AdditiveInverse()
+        True
+        sage: from sage.categories.additive_groups import AdditiveGroups
+        sage: C is AdditiveGroups().AdditiveCommutative()
+        True
+
+    .. NOTE::
+
+        This category is currently empty. It's left there for backward
+        compatibility and because it is likely to grow in the future.
+
+    TESTS::
+
+        sage: TestSuite(CommutativeAdditiveGroups()).run()
+        sage: sorted(CommutativeAdditiveGroups().CartesianProducts().axioms())
+        ['AdditiveAssociative', 'AdditiveCommutative', 'AdditiveInverse', 'AdditiveUnital']
+
+    The empty covariant functorial construction category classes
+    ``CartesianProducts`` and ``Algebras`` are left here for the sake
+    of nicer output since this is a commonly used category::
+
+        sage: CommutativeAdditiveGroups().CartesianProducts()
+        Category of Cartesian products of commutative additive groups
+        sage: CommutativeAdditiveGroups().Algebras(QQ)
+        Category of commutative additive group algebras over Rational Field
+
+    Also, it's likely that some code will end up there at some point.
+    """
+    _base_category_class_and_axiom = (AdditiveGroups, "AdditiveCommutative")
+
+    def __lean_init__(self):
+        return 'add_comm_group'
+
+    class CartesianProducts(CartesianProductsCategory):
+        class ElementMethods:
+            def additive_order(self):
+                r"""
+                Return the additive order of this element.
+
+                EXAMPLES::
+
+                    sage: G = cartesian_product([Zmod(3), Zmod(6), Zmod(5)])
+                    sage: G((1,1,1)).additive_order()
+                    30
+                    sage: any((i * G((1,1,1))).is_zero() for i in range(1,30))
+                    False
+                    sage: 30 * G((1,1,1))
+                    (0, 0, 0)
+
+                    sage: G = cartesian_product([ZZ, ZZ])
+                    sage: G((0,0)).additive_order()
+                    1
+                    sage: G((0,1)).additive_order()
+                    +Infinity
+
+                    sage: # needs sage.rings.finite_rings
+                    sage: K = GF(9)
+                    sage: H = cartesian_product([
+                    ....:     cartesian_product([Zmod(2), Zmod(9)]), K])
+                    sage: z = H(((1,2), K.gen()))
+                    sage: z.additive_order()
+                    18
+                """
+                from sage.rings.infinity import Infinity
+                orders = [x.additive_order() for x in self.cartesian_factors()]
+                if any(o is Infinity for o in orders):
+                    return Infinity
+                else:
+                    from sage.arith.functions import LCM_list
+                    return LCM_list(orders)
+
+    class Algebras(AlgebrasCategory):
+        pass

sage/categories/commutative_additive_monoids.py

@@ -0,0 +1,45 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Commutative additive monoids
+"""
+#*****************************************************************************
+#  Copyright (C) 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_with_axiom import CategoryWithAxiom
+from sage.categories.additive_monoids import AdditiveMonoids
+
+
+class CommutativeAdditiveMonoids(CategoryWithAxiom):
+    """
+    The category of commutative additive monoids, that is abelian
+    additive semigroups with a unit
+
+    EXAMPLES::
+
+        sage: C = CommutativeAdditiveMonoids(); C
+        Category of commutative additive monoids
+        sage: C.super_categories()
+        [Category of additive monoids, Category of commutative additive semigroups]
+        sage: sorted(C.axioms())
+        ['AdditiveAssociative', 'AdditiveCommutative', 'AdditiveUnital']
+        sage: C is AdditiveMagmas().AdditiveAssociative().AdditiveCommutative().AdditiveUnital()
+        True
+
+    .. NOTE::
+
+        This category is currently empty and only serves as a place
+        holder to make ``C.example()`` work.
+
+    TESTS::
+
+        sage: TestSuite(CommutativeAdditiveMonoids()).run()
+    """
+    _base_category_class_and_axiom = (AdditiveMonoids, "AdditiveCommutative")
+
+    def __lean_init__(self):
+        return 'add_comm_monoid'

sage/categories/commutative_additive_semigroups.py

@@ -0,0 +1,48 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Commutative additive semigroups
+"""
+#*****************************************************************************
+#  Copyright (C) 2008 Teresa Gomez-Diaz (CNRS) <Teresa.Gomez-Diaz@univ-mlv.fr>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#                  http://www.gnu.org/licenses/
+#******************************************************************************
+
+from sage.categories.category_with_axiom import CategoryWithAxiom
+from sage.categories.additive_semigroups import AdditiveSemigroups
+
+
+class CommutativeAdditiveSemigroups(CategoryWithAxiom):
+    """
+    The category of additive abelian semigroups, i.e. sets with an
+    associative and abelian operation +.
+
+    EXAMPLES::
+
+        sage: C = CommutativeAdditiveSemigroups(); C
+        Category of commutative additive semigroups
+        sage: C.example()
+        An example of a commutative semigroup: the free commutative semigroup generated by ('a', 'b', 'c', 'd')
+
+        sage: sorted(C.super_categories(), key=str)
+        [Category of additive commutative additive magmas,
+         Category of additive semigroups]
+        sage: sorted(C.axioms())
+        ['AdditiveAssociative', 'AdditiveCommutative']
+        sage: C is AdditiveMagmas().AdditiveAssociative().AdditiveCommutative()
+        True
+
+    .. NOTE::
+
+        This category is currently empty and only serves as a place
+        holder to make ``C.example()`` work.
+
+    TESTS::
+
+        sage: TestSuite(C).run()
+    """
+    _base_category_class_and_axiom = (AdditiveSemigroups, "AdditiveCommutative")
+
+    def __lean_init__(self):
+        return 'add_comm_semigroup'

sage/categories/commutative_algebra_ideals.py

@@ -0,0 +1,87 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Commutative algebra ideals
+"""
+#*****************************************************************************
+#  Copyright (C) 2005      David Kohel <kohel@maths.usyd.edu>
+#                          William Stein <wstein@math.ucsd.edu>
+#                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.algebra_ideals import AlgebraIdeals
+from sage.categories.category_types import Category_ideal, Category_in_ambient
+from sage.categories.commutative_algebras import CommutativeAlgebras
+from sage.categories.commutative_rings import CommutativeRings
+
+
+class CommutativeAlgebraIdeals(Category_ideal):
+    """
+    The category of ideals in a fixed commutative algebra `A`.
+
+    EXAMPLES::
+
+        sage: C = CommutativeAlgebraIdeals(QQ['x'])
+        sage: C
+        Category of commutative algebra ideals in
+         Univariate Polynomial Ring in x over Rational Field
+    """
+    def __init__(self, A):
+        """
+        EXAMPLES::
+
+            sage: CommutativeAlgebraIdeals(ZZ['x'])
+            Category of commutative algebra ideals in
+             Univariate Polynomial Ring in x over Integer Ring
+
+            sage: CommutativeAlgebraIdeals(ZZ)
+            Traceback (most recent call last):
+            ...
+            TypeError: A (=Integer Ring) must be a commutative algebra
+
+            sage: CommutativeAlgebraIdeals(IntegerModRing(4))
+            Traceback (most recent call last):
+            ...
+            TypeError: A (=Ring of integers modulo 4) must be a commutative algebra
+
+            sage: CommutativeAlgebraIdeals(Partitions(4))
+            Traceback (most recent call last):
+            ...
+            TypeError: A (=Partitions of the integer 4) must be a commutative algebra
+
+        TESTS::
+
+            sage: TestSuite(CommutativeAlgebraIdeals(QQ['x'])).run()
+        """
+        # TODO: replace by ``A in CommutativeAlgebras(*)`` once a
+        # suitable mantra has been implemented for this.
+        try:
+            base_ring = A.base_ring()
+        except AttributeError:
+            raise TypeError(f"A (={A}) must be a commutative algebra")
+        else:
+            if base_ring not in CommutativeRings() or A not in CommutativeAlgebras(base_ring.category()):
+                raise TypeError(f"A (={A}) must be a commutative algebra")
+
+        Category_in_ambient.__init__(self, A)
+
+    def algebra(self):
+        """
+        EXAMPLES::
+
+            sage: CommutativeAlgebraIdeals(QQ['x']).algebra()
+            Univariate Polynomial Ring in x over Rational Field
+        """
+        return self.ambient()
+
+    def super_categories(self):
+        """
+        EXAMPLES::
+
+            sage: CommutativeAlgebraIdeals(QQ['x']).super_categories()
+            [Category of algebra ideals in Univariate Polynomial Ring in x over Rational Field]
+        """
+        R = self.algebra()
+        return [AlgebraIdeals(R)]

sage/categories/commutative_algebras.py

@@ -0,0 +1,94 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Commutative algebras
+"""
+#*****************************************************************************
+#  Copyright (C) 2005      David Kohel <kohel@maths.usyd.edu>
+#                          William Stein <wstein@math.ucsd.edu>
+#                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.misc.cachefunc import cached_method
+from sage.categories.category_with_axiom import CategoryWithAxiom_over_base_ring
+from sage.categories.algebras import Algebras
+from sage.categories.commutative_rings import CommutativeRings
+from sage.categories.tensor import TensorProductsCategory
+
+
+class CommutativeAlgebras(CategoryWithAxiom_over_base_ring):
+    """
+    The category of commutative algebras with unit over a given base ring.
+
+    EXAMPLES::
+
+        sage: M = CommutativeAlgebras(GF(19))
+        sage: M
+        Category of commutative algebras over Finite Field of size 19
+        sage: CommutativeAlgebras(QQ).super_categories()
+        [Category of algebras over Rational Field, Category of commutative rings]
+
+    This is just a shortcut for::
+
+        sage: Algebras(QQ).Commutative()
+        Category of commutative algebras over Rational Field
+
+    TESTS::
+
+        sage: Algebras(QQ).Commutative() is CommutativeAlgebras(QQ)
+        True
+        sage: TestSuite(CommutativeAlgebras(ZZ)).run()
+
+    .. TODO::
+
+     - product   ( = Cartesian product)
+     - coproduct ( = tensor product over base ring)
+    """
+
+    def __contains__(self, A):
+        """
+        EXAMPLES::
+
+            sage: QQ['a'] in CommutativeAlgebras(QQ)
+            True
+            sage: QQ['a,b'] in CommutativeAlgebras(QQ)
+            True
+            sage: FreeAlgebra(QQ, 2, 'a,b') in CommutativeAlgebras(QQ)                  # needs sage.combinat sage.modules
+            False
+
+        TODO: get rid of this method once all commutative algebras in
+        Sage declare themselves in this category
+        """
+        return super().__contains__(A) or \
+            (A in Algebras(self.base_ring()) and hasattr(A, "is_commutative") and A.is_commutative())
+
+    class TensorProducts(TensorProductsCategory):
+        """
+        The category of commutative algebras constructed by tensor product of commutative algebras.
+        """
+
+        @cached_method
+        def extra_super_categories(self):
+            """
+            EXAMPLES::
+
+                sage: Algebras(QQ).Commutative().TensorProducts().extra_super_categories()
+                [Category of commutative rings]
+                sage: Algebras(QQ).Commutative().TensorProducts().super_categories()
+                [Category of tensor products of algebras over Rational Field,
+                 Category of commutative algebras over Rational Field]
+
+            TESTS::
+
+                sage: # needs sage.combinat sage.modules
+                sage: X = algebras.Shuffle(QQ, 'ab')
+                sage: Y = algebras.Shuffle(QQ, 'bc')
+                sage: X in Algebras(QQ).Commutative()
+                True
+                sage: T = tensor([X, Y])
+                sage: T in CommutativeRings()
+                True
+            """
+            return [CommutativeRings()]

sage/categories/commutative_ring_ideals.py

@@ -0,0 +1,58 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Commutative ring ideals
+"""
+#*****************************************************************************
+#  Copyright (C) 2005      David Kohel <kohel@maths.usyd.edu>
+#                          William Stein <wstein@math.ucsd.edu>
+#                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_types import Category_ideal
+from sage.categories.commutative_rings import CommutativeRings
+from sage.categories.ring_ideals import RingIdeals
+
+
+class CommutativeRingIdeals(Category_ideal):
+    """
+    The category of ideals in a fixed commutative ring.
+
+    EXAMPLES::
+
+        sage: C = CommutativeRingIdeals(IntegerRing())
+        sage: C
+        Category of commutative ring ideals in Integer Ring
+    """
+    def __init__(self, R):
+        """
+        EXAMPLES::
+
+            sage: CommutativeRingIdeals(ZZ)
+            Category of commutative ring ideals in Integer Ring
+            sage: CommutativeRingIdeals(IntegerModRing(4))
+            Category of commutative ring ideals in Ring of integers modulo 4
+
+        TESTS::
+
+            sage: CommutativeRingIdeals(Partitions(4))
+            Traceback (most recent call last):
+            ...
+            TypeError: R (=Partitions of the integer 4) must be a commutative ring
+            sage: TestSuite(CommutativeRingIdeals(ZZ)).run()
+        """
+        if R not in CommutativeRings():
+            raise TypeError("R (=%s) must be a commutative ring" % R)
+        Category_ideal.__init__(self, R)
+
+    def super_categories(self):
+        """
+        EXAMPLES::
+
+            sage: CommutativeRingIdeals(ZZ).super_categories()
+            [Category of ring ideals in Integer Ring]
+        """
+        R = self.ring()
+        return [RingIdeals(R)]