passagemath-categories 10.6.32__cp314-cp314t-musllinux_1_2_aarch64.whl

sage/categories/noetherian_rings.py

@@ -0,0 +1,87 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Noetherian rings
+
+EXAMPLES::
+
+    sage: from sage.categories.noetherian_rings import NoetherianRings
+    sage: GF(4, "a") in NoetherianRings()                                       # needs sage.rings.finite_rings
+    True
+    sage: QQ in NoetherianRings()
+    True
+    sage: ZZ in NoetherianRings()
+    True
+    sage: IntegerModRing(4) in NoetherianRings()
+    True
+    sage: IntegerModRing(5) in NoetherianRings()
+    True
+"""
+# ****************************************************************************
+#  Copyright (C) 2008 Teresa Gomez-Diaz (CNRS) <Teresa.Gomez-Diaz@univ-mlv.fr>
+#                2012 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.categories.category import Category
+from sage.categories.commutative_rings import CommutativeRings
+
+
+class NoetherianRings(Category):
+    """
+    The category of Noetherian rings.
+
+    A Noetherian ring is a commutative ring in which
+    every ideal is finitely generated.
+
+    See :wikipedia:`Noetherian ring`
+
+    EXAMPLES::
+
+        sage: from sage.categories.noetherian_rings import NoetherianRings
+        sage: C = NoetherianRings(); C
+        Category of noetherian rings
+        sage: sorted(C.super_categories(), key=str)
+        [Category of commutative rings]
+
+    TESTS::
+
+        sage: TestSuite(C).run()
+    """
+    def super_categories(self):
+        """
+        EXAMPLES::
+
+            sage: from sage.categories.noetherian_rings import NoetherianRings
+            sage: NoetherianRings().super_categories()
+            [Category of commutative rings]
+        """
+        return [CommutativeRings()]
+
+    class ParentMethods:
+        def is_noetherian(self, proof=True):
+            r"""
+            Return ``True``, since this in an object of the category
+            of Noetherian rings.
+
+            EXAMPLES::
+
+                sage: ZZ.is_noetherian()
+                True
+                sage: QQ.is_noetherian()
+                True
+                sage: ZZ['x'].is_noetherian()
+                True
+                sage: R.<x> = PolynomialRing(QQ)
+                sage: R.is_noetherian()
+                True
+
+                sage: L.<z> = LazyLaurentSeriesRing(QQ)                                 # needs sage.combinat
+                sage: L.is_noetherian()                                            # needs sage.combinat
+                True
+            """
+            return True
+
+    class ElementMethods:
+        pass

sage/categories/number_fields.py

@@ -0,0 +1,242 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Number fields
+"""
+# ****************************************************************************
+#  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)
+#                  https://www.gnu.org/licenses/
+# *****************************************************************************
+
+from sage.categories.category_singleton import Category_singleton
+from sage.categories.basic import Fields
+
+
+class NumberFields(Category_singleton):
+    r"""
+    The category of number fields.
+
+    EXAMPLES:
+
+    We create the category of number fields::
+
+        sage: C = NumberFields()
+        sage: C
+        Category of number fields
+
+    By definition, it is infinite::
+
+        sage: NumberFields().Infinite() is NumberFields()
+        True
+
+    Notice that the rational numbers `\QQ` *are* considered as
+    an object in this category::
+
+        sage: RationalField() in C
+        True
+
+    However, we can define a degree 1 extension of `\QQ`, which is of
+    course also in this category::
+
+        sage: x = PolynomialRing(RationalField(), 'x').gen()
+        sage: K = NumberField(x - 1, 'a'); K                                            # needs sage.rings.number_field
+        Number Field in a with defining polynomial x - 1
+        sage: K in C                                                                    # needs sage.rings.number_field
+        True
+
+    Number fields all lie in this category, regardless of the name
+    of the variable::
+
+        sage: K = NumberField(x^2 + 1, 'a')                                             # needs sage.rings.number_field
+        sage: K in C                                                                    # needs sage.rings.number_field
+        True
+
+    TESTS::
+
+        sage: TestSuite(NumberFields()).run()
+    """
+
+    def super_categories(self):
+        """
+        EXAMPLES::
+
+            sage: NumberFields().super_categories()
+            [Category of infinite fields]
+        """
+        return [Fields().Infinite()]
+
+    def __contains__(self, x):
+        r"""
+        Return ``True`` if ``x`` is a number field.
+
+        EXAMPLES::
+
+            sage: x = polygen(QQ, 'x')
+            sage: NumberField(x^2 + 1, 'a') in NumberFields()                           # needs sage.rings.number_field
+            True
+            sage: QuadraticField(-97, 'theta') in NumberFields()                        # needs sage.rings.number_field
+            True
+            sage: CyclotomicField(97) in NumberFields()                                 # needs sage.rings.number_field
+            True
+
+        Note that the rational numbers QQ are a number field::
+
+            sage: QQ in NumberFields()
+            True
+            sage: ZZ in NumberFields()
+            False
+        """
+        from sage.rings.number_field.number_field_base import NumberField
+        return isinstance(x, NumberField)
+
+    def _call_(self, x):
+        r"""
+        Construct an object in this category from the data in ``x``,
+        or raise a :exc:`TypeError`.
+
+        EXAMPLES::
+
+            sage: C = NumberFields()
+            sage: x = polygen(QQ, 'x')
+
+            sage: C(QQ)
+            Rational Field
+
+            sage: C(NumberField(x^2 + 1, 'a'))                                          # needs sage.rings.number_field
+            Number Field in a with defining polynomial x^2 + 1
+
+            sage: C(UnitGroup(NumberField(x^2 + 1, 'a')))  # indirect doctest           # needs sage.rings.number_field
+            Number Field in a with defining polynomial x^2 + 1
+
+            sage: C(ZZ)
+            Traceback (most recent call last):
+            ...
+            TypeError: unable to canonically associate a number field to Integer Ring
+        """
+        try:
+            return x.number_field()
+        except AttributeError:
+            raise TypeError("unable to canonically associate a number field to %s" % x)
+
+    class ParentMethods:
+        def zeta_function(self, prec=53,
+                          max_imaginary_part=0,
+                          max_asymp_coeffs=40, algorithm='pari'):
+            r"""
+            Return the Dedekind zeta function of this number field.
+
+            Actually, this returns an interface for computing with the
+            Dedekind zeta function `\zeta_F(s)` of the number field `F`.
+
+            INPUT:
+
+            - ``prec`` -- integer (default: 53); bits of precision
+
+            - ``max_imaginary_part`` -- real (default: 0)
+
+            - ``max_asymp_coeffs`` -- integer (default: 40)
+
+            - ``algorithm`` -- (default: ``'pari'``) either ``'gp'`` or
+              ``'pari'``
+
+            OUTPUT: the zeta function of this number field
+
+            If algorithm is ``'gp'``, this returns an interface to Tim
+            Dokchitser's gp script for computing with `L`-functions.
+
+            If algorithm is ``'pari'``, this returns instead an interface to Pari's
+            own general implementation of `L`-functions.
+
+            EXAMPLES::
+
+                sage: # needs sage.libs.pari sage.schemes
+                sage: K.<a> = NumberField(ZZ['x'].0^2 + ZZ['x'].0 - 1)                  # needs sage.rings.number_field
+                sage: Z = K.zeta_function(); Z                                          # needs sage.rings.number_field sage.symbolic
+                PARI zeta function associated to Number Field in a
+                 with defining polynomial x^2 + x - 1
+                sage: Z(-1)                                                             # needs sage.rings.number_field sage.symbolic
+                0.0333333333333333
+
+                sage: # needs sage.libs.pari sage.schemes
+                sage: x = polygen(QQ, 'x')
+                sage: L.<a, b, c> = NumberField([x^2 - 5, x^2 + 3, x^2 + 1])            # needs sage.rings.number_field
+                sage: Z = L.zeta_function()                                             # needs sage.rings.number_field sage.symbolic
+                sage: Z(5)                                                              # needs sage.rings.number_field sage.symbolic
+                1.00199015670185
+
+            Using the algorithm "pari"::
+
+                sage: # needs sage.libs.pari sage.schemes
+                sage: K.<a> = NumberField(ZZ['x'].0^2 + ZZ['x'].0 - 1)                  # needs sage.rings.number_field
+                sage: Z = K.zeta_function(algorithm='pari')                             # needs sage.rings.number_field sage.symbolic
+                sage: Z(-1)                                                             # needs sage.rings.number_field sage.symbolic
+                0.0333333333333333
+
+                sage: # needs sage.libs.pari sage.schemes
+                sage: x = polygen(QQ, 'x')
+                sage: L.<a, b, c> = NumberField([x^2 - 5, x^2 + 3, x^2 + 1])            # needs sage.rings.number_field
+                sage: Z = L.zeta_function(algorithm='pari')                             # needs sage.rings.number_field sage.symbolic
+                sage: Z(5)                                                              # needs sage.rings.number_field sage.symbolic
+                1.00199015670185
+
+            TESTS::
+
+                sage: # needs sage.libs.pari sage.schemes
+                sage: QQ.zeta_function()                                                # needs sage.symbolic
+                PARI zeta function associated to Rational Field
+            """
+            if algorithm == 'gp':
+                from sage.lfunctions.dokchitser import Dokchitser
+                r1, r2 = self.signature()
+                zero = [0]
+                one = [1]
+                Z = Dokchitser(conductor=abs(self.absolute_discriminant()),
+                               gammaV=(r1 + r2) * zero + r2 * one,
+                               weight=1,
+                               eps=1,
+                               poles=[1],
+                               prec=prec)
+                s = 'nf = nfinit(%s);' % self.absolute_polynomial()
+                s += 'dzk = dirzetak(nf,cflength());'
+                Z.init_coeffs('dzk[k]', pari_precode=s,
+                              max_imaginary_part=max_imaginary_part,
+                              max_asymp_coeffs=max_asymp_coeffs)
+                Z.check_functional_equation()
+                Z.rename('Dokchitser Zeta function associated to %s' % self)
+                return Z
+
+            if algorithm == 'pari':
+                from sage.lfunctions.pari import lfun_number_field, LFunction
+                Z = LFunction(lfun_number_field(self), prec=prec)
+                Z.rename('PARI zeta function associated to %s' % self)
+                return Z
+
+            raise ValueError('algorithm must be "gp" or "pari"')
+
+        def _test_absolute_disc(self, **options):
+            r"""
+            Run basic tests for the method :meth:`absolute_discriminant` of ``self``.
+
+            See the documentation for :class:`TestSuite` for information on
+            further options.
+
+            INPUT:
+
+            - ``options`` -- any keyword arguments accepted by :meth:`_tester`
+
+            EXAMPLES::
+
+                sage: x = polygen(ZZ, 'x')
+                sage: S = NumberField(x**3 - x - 1, 'a')                                # needs sage.rings.number_field
+                sage: S._test_absolute_disc()                                           # needs sage.rings.number_field
+            """
+            from sage.rings.integer import Integer
+            tester = self._tester(**options)
+            tester.assertIsInstance(self.absolute_discriminant(), Integer)
+
+    class ElementMethods:
+        pass

