passagemath-categories 10.6.32__cp314-cp314t-musllinux_1_2_aarch64.whl

sage/categories/cw_complexes.py

@@ -0,0 +1,216 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+CW Complexes
+"""
+#*****************************************************************************
+#  Copyright (C) 2015 Travis Scrimshaw <tscrim at ucdavis.edu>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#                  http://www.gnu.org/licenses/
+#******************************************************************************
+
+from sage.misc.abstract_method import abstract_method
+from sage.misc.cachefunc import cached_method
+from sage.categories.category_singleton import Category_singleton
+from sage.categories.category_with_axiom import CategoryWithAxiom
+from sage.categories.sets_cat import Sets
+
+
+class CWComplexes(Category_singleton):
+    r"""
+    The category of CW complexes.
+
+    A CW complex is a Closure-finite cell complex in the Weak topology.
+
+    REFERENCES:
+
+    - :wikipedia:`CW_complex`
+
+    .. NOTE::
+
+        The notion of "finite" is that the number of cells is finite.
+
+    EXAMPLES::
+
+        sage: from sage.categories.cw_complexes import CWComplexes
+        sage: C = CWComplexes(); C
+        Category of CW complexes
+
+    TESTS::
+
+        sage: TestSuite(C).run()
+    """
+    @cached_method
+    def super_categories(self):
+        """
+        EXAMPLES::
+
+            sage: from sage.categories.cw_complexes import CWComplexes
+            sage: CWComplexes().super_categories()
+            [Category of topological spaces]
+        """
+        return [Sets().Topological()]
+
+    def _repr_object_names(self):
+        """
+        EXAMPLES::
+
+            sage: from sage.categories.cw_complexes import CWComplexes
+            sage: CWComplexes() # indirect doctest
+            Category of CW complexes
+        """
+        return "CW complexes"
+
+    class SubcategoryMethods:
+        @cached_method
+        def Connected(self):
+            """
+            Return the full subcategory of the connected objects of ``self``.
+
+            EXAMPLES::
+
+                sage: from sage.categories.cw_complexes import CWComplexes
+                sage: CWComplexes().Connected()
+                Category of connected CW complexes
+
+            TESTS::
+
+                sage: TestSuite(CWComplexes().Connected()).run()
+                sage: CWComplexes().Connected.__module__
+                'sage.categories.cw_complexes'
+            """
+            return self._with_axiom('Connected')
+
+        @cached_method
+        def FiniteDimensional(self):
+            """
+            Return the full subcategory of the finite dimensional
+            objects of ``self``.
+
+            EXAMPLES::
+
+                sage: from sage.categories.cw_complexes import CWComplexes
+                sage: C = CWComplexes().FiniteDimensional(); C
+                Category of finite dimensional CW complexes
+
+            TESTS::
+
+                sage: from sage.categories.cw_complexes import CWComplexes
+                sage: C = CWComplexes().FiniteDimensional()
+                sage: TestSuite(C).run()
+                sage: CWComplexes().Connected().FiniteDimensional.__module__
+                'sage.categories.cw_complexes'
+            """
+            return self._with_axiom('FiniteDimensional')
+
+    class Connected(CategoryWithAxiom):
+        """
+        The category of connected CW complexes.
+        """
+
+    class FiniteDimensional(CategoryWithAxiom):
+        """
+        Category of finite dimensional CW complexes.
+        """
+
+    class Finite(CategoryWithAxiom):
+        """
+        Category of finite CW complexes.
+
+        A finite CW complex is a CW complex with a finite number of cells.
+        """
+        def extra_super_categories(self):
+            """
+            Return the extra super categories of ``self``.
+
+            A finite CW complex is a compact finite-dimensional CW complex.
+
+            EXAMPLES::
+
+                sage: from sage.categories.cw_complexes import CWComplexes
+                sage: C = CWComplexes().Finite()
+                sage: C.extra_super_categories()
+                [Category of finite dimensional CW complexes,
+                 Category of compact topological spaces]
+            """
+            return [CWComplexes().FiniteDimensional(), Sets().Topological().Compact()]
+
+        class ParentMethods:
+            @cached_method
+            def dimension(self):
+                """
+                Return the dimension of ``self``.
+
+                EXAMPLES::
+
+                    sage: from sage.categories.cw_complexes import CWComplexes
+                    sage: X = CWComplexes().example()
+                    sage: X.dimension()
+                    2
+                """
+                C = self.cells()
+                return max(c.dimension() for d in C.keys() for c in C[d])
+
+    def Compact_extra_super_categories(self):
+        """
+        Return extraneous super categories for ``CWComplexes().Compact()``.
+
+        A compact CW complex is finite, see Proposition A.1 in [Hat2002]_.
+
+        .. TODO::
+
+            Fix the name of finite CW complexes.
+
+        EXAMPLES::
+
+            sage: from sage.categories.cw_complexes import CWComplexes
+            sage: CWComplexes().Compact() # indirect doctest
+            Category of finite finite dimensional CW complexes
+            sage: CWComplexes().Compact() is CWComplexes().Finite()
+            True
+        """
+        return (Sets().Finite(),)
+
+    class ElementMethods:
+        @abstract_method
+        def dimension(self):
+            """
+            Return the dimension of ``self``.
+
+            EXAMPLES::
+
+                sage: from sage.categories.cw_complexes import CWComplexes
+                sage: X = CWComplexes().example()
+                sage: X.an_element().dimension()
+                2
+            """
+
+    class ParentMethods:
+        @abstract_method
+        def dimension(self):
+            """
+            Return the dimension of ``self``.
+
+            EXAMPLES::
+
+                sage: from sage.categories.cw_complexes import CWComplexes
+                sage: X = CWComplexes().example()
+                sage: X.dimension()
+                2
+            """
+
+        @abstract_method(optional=True)
+        def cells(self):
+            """
+            Return the cells of ``self``.
+
+            EXAMPLES::
+
+                sage: from sage.categories.cw_complexes import CWComplexes
+                sage: X = CWComplexes().example()
+                sage: C = X.cells()
+                sage: sorted((d, C[d]) for d in C.keys())
+                [(0, (0-cell v,)),
+                 (1, (0-cell e1, 0-cell e2)),
+                 (2, (2-cell f,))]
+            """

sage/categories/dedekind_domains.py

@@ -0,0 +1,137 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Dedekind Domains
+"""
+# ****************************************************************************
+#  Distributed under the terms of the GNU General Public License (GPL)
+#                  https://www.gnu.org/licenses/
+# *****************************************************************************
+try:
+    from typing import Self  # type: ignore (Python >= 3.11)
+except ImportError:
+    from typing_extensions import Self  # type: ignore (Python 3.10)
+
+from sage.categories.category import Category
+from sage.categories.integral_domains import IntegralDomains
+
+
+class DedekindDomains(Category):
+    """
+    The category of Dedekind domains.
+
+    A Dedekind domain is a Noetherian integral domain of Krull
+    dimension one that is integrally closed in its field of fractions.
+
+    EXAMPLES::
+
+        sage: C = DedekindDomains(); C
+        Category of Dedekind domains
+        sage: C.super_categories()
+        [Category of integral domains]
+
+    TESTS::
+
+        sage: TestSuite(C).run()
+    """
+    def super_categories(self):
+        """
+        EXAMPLES::
+
+            sage: DedekindDomains().super_categories()
+            [Category of integral domains]
+        """
+        return [IntegralDomains()]
+
+    class ParentMethods:
+        def krull_dimension(self):
+            """
+            Return 1 since Dedekind domains have Krull dimension 1.
+
+            EXAMPLES:
+
+            The following are examples of Dedekind domains::
+
+                sage: ZZ.krull_dimension()
+                1
+                sage: x = polygen(ZZ, 'x')
+                sage: K = NumberField(x^2 + 1, 's')                                         # needs sage.rings.number_field
+                sage: OK = K.ring_of_integers()                                             # needs sage.rings.number_field
+                sage: OK.krull_dimension()                                                  # needs sage.rings.number_field
+                1
+            """
+            from sage.rings.integer_ring import ZZ
+            return ZZ.one()
+
+        def is_integrally_closed(self) -> bool:
+            """
+            Return ``True`` since Dedekind domains are integrally closed.
+
+            EXAMPLES:
+
+            The following are examples of Dedekind domains::
+
+                sage: ZZ.is_integrally_closed()
+                True
+                sage: x = polygen(ZZ, 'x')
+                sage: K = NumberField(x^2 + 1, 's')                                         # needs sage.rings.number_field
+                sage: OK = K.ring_of_integers()                                             # needs sage.rings.number_field
+                sage: OK.is_integrally_closed()                                             # needs sage.rings.number_field
+                True
+
+            These, however, are not Dedekind domains::
+
+                sage: QQ.is_integrally_closed()
+                True
+                sage: S = ZZ[sqrt(5)]; S.is_integrally_closed()                             # needs fpylll sage.rings.number_field sage.symbolic
+                False
+                sage: T.<x,y> = PolynomialRing(QQ, 2); T
+                Multivariate Polynomial Ring in x, y over Rational Field
+                sage: T.is_integral_domain()
+                True
+            """
+            return True
+
+        def integral_closure(self) -> Self:
+            r"""
+            Return ``self`` since Dedekind domains are integrally closed.
+
+            EXAMPLES::
+
+                sage: # needs sage.rings.number_field
+                sage: x = polygen(ZZ, 'x')
+                sage: K = NumberField(x^2 + 1, 's')
+                sage: OK = K.ring_of_integers()
+                sage: OK.integral_closure()
+                Gaussian Integers generated by s in Number Field in s
+                 with defining polynomial x^2 + 1
+                sage: OK.integral_closure() == OK
+                True
+
+                sage: QQ.integral_closure() == QQ
+                True
+            """
+            return self
+
+        def is_noetherian(self) -> bool:
+            r"""
+            Return ``True`` since Dedekind domains are Noetherian.
+
+            EXAMPLES:
+
+            The integers, `\ZZ`, and rings of integers of number
+            fields are Dedekind domains::
+
+                sage: ZZ.is_noetherian()
+                True
+                sage: x = polygen(ZZ, 'x')
+                sage: K = NumberField(x^2 + 1, 's')                                         # needs sage.rings.number_field
+                sage: OK = K.ring_of_integers()                                             # needs sage.rings.number_field
+                sage: OK.is_noetherian()                                                    # needs sage.rings.number_field
+                True
+                sage: QQ.is_noetherian()
+                True
+            """
+            return True
+
+    class ElementMethods:
+        pass

