passagemath-categories 10.6.32__cp314-cp314t-musllinux_1_2_aarch64.whl

sage/categories/distributive_magmas_and_additive_magmas.py

@@ -0,0 +1,100 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Distributive Magmas and Additive Magmas
+"""
+# ****************************************************************************
+#  Copyright (C) 2010 Nicolas Borie <nicolas.borie@math.u-psud.fr>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#                  https://www.gnu.org/licenses/
+# *****************************************************************************
+
+from sage.misc.lazy_import import LazyImport
+from sage.categories.category_with_axiom import CategoryWithAxiom
+from sage.categories.cartesian_product import CartesianProductsCategory
+
+
+class DistributiveMagmasAndAdditiveMagmas(CategoryWithAxiom):
+    """
+    The category of sets `(S, +, *)` with `*` distributing on `+`.
+
+    This is similar to a ring, but `+` and `*` are only required to be
+    (additive) magmas.
+
+    EXAMPLES::
+
+        sage: from sage.categories.distributive_magmas_and_additive_magmas import DistributiveMagmasAndAdditiveMagmas
+        sage: C = DistributiveMagmasAndAdditiveMagmas(); C
+        Category of distributive magmas and additive magmas
+        sage: C.super_categories()
+        [Category of magmas and additive magmas]
+
+    TESTS::
+
+        sage: from sage.categories.magmas_and_additive_magmas import MagmasAndAdditiveMagmas
+        sage: C is MagmasAndAdditiveMagmas().Distributive()
+        True
+        sage: C is (Magmas() & AdditiveMagmas()).Distributive()
+        True
+        sage: TestSuite(C).run()
+    """
+
+    class AdditiveAssociative(CategoryWithAxiom):
+        class AdditiveCommutative(CategoryWithAxiom):
+            class AdditiveUnital(CategoryWithAxiom):
+                class Associative(CategoryWithAxiom):
+                    AdditiveInverse = LazyImport('sage.categories.rngs', 'Rngs', at_startup=True)
+                    Unital = LazyImport('sage.categories.semirings', 'Semirings', at_startup=True)
+
+    class ParentMethods:
+
+        def _test_distributivity(self, **options):
+            r"""
+            Test the distributivity of `*` on `+` on (not necessarily
+            all) elements of this set.
+
+            INPUT:
+
+            - ``options`` -- any keyword arguments accepted by :meth:`_tester`
+
+            EXAMPLES:
+
+            By default, this method runs the tests only on the
+            elements returned by ``self.some_elements()``::
+
+                sage: NN.some_elements()
+                [0, 1, 3, 42]
+                sage: NN._test_distributivity()
+
+            However, the elements tested can be customized with the
+            ``elements`` keyword argument::
+
+                sage: CC._test_distributivity(elements=[CC(0),CC(1),CC(3),CC(I)])       # needs sage.symbolic
+
+            See the documentation for :class:`TestSuite` for more information.
+            """
+            tester = self._tester(**options)
+            tester.some_elements()
+            from sage.misc.misc import some_tuples
+            for x, y, z in some_tuples(tester.some_elements(), 3, tester._max_runs):
+                # left distributivity
+                tester.assertEqual(x * (y + z), (x * y) + (x * z))
+                # right distributivity
+                tester.assertEqual((x + y) * z, (x * z) + (y * z))
+
+    class CartesianProducts(CartesianProductsCategory):
+        def extra_super_categories(self):
+            """
+            Implement the fact that a Cartesian product of magmas distributing
+            over additive magmas is a magma distributing over an
+            additive magma.
+
+            EXAMPLES::
+
+                sage: C = (Magmas() & AdditiveMagmas()).Distributive().CartesianProducts()
+                sage: C.extra_super_categories()
+                [Category of distributive magmas and additive magmas]
+                sage: C.axioms()
+                frozenset({'Distributive'})
+            """
+            return [DistributiveMagmasAndAdditiveMagmas()]

sage/categories/division_rings.py

@@ -0,0 +1,114 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Division rings
+"""
+#*****************************************************************************
+#  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.misc.lazy_import import LazyImport
+from sage.categories.category_with_axiom import CategoryWithAxiom
+from sage.categories.rings import Rings
+
+
+class DivisionRings(CategoryWithAxiom):
+    """
+    The category of division rings.
+
+    A division ring (or skew field) is a not necessarily commutative
+    ring where all nonzero elements have multiplicative inverses
+
+    EXAMPLES::
+
+      sage: DivisionRings()
+      Category of division rings
+      sage: DivisionRings().super_categories()
+      [Category of domains]
+
+    TESTS::
+
+        sage: TestSuite(DivisionRings()).run()
+    """
+
+    # This information could be deduced from the name. It's set here
+    # just to get ``division rings`` for the name of the objects of
+    # this category and not ``no zero divisors division rings``. See
+    # :meth:`Category_with_axiom._repr_object_names` and the ``named``
+    # option of :meth:`Category_with_axiom._without_axioms
+    _base_category_class_and_axiom = (Rings, "Division")
+
+    def extra_super_categories(self):
+        r"""
+        Return the :class:`Domains` category.
+
+        This method specifies that a division ring has no zero
+        divisors, i.e. is a domain.
+
+        .. SEEALSO::
+
+            The :ref:`axioms-deduction-rules` section in the
+            documentation of axioms
+
+        EXAMPLES::
+
+            sage: DivisionRings().extra_super_categories()
+            (Category of domains,)
+            sage: "NoZeroDivisors" in DivisionRings().axioms()
+            True
+        """
+        return (Rings().NoZeroDivisors(),)
+
+    Commutative = LazyImport('sage.categories.fields', 'Fields', at_startup=True)
+
+    def Finite_extra_super_categories(self):
+        r"""
+        Return extraneous super categories for ``DivisionRings().Finite()``.
+
+        EXAMPLES:
+
+        Any field is a division ring::
+
+            sage: Fields().is_subcategory(DivisionRings())
+            True
+
+        This methods specifies that, by Weddeburn theorem, the
+        reciprocal holds in the finite case: a finite division ring is
+        commutative and thus a field::
+
+            sage: DivisionRings().Finite_extra_super_categories()
+            (Category of commutative magmas,)
+            sage: DivisionRings().Finite()
+            Category of finite enumerated fields
+
+        .. WARNING::
+
+            This is not implemented in
+            ``DivisionRings.Finite.extra_super_categories`` because
+            the categories of finite division rings and of finite
+            fields coincide. See the section
+            :ref:`axioms-deduction-rules` in the documentation of
+            axioms.
+
+        TESTS::
+
+            sage: DivisionRings().Finite() is Fields().Finite()
+            True
+
+        This works also for subcategories::
+
+            sage: class Foo(Category):
+            ....:     def super_categories(self): return [DivisionRings()]
+            sage: Foo().Finite().is_subcategory(Fields())
+            True
+        """
+        from sage.categories.magmas import Magmas
+        return (Magmas().Commutative(),)
+
+    class ParentMethods:
+        pass
+
+    class ElementMethods:
+        pass

