passagemath-categories 10.6.32__cp314-cp314t-musllinux_1_2_aarch64.whl

sage/categories/additive_monoids.py

@@ -0,0 +1,114 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Additive monoids
+"""
+#*****************************************************************************
+#  Copyright (C) 2013-2014 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_singleton
+from sage.categories.additive_semigroups import AdditiveSemigroups
+from sage.categories.homsets import HomsetsCategory
+
+
+class AdditiveMonoids(CategoryWithAxiom_singleton):
+    """
+    The category of additive monoids.
+
+    An *additive monoid* is a unital :class:`additive semigroup
+    <sage.categories.additive_semigroups.AdditiveSemigroups>`, that
+    is a set endowed with a binary operation `+` which is associative
+    and admits a zero (see :wikipedia:`Monoid`).
+
+    EXAMPLES::
+
+        sage: from sage.categories.additive_monoids import AdditiveMonoids
+        sage: C = AdditiveMonoids(); C
+        Category of additive monoids
+        sage: C.super_categories()
+        [Category of additive unital additive magmas, Category of additive semigroups]
+        sage: sorted(C.axioms())
+        ['AdditiveAssociative', 'AdditiveUnital']
+        sage: from sage.categories.additive_semigroups import AdditiveSemigroups
+        sage: C is AdditiveSemigroups().AdditiveUnital()
+        True
+
+    TESTS::
+
+        sage: C.Algebras(QQ).is_subcategory(AlgebrasWithBasis(QQ))
+        True
+        sage: TestSuite(C).run()
+    """
+    _base_category_class_and_axiom = (AdditiveSemigroups, "AdditiveUnital")
+
+    def __lean_init__(self):
+        return 'add_monoid'
+
+    AdditiveCommutative = LazyImport('sage.categories.commutative_additive_monoids', 'CommutativeAdditiveMonoids', at_startup=True)
+    AdditiveInverse = LazyImport('sage.categories.additive_groups', 'AdditiveGroups', at_startup=True)
+
+    class ParentMethods:
+        def sum(self, args):
+            r"""
+            Return the sum of the elements in ``args``, as an element
+            of ``self``.
+
+            INPUT:
+
+            - ``args`` -- list (or iterable) of elements of ``self``
+
+            EXAMPLES::
+
+                sage: S = CommutativeAdditiveMonoids().example()
+                sage: (a,b,c,d) = S.additive_semigroup_generators()
+                sage: S.sum((a,b,a,c,a,b))
+                3*a + 2*b + c
+                sage: S.sum(())
+                0
+                sage: S.sum(()).parent() == S
+                True
+
+            TESTS:
+
+            The following should be reasonably fast (0.5s each)::
+
+                sage: R.<x,y> = QQ[]
+                sage: ignore = R.sum(
+                ....:     QQ.random_element()*x^i*y^j for i in range(200) for j in range(200))
+                sage: ignore = R.sum([
+                ....:     QQ.random_element()*x^i*y^j for i in range(200) for j in range(200)])
+
+            Summing an empty iterator::
+
+                sage: R.sum(1 for i in range(0))
+                0
+            """
+            from sage.misc.misc_c import balanced_sum
+            return balanced_sum(args, self.zero(), 20)
+
+    class Homsets(HomsetsCategory):
+
+        def extra_super_categories(self):
+            """
+            Implement the fact that a homset between two monoids is
+            associative.
+
+            EXAMPLES::
+
+                sage: from sage.categories.additive_monoids import AdditiveMonoids
+                sage: AdditiveMonoids().Homsets().extra_super_categories()
+                [Category of additive semigroups]
+                sage: AdditiveMonoids().Homsets().super_categories()
+                [Category of homsets of additive unital additive magmas, Category of additive monoids]
+
+            .. TODO::
+
+                This could be deduced from
+                :meth:`AdditiveSemigroups.Homsets.extra_super_categories`.
+                See comment in :meth:`Objects.SubcategoryMethods.Homsets`.
+            """
+            return [AdditiveSemigroups()]

sage/categories/additive_semigroups.py

@@ -0,0 +1,184 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Additive semigroups
+"""
+# ****************************************************************************
+#  Copyright (C) 2013 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.misc.cachefunc import cached_method
+from sage.misc.lazy_import import LazyImport
+from sage.categories.category_with_axiom import CategoryWithAxiom_singleton
+from sage.categories.cartesian_product import CartesianProductsCategory
+from sage.categories.algebra_functor import AlgebrasCategory
+from sage.categories.homsets import HomsetsCategory
+from sage.categories.additive_magmas import AdditiveMagmas
+
+
+class AdditiveSemigroups(CategoryWithAxiom_singleton):
+    """
+    The category of additive semigroups.
+
+    An *additive semigroup* is an associative :class:`additive magma
+    <AdditiveMagmas>`, that is a set endowed with an operation `+`
+    which is associative.
+
+    EXAMPLES::
+
+        sage: from sage.categories.additive_semigroups import AdditiveSemigroups
+        sage: C = AdditiveSemigroups(); C
+        Category of additive semigroups
+        sage: C.super_categories()
+        [Category of additive magmas]
+        sage: C.all_super_categories()
+        [Category of additive semigroups,
+         Category of additive magmas,
+         Category of sets,
+         Category of sets with partial maps,
+         Category of objects]
+
+        sage: C.axioms()
+        frozenset({'AdditiveAssociative'})
+        sage: C is AdditiveMagmas().AdditiveAssociative()
+        True
+
+    TESTS::
+
+        sage: TestSuite(C).run()
+    """
+    _base_category_class_and_axiom = (AdditiveMagmas, "AdditiveAssociative")
+
+    def __lean_init__(self):
+        return 'add_semigroup'
+
+    AdditiveCommutative = LazyImport('sage.categories.commutative_additive_semigroups', 'CommutativeAdditiveSemigroups', at_startup=True)
+    AdditiveUnital = LazyImport('sage.categories.additive_monoids', 'AdditiveMonoids', at_startup=True)
+
+    class ParentMethods:
+        def _test_additive_associativity(self, **options):
+            r"""
+            Test associativity for (not necessarily all) elements of this
+            additive semigroup.
+
+            INPUT:
+
+            - ``options`` -- any keyword arguments accepted by :meth:`_tester`
+
+            EXAMPLES:
+
+            By default, this method tests only the elements returned by
+            ``self.some_elements()``::
+
+                sage: S = CommutativeAdditiveSemigroups().example()
+                sage: S._test_additive_associativity()
+
+            However, the elements tested can be customized with the
+            ``elements`` keyword argument::
+
+                sage: (a,b,c,d) = S.additive_semigroup_generators()
+                sage: S._test_additive_associativity(elements = (a, b+c, d))
+
+            See the documentation for :class:`TestSuite` for more information.
+            """
+            tester = self._tester(**options)
+            S = tester.some_elements()
+            from sage.misc.misc import some_tuples
+            for x, y, z in some_tuples(S, 3, tester._max_runs):
+                tester.assertEqual((x + y) + z, x + (y + z))
+
+    class Homsets(HomsetsCategory):
+
+        def extra_super_categories(self):
+            r"""
+            Implement the fact that a homset between two semigroups is a
+            semigroup.
+
+            EXAMPLES::
+
+                sage: from sage.categories.additive_semigroups import AdditiveSemigroups
+                sage: AdditiveSemigroups().Homsets().extra_super_categories()
+                [Category of additive semigroups]
+                sage: AdditiveSemigroups().Homsets().super_categories()
+                [Category of homsets of additive magmas, Category of additive semigroups]
+            """
+            return [AdditiveSemigroups()]
+
+    class CartesianProducts(CartesianProductsCategory):
+
+        def extra_super_categories(self):
+            """
+            Implement the fact that a Cartesian product of additive semigroups
+            is an additive semigroup.
+
+            EXAMPLES::
+
+                sage: from sage.categories.additive_semigroups import AdditiveSemigroups
+                sage: C = AdditiveSemigroups().CartesianProducts()
+                sage: C.extra_super_categories()
+                [Category of additive semigroups]
+                sage: C.axioms()
+                frozenset({'AdditiveAssociative'})
+            """
+            return [AdditiveSemigroups()]
+
+    class Algebras(AlgebrasCategory):
+
+        def extra_super_categories(self):
+            """
+            EXAMPLES::
+
+                sage: from sage.categories.additive_semigroups import AdditiveSemigroups
+                sage: AdditiveSemigroups().Algebras(QQ).extra_super_categories()
+                [Category of semigroups]
+                sage: CommutativeAdditiveSemigroups().Algebras(QQ).super_categories()
+                [Category of additive semigroup algebras over Rational Field,
+                 Category of additive commutative additive magma algebras over Rational Field]
+            """
+            from sage.categories.semigroups import Semigroups
+            return [Semigroups()]
+
+        class ParentMethods:
+
+            @cached_method
+            def algebra_generators(self):
+                r"""
+                Return the generators of this algebra, as per
+                :meth:`MagmaticAlgebras.ParentMethods.algebra_generators()
+                <.magmatic_algebras.MagmaticAlgebras.ParentMethods.algebra_generators>`.
+
+                They correspond to the generators of the additive semigroup.
+
+                EXAMPLES::
+
+                    sage: S = CommutativeAdditiveSemigroups().example(); S
+                    An example of a commutative semigroup:
+                     the free commutative semigroup generated by ('a', 'b', 'c', 'd')
+                    sage: A = S.algebra(QQ)                                             # needs sage.modules
+                    sage: A.algebra_generators()                                        # needs sage.modules
+                    Family (B[a], B[b], B[c], B[d])
+                """
+                return self.basis().keys().additive_semigroup_generators().map(self.monomial)
+
+            def product_on_basis(self, g1, g2):
+                r"""
+                Product, on basis elements, as per
+                :meth:`MagmaticAlgebras.WithBasis.ParentMethods.product_on_basis()
+                <sage.categories.magmatic_algebras.MagmaticAlgebras.WithBasis.ParentMethods.product_on_basis>`.
+
+                The product of two basis elements is induced by the
+                addition of the corresponding elements of the group.
+
+                EXAMPLES::
+
+                    sage: S = CommutativeAdditiveSemigroups().example(); S
+                    An example of a commutative semigroup:
+                     the free commutative semigroup generated by ('a', 'b', 'c', 'd')
+                    sage: A = S.algebra(QQ)                                             # needs sage.modules
+                    sage: a, b, c, d = A.algebra_generators()                           # needs sage.modules
+                    sage: b * d * c                                                     # needs sage.modules
+                    B[b + c + d]
+                """
+                return self.monomial(g1 + g2)