sage/categories/discrete_valuation.py

@@ -0,0 +1,325 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Discrete Valuation Rings (DVR) and Fields (DVF)
+"""
+#**************************************************************************
+#  Copyright (C) 2013 Xavier Caruso <xavier.caruso@normalesup.org>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#                  http://www.gnu.org/licenses/
+#**************************************************************************
+
+
+from sage.misc.abstract_method import abstract_method
+from sage.categories.category_singleton import Category_singleton
+from sage.categories.euclidean_domains import EuclideanDomains
+from sage.categories.fields import Fields
+
+
+class DiscreteValuationRings(Category_singleton):
+    """
+    The category of discrete valuation rings.
+
+    EXAMPLES::
+
+        sage: GF(7)[['x']] in DiscreteValuationRings()
+        True
+        sage: TestSuite(DiscreteValuationRings()).run()
+    """
+    def super_categories(self):
+        """
+        EXAMPLES::
+
+            sage: DiscreteValuationRings().super_categories()
+            [Category of euclidean domains]
+        """
+        return [EuclideanDomains()]
+
+    class ParentMethods:
+        @abstract_method
+        def uniformizer(self):
+            """
+            Return a uniformizer of this ring.
+
+            EXAMPLES::
+
+                sage: Zp(5).uniformizer()                                               # needs sage.rings.padics
+                5 + O(5^21)
+
+                sage: K.<u> = QQ[[]]
+                sage: K.uniformizer()
+                u
+            """
+
+        @abstract_method
+        def residue_field(self):
+            """
+            Return the residue field of this ring.
+
+            EXAMPLES::
+
+                sage: Zp(5).residue_field()                                             # needs sage.rings.padics
+                Finite Field of size 5
+
+                sage: K.<u> = QQ[[]]
+                sage: K.residue_field()
+                Rational Field
+            """
+
+        def _matrix_charpoly(self, M, var):
+            r"""
+            Return the characteristic polynomial of `M`.
+
+            EXAMPLES::
+
+                sage: # needs sage.modules
+                sage: R.<t> = PowerSeriesRing(GF(5))
+                sage: M = matrix(4, 4, [(t^(i+j)).add_bigoh(10)
+                ....:                   for i in range(4) for j in range(4)])
+                sage: M
+                [  1 + O(t^10)   t + O(t^10) t^2 + O(t^10) t^3 + O(t^10)]
+                [  t + O(t^10) t^2 + O(t^10) t^3 + O(t^10) t^4 + O(t^10)]
+                [t^2 + O(t^10) t^3 + O(t^10) t^4 + O(t^10) t^5 + O(t^10)]
+                [t^3 + O(t^10) t^4 + O(t^10) t^5 + O(t^10) t^6 + O(t^10)]
+                sage: M.charpoly()   # indirect doctest
+                x^4 + (4 + 4*t^2 + 4*t^4 + 4*t^6 + O(t^10))*x^3
+
+            Note that this function uses a Hessenberg-like algorithm
+            that performs divisions. Hence, truncations may show up
+            even if the input matrix is exact::
+
+                sage: # needs sage.modules
+                sage: M = matrix(3, 3, [ 1, t, t^2, 1+t, t^2, t^3, t^2, t^3, t^4 ])
+                sage: M
+                [    1     t   t^2]
+                [1 + t   t^2   t^3]
+                [  t^2   t^3   t^4]
+                sage: M.charpoly()
+                x^3 + (4 + 4*t^2 + 4*t^4 + O(t^25))*x^2 + (4*t + O(t^24))*x
+
+            Another example over the `p`-adics::
+
+                sage: # needs sage.modules sage.rings.padics
+                sage: R = Zp(5, print_mode='digits', prec=5)
+                sage: M = matrix(R, 3, 3, range(9))
+                sage: M
+                [        0  ...00001  ...00002]
+                [ ...00003  ...00004 ...000010]
+                [ ...00011  ...00012  ...00013]
+                sage: M.charpoly()
+                ...00001*x^3 + ...44423*x^2 + ...44412*x + ...00000
+            """
+            return M._charpoly_hessenberg(var)
+
+    class ElementMethods:
+        @abstract_method
+        def valuation(self):
+            """
+            Return the valuation of this element.
+
+            EXAMPLES::
+
+                sage: # needs sage.rings.padics
+                sage: x = Zp(5)(50)
+                sage: x.valuation()
+                2
+            """
+
+        def euclidean_degree(self):
+            """
+            Return the Euclidean degree of this element.
+
+            TESTS::
+
+                sage: R.<q> = GF(5)[[]]
+                sage: (q^3).euclidean_degree()
+                3
+                sage: R(0).euclidean_degree()
+                Traceback (most recent call last):
+                ...
+                ValueError: Euclidean degree of the zero element not defined
+            """
+            if not self:
+                raise ValueError("Euclidean degree of the zero element not defined")
+            return self.valuation()
+
+        def quo_rem(self, other):
+            """
+            Return the quotient and remainder for Euclidean division
+            of ``self`` by ``other``.
+
+            EXAMPLES::
+
+                sage: R.<q> = GF(5)[[]]
+                sage: (q^2 + q).quo_rem(q)
+                (1 + q, 0)
+                sage: (q + 1).quo_rem(q^2)
+                (0, 1 + q)
+
+            TESTS::
+
+                sage: q.quo_rem(0)
+                Traceback (most recent call last):
+                ...
+                ZeroDivisionError: Euclidean division by the zero element not defined
+
+                sage: L = PowerSeriesRing(QQ, 't')
+                sage: t = L.gen()
+                sage: F = algebras.Free(L, ['A', 'B'])                                  # needs sage.combinat sage.modules
+                sage: A, B = F.gens()                                                   # needs sage.combinat sage.modules
+                sage: f = t*A + t**2*B/2                                                # needs sage.combinat sage.modules
+            """
+            if not other:
+                raise ZeroDivisionError("Euclidean division by the zero element not defined")
+            P = self.parent()
+            other = P(other)
+            if self.valuation() >= other.valuation():
+                return P(self / other), P.zero()
+            else:
+                return P.zero(), self
+
+        def is_unit(self):
+            """
+            Return ``True`` if ``self`` is invertible.
+
+            EXAMPLES::
+
+                sage: # needs sage.rings.padics
+                sage: x = Zp(5)(50)
+                sage: x.is_unit()
+                False
+
+                sage: # needs sage.rings.padics
+                sage: x = Zp(7)(50)
+                sage: x.is_unit()
+                True
+            """
+            return self.valuation() == 0
+
+        def gcd(self, other):
+            """
+            Return the greatest common divisor of ``self`` and ``other``,
+            normalized so that it is a power of the distinguished
+            uniformizer.
+            """
+            from sage.rings.infinity import Infinity
+            val = min(self.valuation(), other.valuation())
+            if val is Infinity:
+                return self.parent()(0)
+            else:
+                return self.parent().uniformizer() ** val
+
+        def lcm(self, other):
+            """
+            Return the least common multiple of ``self`` and ``other``,
+            normalized so that it is a power of the distinguished
+            uniformizer.
+            """
+            from sage.rings.infinity import Infinity
+            val = max(self.valuation(), other.valuation())
+            if val is Infinity:
+                return self.parent()(0)
+            else:
+                return self.parent().uniformizer() ** val
+
+
+class DiscreteValuationFields(Category_singleton):
+    """
+    The category of discrete valuation fields.
+
+    EXAMPLES::
+
+        sage: Qp(7) in DiscreteValuationFields()                                        # needs sage.rings.padics
+        True
+        sage: TestSuite(DiscreteValuationFields()).run()
+    """
+
+    def super_categories(self):
+        """
+        EXAMPLES::
+
+            sage: DiscreteValuationFields().super_categories()
+            [Category of fields]
+        """
+        return [Fields()]
+
+    class ParentMethods:
+        @abstract_method
+        def uniformizer(self):
+            """
+            Return a uniformizer of this ring.
+
+            EXAMPLES::
+
+                sage: Qp(5).uniformizer()                                               # needs sage.rings.padics
+                5 + O(5^21)
+            """
+
+        @abstract_method
+        def residue_field(self):
+            """
+            Return the residue field of the ring of integers of
+            this discrete valuation field.
+
+            EXAMPLES::
+
+                sage: Qp(5).residue_field()                                             # needs sage.rings.padics
+                Finite Field of size 5
+
+                sage: K.<u> = LaurentSeriesRing(QQ)
+                sage: K.residue_field()
+                Rational Field
+            """
+
+        def _matrix_hessenbergize(self, H):
+            r"""
+            Replace `H` with a Hessenberg form of it.
+
+            EXAMPLES::
+
+                sage: # needs sage.modules
+                sage: R.<t> = PowerSeriesRing(GF(5))
+                sage: K = R.fraction_field()
+                sage: H = matrix(K, 4, 4, [(t^(i+j)).add_bigoh(10)
+                ....:                      for i in range(4) for j in range(4)])
+                sage: H
+                [  1 + O(t^10)   t + O(t^10) t^2 + O(t^10) t^3 + O(t^10)]
+                [  t + O(t^10) t^2 + O(t^10) t^3 + O(t^10) t^4 + O(t^10)]
+                [t^2 + O(t^10) t^3 + O(t^10) t^4 + O(t^10) t^5 + O(t^10)]
+                [t^3 + O(t^10) t^4 + O(t^10) t^5 + O(t^10) t^6 + O(t^10)]
+                sage: H.hessenbergize()
+                sage: H
+                [              1 + O(t^10)   t + t^3 + t^5 + O(t^10)             t^2 + O(t^10)             t^3 + O(t^10)]
+                [              t + O(t^10) t^2 + t^4 + t^6 + O(t^10)             t^3 + O(t^10)             t^4 + O(t^10)]
+                [                  O(t^10)                   O(t^10)                   O(t^10)                   O(t^10)]
+                [                  O(t^10)                   O(t^10)                   O(t^10)                   O(t^10)]
+
+            Another example over the `p`-adics::
+
+                sage: # needs sage.modules sage.rings.padics
+                sage: K = Qp(5, print_mode='digits', prec=5)
+                sage: H = matrix(K, 3, 3, range(9)); H
+                [        0  ...00001  ...00002]
+                [ ...00003  ...00004 ...000010]
+                [ ...00011  ...00012  ...00013]
+                sage: H.hessenbergize(); H
+                [        0  ...00010  ...00002]
+                [ ...00003  ...00024 ...000010]
+                [ ...00000  ...44440  ...44443]
+            """
+            from sage.matrix.matrix_cdv import hessenbergize_cdvf
+            hessenbergize_cdvf(H)
+
+    class ElementMethods:
+        @abstract_method
+        def valuation(self):
+            """
+            Return the valuation of this element.
+
+            EXAMPLES::
+
+                sage: # needs sage.rings.padics
+                sage: x = Qp(5)(50)
+                sage: x.valuation()
+                2
+            """