sage/categories/ore_modules.py

@@ -0,0 +1,189 @@
+# sage_setup: distribution = sagemath-categories
+from sage.misc.lazy_attribute import lazy_attribute
+from sage.misc.lazy_import import lazy_import
+
+from sage.categories.modules import Modules
+from sage.categories.category_types import Category_over_base_ring
+from sage.categories.homsets import Homsets
+
+lazy_import('sage.rings.polynomial.ore_polynomial_ring', 'OrePolynomialRing')
+
+
+class OreModules(Category_over_base_ring):
+    r"""
+    Category of Ore modules.
+    """
+    @staticmethod
+    def __classcall_private__(cls, ring, twist):
+        r"""
+        Normalize the input and call the init function.
+
+        INPUT:
+
+        - ``ring`` -- a commutative ring, the base ring of
+          the Ore modules
+
+        - ``twist`` -- a twisting morphism/derivation or a
+          Ore polynomial ring
+
+        TESTS::
+
+            sage: # needs sage.rings.finite_rings
+            sage: from sage.categories.ore_modules import OreModules
+            sage: K.<a> = GF(5^3)
+            sage: Frob = K.frobenius_endomorphism()
+            sage: cat = OreModules(K, Frob)
+            sage: cat
+            Category of Ore modules over Finite Field in a of size 5^3 twisted by a |--> a^5
+            sage: S = cat.ore_ring('y')
+            sage: cat is OreModules(K, S)
+            True
+        """
+        if isinstance(twist, OrePolynomialRing):
+            ore = twist.change_var('x')
+            if ore.base_ring() is not ring:
+                raise ValueError("base rings do not match")
+        else:
+            ore = OrePolynomialRing(ring, twist, names='x', polcast=False)
+        return cls.__classcall__(cls, ore)
+
+    def __init__(self, ore):
+        r"""
+        Initialize this category.
+
+        TESTS::
+
+            sage: # needs sage.rings.finite_rings
+            sage: from sage.categories.ore_modules import OreModules
+            sage: K.<a> = GF(5^3)
+            sage: Frob = K.frobenius_endomorphism()
+            sage: cat = OreModules(K, Frob)
+            sage: TestSuite(cat).run()
+        """
+        base = ore.base_ring()
+        Category_over_base_ring.__init__(self, base)
+        self._ore = ore
+
+    def __reduce__(self):
+        r"""
+        Return the arguments which were used to create this instance.
+
+        This method is needed for pickling.
+
+        TESTS::
+
+            sage: # needs sage.rings.finite_rings
+            sage: from sage.categories.ore_modules import OreModules
+            sage: K.<a> = GF(5^3)
+            sage: Frob = K.frobenius_endomorphism()
+            sage: cat = OreModules(K, Frob)
+            sage: cat2 = loads(dumps(cat))  # indirect doctest
+            sage: cat is cat2
+            True
+        """
+        return OreModules, (self.base_ring(), self._ore)
+
+    def super_categories(self):
+        r"""
+        Return the immediate super categories of this category.
+
+        EXAMPLES::
+
+            sage: # needs sage.rings.finite_rings
+            sage: from sage.categories.ore_modules import OreModules
+            sage: K.<a> = GF(5^3)
+            sage: Frob = K.frobenius_endomorphism()
+            sage: cat = OreModules(K, Frob)
+            sage: cat.super_categories()
+            [Category of vector spaces over Finite Field in a of size 5^3]
+        """
+        return [Modules(self.base())]
+
+    def _repr_object_names(self):
+        r"""
+        Return a string representation naming the objects
+        in this category.
+
+        EXAMPLES::
+
+            sage: # needs sage.rings.finite_rings
+            sage: from sage.categories.ore_modules import OreModules
+            sage: K.<a> = GF(5^3)
+            sage: Frob = K.frobenius_endomorphism()
+            sage: cat = OreModules(K, Frob)
+            sage: cat._repr_object_names()
+            'Ore modules over Finite Field in a of size 5^3 twisted by a |--> a^5'
+        """
+        return "Ore modules over %s %s" % (self.base_ring(), self._ore._repr_twist())
+
+    def ore_ring(self, var='x'):
+        r"""
+        Return the underlying Ore polynomial ring.
+
+        INPUT:
+
+        - ``var`` (default; ``x``) -- the variable name
+
+        EXAMPLES::
+
+            sage: # needs sage.rings.finite_rings
+            sage: from sage.categories.ore_modules import OreModules
+            sage: K.<a> = GF(5^3)
+            sage: Frob = K.frobenius_endomorphism()
+            sage: cat = OreModules(K, Frob)
+            sage: cat.ore_ring()
+            Ore Polynomial Ring in x over Finite Field in a of size 5^3 twisted by a |--> a^5
+            sage: cat.ore_ring('y')
+            Ore Polynomial Ring in y over Finite Field in a of size 5^3 twisted by a |--> a^5
+        """
+        return self._ore.change_var(var)
+
+    def twisting_morphism(self):
+        r"""
+        Return the underlying twisting morphism.
+
+        EXAMPLES::
+
+            sage: from sage.categories.ore_modules import OreModules
+
+            sage: # needs sage.rings.finite_rings
+            sage: K.<a> = GF(5^3)
+            sage: Frob = K.frobenius_endomorphism()
+            sage: cat = OreModules(K, Frob)
+            sage: cat.twisting_morphism()
+            Frobenius endomorphism a |--> a^5 on Finite Field in a of size 5^3
+
+        If the twisting morphism is the identity, nothing is returned::
+
+            sage: # needs sage.modules
+            sage: R.<t> = QQ[]
+            sage: d = R.derivation()
+            sage: cat = OreModules(R, d)
+            sage: cat.twisting_morphism()
+        """
+        return self._ore.twisting_morphism()
+
+    def twisting_derivation(self):
+        r"""
+        Return the underlying twisting derivation.
+
+        EXAMPLES::
+
+            sage: from sage.categories.ore_modules import OreModules
+
+            sage: # needs sage.modules
+            sage: R.<t> = QQ[]
+            sage: d = R.derivation()
+            sage: cat = OreModules(R, d)
+            sage: cat.twisting_derivation()
+            d/dt
+
+        If the twisting derivation is zero, nothing is returned::
+
+            sage: # needs sage.rings.finite_rings
+            sage: K.<a> = GF(5^3)
+            sage: Frob = K.frobenius_endomorphism()
+            sage: cat = OreModules(K, Frob)
+            sage: cat.twisting_derivation()
+        """
+        return self._ore.twisting_derivation()