sage/categories/domains.py

@@ -0,0 +1,95 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Domains
+"""
+#*****************************************************************************
+#  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)
+#                  http://www.gnu.org/licenses/
+#******************************************************************************
+
+from sage.misc.lazy_import import LazyImport
+from sage.categories.category_with_axiom import CategoryWithAxiom
+from sage.categories.rings import Rings
+
+
+class Domains(CategoryWithAxiom):
+    """
+    The category of domains.
+
+    A domain (or non-commutative integral domain), is a ring, not
+    necessarily commutative, with no nonzero zero divisors.
+
+    EXAMPLES::
+
+        sage: C = Domains(); C
+        Category of domains
+        sage: C.super_categories()
+        [Category of rings]
+        sage: C is Rings().NoZeroDivisors()
+        True
+
+    TESTS::
+
+        sage: TestSuite(C).run()
+    """
+
+    _base_category_class_and_axiom = (Rings, "NoZeroDivisors")
+
+    def super_categories(self):
+        """
+        EXAMPLES::
+
+            sage: Domains().super_categories()
+            [Category of rings]
+        """
+        return [Rings()]
+
+    Commutative = LazyImport('sage.categories.integral_domains', 'IntegralDomains', at_startup=True)
+
+    class ParentMethods:
+        def _test_zero_divisors(self, **options):
+            """
+            Check to see that there are no zero divisors.
+
+            .. NOTE::
+
+                In rings whose elements can not be represented exactly, there
+                may be zero divisors in practice, even though these rings do
+                not have them in theory. For such inexact rings, these tests
+                are not performed::
+
+                    sage: # needs sage.rings.padics
+                    sage: R = ZpFM(5); R
+                    5-adic Ring of fixed modulus 5^20
+                    sage: R.is_exact()
+                    False
+                    sage: a = R(5^19)
+                    sage: a.is_zero()
+                    False
+                    sage: (a * a).is_zero()
+                    True
+                    sage: R._test_zero_divisors()
+
+            EXAMPLES::
+
+                sage: ZZ._test_zero_divisors()
+                sage: ZpFM(5)._test_zero_divisors()                                     # needs sage.rings.padics
+            """
+            if not self.is_exact():
+                return # Can't check on inexact rings
+
+            tester = self._tester(**options)
+
+            # Filter out zero
+            S = [s for s in tester.some_elements() if not s.is_zero()]
+
+            from sage.misc.misc import some_tuples
+            for a,b in some_tuples(S, 2, tester._max_runs):
+                p = a * b
+                tester.assertFalse(p.is_zero())
+
+    class ElementMethods:
+        pass