sage/categories/affine_weyl_groups.py

@@ -0,0 +1,238 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Affine Weyl groups
+"""
+# *****************************************************************************
+#  Copyright (C) 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.misc.cachefunc import cached_method
+from sage.categories.category_singleton import Category_singleton
+from sage.categories.weyl_groups import WeylGroups
+from sage.categories.finite_enumerated_sets import FiniteEnumeratedSets
+
+
+class AffineWeylGroups(Category_singleton):
+    """
+    The category of affine Weyl groups.
+
+    .. TODO:: add a description of this category
+
+    .. SEEALSO::
+
+        - :wikipedia:`Affine_weyl_group`
+        - :class:`WeylGroups`, :class:`WeylGroup`
+
+    EXAMPLES::
+
+        sage: C = AffineWeylGroups(); C
+        Category of affine Weyl groups
+        sage: C.super_categories()
+        [Category of infinite Weyl groups]
+
+        sage: C.example()
+        NotImplemented
+        sage: W = WeylGroup(["A", 4, 1]); W                                             # needs sage.combinat sage.groups
+        Weyl Group of type ['A', 4, 1] (as a matrix group acting on the root space)
+        sage: W.category()                                                              # needs sage.combinat sage.groups
+        Category of irreducible affine Weyl groups
+
+    TESTS::
+
+        sage: TestSuite(C).run()
+    """
+
+    def super_categories(self):
+        r"""
+        EXAMPLES::
+
+            sage: AffineWeylGroups().super_categories()
+            [Category of infinite Weyl groups]
+        """
+        return [WeylGroups().Infinite()]
+
+    def additional_structure(self):
+        r"""
+        Return ``None``.
+
+        Indeed, the category of affine Weyl groups defines no
+        additional structure: affine Weyl groups are a special class
+        of Weyl groups.
+
+        .. SEEALSO:: :meth:`Category.additional_structure`
+
+        .. TODO:: Should this category be a :class:`CategoryWithAxiom`?
+
+        EXAMPLES::
+
+            sage: AffineWeylGroups().additional_structure()
+        """
+        return None
+
+    def _repr_object_names(self):
+        """
+        Return the name of the objects of this category.
+
+        EXAMPLES::
+
+            sage: AffineWeylGroups()
+            Category of affine Weyl groups
+        """
+        return "affine Weyl groups"
+
+    class ParentMethods:
+
+        @cached_method
+        def special_node(self):
+            """
+            Return the distinguished special node of the underlying
+            Dynkin diagram.
+
+            EXAMPLES::
+
+                sage: W = WeylGroup(['A', 3, 1])                                        # needs sage.combinat sage.groups
+                sage: W.special_node()                                                  # needs sage.combinat sage.groups
+                0
+            """
+            return self.cartan_type().special_node()
+
+        def affine_grassmannian_elements_of_given_length(self, k):
+            """
+            Return the affine Grassmannian elements of length `k`.
+
+            This is returned as a finite enumerated set.
+
+            EXAMPLES::
+
+                sage: W = WeylGroup(['A', 3, 1])                                        # needs sage.combinat sage.groups
+                sage: [x.reduced_word()                                                 # needs sage.combinat sage.groups
+                ....:  for x in W.affine_grassmannian_elements_of_given_length(3)]
+                [[2, 1, 0], [3, 1, 0], [2, 3, 0]]
+
+            .. SEEALSO::
+
+                :meth:`AffineWeylGroups.ElementMethods.is_affine_grassmannian`
+            """
+            from sage.sets.recursively_enumerated_set import RecursivelyEnumeratedSet_forest
+
+            def select_length(pair):
+                u, length = pair
+                if length == k:
+                    return u
+
+            def succ(pair):
+                u, length = pair
+                for i in u.descents(positive=True, side='left'):
+                    u1 = u.apply_simple_reflection(i, "left")
+                    if (length < k and i == u1.first_descent(side='left') and
+                            u1.is_affine_grassmannian()):
+                        yield (u1, length + 1)
+
+            return RecursivelyEnumeratedSet_forest(((self.one(), 0),), succ, algorithm='breadth',
+                                                   category=FiniteEnumeratedSets(),
+                                                   post_process=select_length)
+
+    class ElementMethods:
+        def is_affine_grassmannian(self):
+            """
+            Test whether ``self`` is affine Grassmannian.
+
+            An element of an affine Weyl group is *affine Grassmannian*
+            if any of the following equivalent properties holds:
+
+            - all reduced words for ``self`` end with 0.
+            - ``self`` is the identity, or 0 is its single right descent.
+            - ``self`` is a minimal coset representative for W / cl W.
+
+            EXAMPLES::
+
+                sage: # needs sage.combinat sage.groups
+                sage: W = WeylGroup(['A', 3, 1])
+                sage: w = W.from_reduced_word([2,1,0])
+                sage: w.is_affine_grassmannian()
+                True
+                sage: w = W.from_reduced_word([2,0])
+                sage: w.is_affine_grassmannian()
+                False
+                sage: W.one().is_affine_grassmannian()
+                True
+            """
+            D = self.descents()
+            return (not D) or D == [self.parent().special_node()]
+
+        def affine_grassmannian_to_core(self):
+            r"""
+            Bijection between affine Grassmannian elements of type `A_k^{(1)}` and `(k+1)`-cores.
+
+            INPUT:
+
+            - ``self`` -- an affine Grassmannian element of some affine Weyl group of type `A_k^{(1)}`
+
+            Recall that an element `w` of an affine Weyl group is
+            affine Grassmannian if all its all reduced words end in 0, see :meth:`is_affine_grassmannian`.
+
+            OUTPUT:
+
+            - a `(k+1)`-core
+
+            .. SEEALSO:: :meth:`affine_grassmannian_to_partition`
+
+            EXAMPLES::
+
+                sage: # needs sage.combinat sage.groups
+                sage: W = WeylGroup(['A', 2, 1])
+                sage: w = W.from_reduced_word([0,2,1,0])
+                sage: la = w.affine_grassmannian_to_core(); la
+                [4, 2]
+                sage: type(la)
+                <class 'sage.combinat.core.Cores_length_with_category.element_class'>
+                sage: la.to_grassmannian() == w
+                True
+
+                sage: w = W.from_reduced_word([0,2,1])                                  # needs sage.combinat sage.groups
+                sage: w.affine_grassmannian_to_core()                                   # needs sage.combinat sage.groups
+                Traceback (most recent call last):
+                ...
+                ValueError: this only works on type 'A' affine Grassmannian elements
+            """
+            from sage.combinat.partition import Partition
+            from sage.combinat.core import Core
+            if not self.is_affine_grassmannian() or not self.parent().cartan_type().letter == 'A':
+                raise ValueError("this only works on type 'A' affine Grassmannian elements")
+            out = Partition([])
+            rword = self.reduced_word()
+            kp1 = self.parent().n
+            for i in range(len(rword)):
+                for c in out.outside_corners():
+                    if (c[1] - c[0]) % kp1 == rword[-i - 1]:
+                        out = out.add_cell(c[0], c[1])
+            return Core(out._list, kp1)
+
+        def affine_grassmannian_to_partition(self):
+            r"""
+            Bijection between affine Grassmannian elements of type `A_k^{(1)}`
+            and `k`-bounded partitions.
+
+            INPUT:
+
+            - ``self`` is affine Grassmannian element of the affine Weyl group of type `A_k^{(1)}` (i.e. all reduced words end in 0)
+
+            OUTPUT: `k`-bounded partition
+
+            .. SEEALSO:: :meth:`affine_grassmannian_to_core`
+
+            EXAMPLES::
+
+                sage: # needs sage.combinat sage.groups
+                sage: k = 2
+                sage: W = WeylGroup(['A', k, 1])
+                sage: w = W.from_reduced_word([0,2,1,0])
+                sage: la = w.affine_grassmannian_to_partition(); la
+                [2, 2]
+                sage: la.from_kbounded_to_grassmannian(k) == w
+                True
+            """
+            return self.affine_grassmannian_to_core().to_bounded_partition()

sage/categories/algebra_ideals.py

@@ -0,0 +1,95 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+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)
+#                  https://www.gnu.org/licenses/
+# *****************************************************************************
+
+from sage.categories.algebra_modules import AlgebraModules
+from sage.categories.algebras import Algebras
+from sage.categories.category_types import Category_ideal
+from sage.categories.rings import Rings
+
+
+class AlgebraIdeals(Category_ideal):
+    """
+    The category of two-sided ideals in a fixed algebra `A`.
+
+    EXAMPLES::
+
+        sage: AlgebraIdeals(QQ['a'])
+        Category of algebra ideals in Univariate Polynomial Ring in a over Rational Field
+
+    .. TODO::
+
+        - Add support for non commutative rings (this is currently not
+          supported by the subcategory :class:`AlgebraModules`).
+        - Make ``AlgebraIdeals(R)``, return ``CommutativeAlgebraIdeals(R)``
+          when ``R`` is commutative.
+        - If useful, implement ``AlgebraLeftIdeals`` and
+          ``AlgebraRightIdeals`` of which ``AlgebraIdeals``
+          would be a subcategory.
+    """
+    def __init__(self, A):
+        """
+        EXAMPLES::
+
+            sage: AlgebraIdeals(QQ['a'])
+            Category of algebra ideals in Univariate Polynomial Ring in a over Rational Field
+            sage: AlgebraIdeals(QQ)
+            Traceback (most recent call last):
+            ...
+            TypeError: A (=Rational Field) must be an algebra
+
+        TESTS::
+
+            sage: TestSuite(AlgebraIdeals(QQ['a'])).run()
+        """
+        try:
+            base_ring = A.base_ring()
+        except AttributeError:
+            raise TypeError(f"A (={A}) must be an algebra")
+        else:
+            if base_ring not in Rings() or A not in Algebras(base_ring.category()):
+                raise TypeError(f"A (={A}) must be an algebra")
+
+        Category_ideal.__init__(self, A)
+
+    def algebra(self):
+        """
+        EXAMPLES::
+
+            sage: AlgebraIdeals(QQ['x']).algebra()
+            Univariate Polynomial Ring in x over Rational Field
+        """
+        return self.ambient()
+
+    def super_categories(self):
+        """
+        The category of algebra modules should be a super category of this category.
+
+        However, since algebra modules are currently only available over commutative rings,
+        we have to omit it if our ring is non-commutative.
+
+        EXAMPLES::
+
+            sage: AlgebraIdeals(QQ['x']).super_categories()
+            [Category of algebra modules
+              over Univariate Polynomial Ring in x over Rational Field]
+            sage: C = AlgebraIdeals(FreeAlgebra(QQ, 2, 'a,b'))                          # needs sage.combinat sage.modules
+            sage: C.super_categories()                                                  # needs sage.combinat sage.modules
+            []
+        """
+        R = self.algebra()
+        try:
+            if R.is_commutative():
+                return [AlgebraModules(R)]
+        except (AttributeError, NotImplementedError):
+            pass
+        return []