sage/categories/partially_ordered_monoids.py

@@ -0,0 +1,49 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Partially ordered monoids
+"""
+#*****************************************************************************
+#  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_singleton import Category_singleton
+from sage.categories.basic import Posets, Monoids
+
+
+class PartiallyOrderedMonoids(Category_singleton):
+    r"""
+    The category of partially ordered monoids, that is partially ordered sets
+    which are also monoids, and such that multiplication preserves the
+    ordering: `x \leq y` implies `x*z < y*z` and `z*x < z*y`.
+
+    See :wikipedia:`Ordered_monoid`
+
+    EXAMPLES::
+
+        sage: PartiallyOrderedMonoids()
+        Category of partially ordered monoids
+        sage: PartiallyOrderedMonoids().super_categories()
+        [Category of posets, Category of monoids]
+
+    TESTS::
+
+        sage: TestSuite(PartiallyOrderedMonoids()).run()
+    """
+
+    def super_categories(self):
+        """
+        EXAMPLES::
+
+            sage: PartiallyOrderedMonoids().super_categories()
+            [Category of posets, Category of monoids]
+        """
+        return [Posets(), Monoids()]
+
+    class ParentMethods:
+        pass
+
+    class ElementMethods:
+        pass

sage/categories/permutation_groups.py

@@ -0,0 +1,63 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Permutation groups
+"""
+#*****************************************************************************
+#  Copyright (C) 2011      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 import Category
+from sage.categories.groups import Groups
+from sage.misc.lazy_import import LazyImport
+
+
+class PermutationGroups(Category):
+    r"""
+    The category of permutation groups.
+
+    A *permutation group* is a group whose elements are concretely
+    represented by permutations of some set. In other words, the group
+    comes endowed with a distinguished action on some set.
+
+    This distinguished action should be preserved by permutation group
+    morphisms. For details, see
+    :wikipedia:`Permutation_group#Permutation_isomorphic_groups`.
+
+    .. TODO:: shall we accept only permutations with finite support or not?
+
+    EXAMPLES::
+
+        sage: PermutationGroups()
+        Category of permutation groups
+        sage: PermutationGroups().super_categories()
+        [Category of groups]
+
+    The category of permutation groups defines additional structure
+    that should be preserved by morphisms, namely the distinguished
+    action::
+
+        sage: PermutationGroups().additional_structure()
+        Category of permutation groups
+
+    TESTS::
+
+        sage: C = PermutationGroups()
+        sage: TestSuite(C).run()
+    """
+    @cached_method
+    def super_categories(self):
+        """
+        Return a list of the immediate super categories of ``self``.
+
+        EXAMPLES::
+
+            sage: PermutationGroups().super_categories()
+            [Category of groups]
+        """
+        return [Groups()]
+
+    Finite = LazyImport('sage.categories.finite_permutation_groups', 'FinitePermutationGroups')

sage/categories/pointed_sets.py

@@ -0,0 +1,42 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Pointed sets
+"""
+#*****************************************************************************
+#  Copyright (C) 2008 David Kohel <kohel@maths.usyd.edu> and
+#                     William Stein <wstein@math.ucsd.edu>
+#                     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_singleton import Category_singleton
+from sage.categories.sets_cat import Sets
+
+
+class PointedSets(Category_singleton):
+    """
+    The category of pointed sets.
+
+    EXAMPLES::
+
+        sage: PointedSets()
+        Category of pointed sets
+
+    TESTS::
+
+        sage: TestSuite(PointedSets()).run()
+    """
+    #def __call__(self, X, pt):
+    #    import sage.sets.all
+    #    return sage.sets.all.Set(X, pt)
+
+    def super_categories(self):
+        """
+        EXAMPLES::
+
+            sage: PointedSets().super_categories()
+            [Category of sets]
+        """
+        return [Sets()] # ???