passagemath-categories 10.6.32__cp314-cp314t-musllinux_1_2_aarch64.whl

sage/categories/semirings.py

@@ -0,0 +1,71 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Semirings
+"""
+# ****************************************************************************
+#  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.categories.category_with_axiom import CategoryWithAxiom
+from sage.categories.magmas_and_additive_magmas import MagmasAndAdditiveMagmas
+
+
+class Semirings(CategoryWithAxiom):
+    """
+    The category of semirings.
+
+    A semiring `(S, +, *)` is similar to a ring, but without the
+    requirement that each element must have an additive inverse. In
+    other words, it is a combination of a commutative additive monoid
+    `(S, +)` and a multiplicative monoid `(S, *)`, where `*` distributes
+    over `+`.
+
+    .. SEEALSO::
+
+        :wikipedia:`Semiring`
+
+    EXAMPLES::
+
+        sage: Semirings()
+        Category of semirings
+        sage: Semirings().super_categories()
+        [Category of associative additive commutative additive
+         associative additive unital distributive magmas and additive magmas,
+         Category of monoids]
+
+        sage: sorted(Semirings().axioms())
+        ['AdditiveAssociative', 'AdditiveCommutative', 'AdditiveUnital',
+         'Associative', 'Distributive', 'Unital']
+
+        sage: Semirings() is (CommutativeAdditiveMonoids() & Monoids()).Distributive()
+        True
+
+        sage: Semirings().AdditiveInverse()
+        Category of rings
+
+
+    TESTS::
+
+        sage: TestSuite(Semirings()).run()
+        sage: Semirings().example()
+        An example of a semiring: the ternary-logic semiring
+    """
+    _base_category_class_and_axiom = (MagmasAndAdditiveMagmas.Distributive.AdditiveAssociative.AdditiveCommutative.AdditiveUnital.Associative, "Unital")
+
+    def __lean_init__(self):
+        r"""
+        Return the category as Lean mathlib input for a typeclass.
+
+        EXAMPLES::
+
+            sage: from sage.categories.semirings import Semirings
+            sage: C = Semirings(); C
+            Category of semirings
+            sage: C.__lean_init__()
+            'semiring'
+        """
+        # defined in algebra.ring.basic
+        return 'semiring'

sage/categories/semisimple_algebras.py

@@ -0,0 +1,114 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Semisimple Algebras
+"""
+#*****************************************************************************
+#  Copyright (C) 2011-2015 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.algebras import Algebras
+from sage.categories.category_types import Category_over_base_ring
+from sage.categories.category_with_axiom import CategoryWithAxiom_over_base_ring
+from sage.misc.bindable_class import BoundClass
+from sage.misc.cachefunc import cached_method
+from sage.misc.lazy_import import LazyImport
+
+
+class SemisimpleAlgebras(Category_over_base_ring):
+    """
+    The category of semisimple algebras over a given base ring.
+
+    EXAMPLES::
+
+        sage: from sage.categories.semisimple_algebras import SemisimpleAlgebras
+        sage: C = SemisimpleAlgebras(QQ); C
+        Category of semisimple algebras over Rational Field
+
+    This category is best constructed as::
+
+        sage: D = Algebras(QQ).Semisimple(); D
+        Category of semisimple algebras over Rational Field
+        sage: D is C
+        True
+
+        sage: C.super_categories()
+        [Category of algebras over Rational Field]
+
+    Typically, finite group algebras are semisimple::
+
+        sage: DihedralGroup(5).algebra(QQ) in SemisimpleAlgebras                        # needs sage.groups sage.modules
+        True
+
+    Unless the characteristic of the field divides the order of the group::
+
+        sage: DihedralGroup(5).algebra(IntegerModRing(5)) in SemisimpleAlgebras         # needs sage.groups sage.modules
+        False
+
+        sage: DihedralGroup(5).algebra(IntegerModRing(7)) in SemisimpleAlgebras         # needs sage.groups sage.modules
+        True
+
+    .. SEEALSO:: :wikipedia:`Semisimple_algebra`
+
+    TESTS::
+
+        sage: TestSuite(C).run()
+    """
+    @staticmethod
+    def __classget__(cls, base_category, base_category_class):
+        """
+        Implement the shorthand ``Algebras(K).Semisimple()`` for ``SemisimpleAlgebras(K)``.
+
+        This magic mimics the syntax of axioms for a smooth transition
+        if ``Semisimple`` becomes one.
+
+        EXAMPLES::
+
+            sage: Algebras(QQ).Semisimple()
+            Category of semisimple algebras over Rational Field
+            sage: Algebras.Semisimple
+            <class 'sage.categories.semisimple_algebras.SemisimpleAlgebras'>
+        """
+        if base_category is None:
+            return cls
+        return BoundClass(cls, base_category.base_ring())
+
+    @cached_method
+    def super_categories(self):
+        """
+        EXAMPLES::
+
+            sage: Algebras(QQ).Semisimple().super_categories()
+            [Category of algebras over Rational Field]
+        """
+        R = self.base_ring()
+        return [Algebras(R)]
+
+    class ParentMethods:
+
+        def radical_basis(self, **keywords):
+            r"""
+            Return a basis of the Jacobson radical of this algebra.
+
+            - ``keywords`` -- for compatibility; ignored
+
+            OUTPUT: the empty list since this algebra is semisimple
+
+            EXAMPLES::
+
+                sage: A = SymmetricGroup(4).algebra(QQ)                                 # needs sage.combinat sage.groups
+                sage: A.radical_basis()                                                 # needs sage.combinat sage.groups
+                ()
+
+            TESTS::
+
+                sage: A.radical_basis.__module__                                        # needs sage.combinat sage.groups
+                'sage.categories.finite_dimensional_semisimple_algebras_with_basis'
+            """
+            return ()
+
+    class FiniteDimensional(CategoryWithAxiom_over_base_ring):
+
+        WithBasis = LazyImport('sage.categories.finite_dimensional_semisimple_algebras_with_basis', 'FiniteDimensionalSemisimpleAlgebrasWithBasis')

sage/categories/sets_with_grading.py

@@ -0,0 +1,235 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Sets With a Grading
+"""
+# ****************************************************************************
+#  Copyright (C) 2010-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_types import Category
+from sage.categories.enumerated_sets import EnumeratedSets
+from sage.categories.sets_cat import Sets
+from sage.misc.abstract_method import abstract_method
+from sage.misc.cachefunc import cached_method
+
+
+class SetsWithGrading(Category):
+    r"""
+    The category of sets with a grading.
+
+    A *set with a grading* is a set `S` equipped with a
+    grading by some other set `I` (by default the set `\NN` of the
+    nonnegative integers):
+
+    .. MATH::
+
+         S = \biguplus_{i\in I} S_i
+
+    where the *graded components* `S_i` are (usually finite)
+    sets. The *grading* function maps each element `s` of
+    `S` to its *grade* `i`, so that `s\in S_i`.
+
+    From implementation point of view, if the graded set is enumerated then
+    each graded component should be enumerated (there is a check in the method
+    :meth:`~SetsWithGrading.ParentMethods._test_graded_components`). The
+    contrary needs not be true.
+
+    To implement this category, a parent must either implement
+    :meth:`~SetsWithGrading.ParentMethods.graded_component()` or
+    :meth:`~SetsWithGrading.ParentMethods.subset()`. If only
+    :meth:`~SetsWithGrading.ParentMethods.subset()` is implemented, the first
+    argument must be the grading for compatibility with
+    :meth:`~SetsWithGrading.ParentMethods.graded_component()`. Additionally
+    either the parent must implement
+    :meth:`~SetsWithGrading.ParentMethods.grading()` or its elements must
+    implement a method ``grade()``. See the example
+    :class:`sage.categories.examples.sets_with_grading.NonNegativeIntegers`.
+
+    Finally, if the graded set is enumerated (see
+    :class:`~sage.categories.enumerated_sets.EnumeratedSets`) then each graded
+    component should be enumerated. The contrary needs not be true.
+
+    EXAMPLES:
+
+    A typical example of a set with a grading is the set of nonnegative
+    integers graded by themselves::
+
+        sage: N = SetsWithGrading().example(); N
+        Non negative integers
+        sage: N.category()
+        Category of facade infinite sets with grading
+        sage: N.grading_set()
+        Non negative integers
+
+    The *grading function* is given by ``N.grading``::
+
+        sage: N.grading(4)
+        4
+
+    The graded component `N_i` is the set with one element `i`::
+
+        sage: N.graded_component(grade=5)
+        {5}
+        sage: N.graded_component(grade=42)
+        {42}
+
+    Here are some information about this category::
+
+        sage: SetsWithGrading()
+        Category of sets with grading
+        sage: SetsWithGrading().super_categories()
+        [Category of sets]
+        sage: SetsWithGrading().all_super_categories()
+        [Category of sets with grading,
+         Category of sets,
+         Category of sets with partial maps,
+         Category of objects]
+
+    .. TODO::
+
+        - This should be moved to ``Sets().WithGrading()``.
+        - Should the grading set be a parameter for this category?
+        - Does the enumeration need to be compatible with the grading? Be
+          careful that the fact that graded components are allowed to be finite
+          or infinite make the answer complicated.
+
+    TESTS::
+
+        sage: C = SetsWithGrading()
+        sage: TestSuite(C).run()
+    """
+
+    @cached_method
+    def super_categories(self):
+        """
+        EXAMPLES::
+
+            sage: SetsWithGrading().super_categories()
+            [Category of sets]
+        """
+        return [Sets()]
+
+    class ParentMethods:
+
+        def _test_graded_components(self, **options):
+            r"""
+            Test that some graded components of ``self`` are parent with
+            initialized category and that the parent has a properly implemented
+            ``grading()`` method.
+
+            EXAMPLES::
+
+                sage: SetsWithGrading().example()._test_graded_components()
+            """
+            tester = self._tester(**options)
+            for grade in self.grading_set().some_elements():
+                G = self.graded_component(grade)
+                if self in EnumeratedSets():
+                    tester.assertIn(G, EnumeratedSets())
+                else:
+                    tester.assertIn(G, Sets())
+                for elt in G.some_elements():
+                    tester.assertEqual(self.grading(elt), grade)
+
+        def grading_set(self):
+            """
+            Return the set ``self`` is graded by. By default, this is
+            the set of nonnegative integers.
+
+            EXAMPLES::
+
+                sage: SetsWithGrading().example().grading_set()
+                Non negative integers
+            """
+            from sage.sets.non_negative_integers import NonNegativeIntegers
+            return NonNegativeIntegers()
+
+        # TODO:
+        #  - Should this method be in EnumeratedSets? With a default implementation
+        #    a la ``filter``?
+        #  - Do we want to enforce implementing subset rather than graded_component?
+        @abstract_method(optional=True)
+        def subset(self, *args, **options):
+            """
+            Return the subset of ``self`` described by the given parameters.
+
+            .. SEEALSO::
+
+                -:meth:`graded_component()`
+
+            EXAMPLES::
+
+                sage: W = WeightedIntegerVectors([3,2,1]); W
+                Integer vectors weighted by [3, 2, 1]
+                sage: W.subset(4)
+                Integer vectors of 4 weighted by [3, 2, 1]
+            """
+
+        def graded_component(self, grade):
+            """
+            Return the graded component of ``self`` with grade ``grade``.
+
+            The default implementation just calls the method :meth:`subset()`
+            with the first argument ``grade``.
+
+            EXAMPLES::
+
+                sage: N = SetsWithGrading().example(); N
+                Non negative integers
+                sage: N.graded_component(3)
+                {3}
+            """
+            return self.subset(grade)
+
+        def grading(self, elt):
+            """
+            Return the grading of the element ``elt`` of ``self``.
+
+            This default implementation calls ``elt.grade()``.
+
+            EXAMPLES::
+
+                sage: N = SetsWithGrading().example(); N
+                Non negative integers
+                sage: N.grading(4)
+                4
+            """
+            return elt.grade()
+
+        def generating_series(self):
+            """
+            Default implementation for generating series.
+
+            OUTPUT: a series, indexed by the grading set
+
+            EXAMPLES::
+
+                sage: N = SetsWithGrading().example(); N
+                Non negative integers
+                sage: N.generating_series()
+                1/(-z + 1)
+
+                sage: Permutations().generating_series()                                # needs sage.combinat
+                1 + z + 2*z^2 + 6*z^3 + 24*z^4 + 120*z^5 + 720*z^6 + O(z^7)
+
+             .. TODO::
+
+                 - Very likely, this should always return a lazy power series.
+            """
+            from sage.rings.integer_ring import ZZ
+            from sage.rings.lazy_series_ring import LazyPowerSeriesRing
+            from sage.sets.non_negative_integers import NonNegativeIntegers
+            if isinstance(self.grading_set(), NonNegativeIntegers):
+                R = LazyPowerSeriesRing(ZZ, names='z')
+                return R(lambda n: self.graded_component(n).cardinality())
+            raise NotImplementedError
+
+        # TODO:
+        #   * asymptotic behavior: we need an object for asymptotic behavior and
+        #   a default name for the method that should be here. Such method will
+        #   have two goals (and perhaps need two implementations): give a
+        #   theorem on asymptotic and be a tool to determine a strategy for
+        #   algorithms.

sage/categories/shephard_groups.py

@@ -0,0 +1,43 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Shephard Groups
+"""
+#*****************************************************************************
+#  Copyright (C) 2016 Travis Scrimshaw <tscrim at ucdavis.edu>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 2 of the License, or
+# (at your option) any later version.
+#                  http://www.gnu.org/licenses/
+#*****************************************************************************
+
+from sage.categories.category_singleton import Category_singleton
+from sage.categories.generalized_coxeter_groups import GeneralizedCoxeterGroups
+from sage.misc.cachefunc import cached_method
+
+
+class ShephardGroups(Category_singleton):
+    r"""
+    The category of Shephard groups.
+
+    EXAMPLES::
+
+        sage: from sage.categories.shephard_groups import ShephardGroups
+        sage: C = ShephardGroups(); C
+        Category of shephard groups
+
+    TESTS::
+
+        sage: TestSuite(C).run()
+    """
+    @cached_method
+    def super_categories(self):
+        """
+        EXAMPLES::
+
+            sage: from sage.categories.shephard_groups import ShephardGroups
+            sage: ShephardGroups().super_categories()
+            [Category of finite generalized Coxeter groups]
+        """
+        return [GeneralizedCoxeterGroups().Finite()]

sage/categories/signed_tensor.py

@@ -0,0 +1,120 @@
+# sage_setup: distribution = sagemath-categories
+"""
+Signed Tensor Product Functorial Construction
+
+AUTHORS:
+
+- Travis Scrimshaw (2019-07): initial version
+"""
+# ****************************************************************************
+#  Copyright (C) 2019 Travis Scrimshaw <tcscrims at gamil.com>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#                  http://www.gnu.org/licenses/
+# ****************************************************************************
+
+from sage.categories.covariant_functorial_construction import CovariantFunctorialConstruction, CovariantConstructionCategory
+from sage.typeset.unicode_characters import unicode_otimes
+
+
+class SignedTensorProductFunctor(CovariantFunctorialConstruction):
+    """
+    A singleton class for the signed tensor functor.
+
+    This functor takes a collection of graded algebras (possibly with
+    basis) and constructs the signed tensor product of those algebras.
+    If this algebra is in a subcategory, say that of
+    ``Algebras(QQ).Graded()``, it is automatically endowed with
+    its natural algebra structure, thanks to the category
+    ``Algebras(QQ).Graded().SignedTensorProducts()`` of signed tensor
+    products of graded algebras. For elements, it constructs the natural
+    tensor product element in the corresponding tensor product of their
+    parents.
+
+    The signed tensor functor is covariant: if ``A`` is a subcategory
+    of ``B``, then ``A.SignedTensorProducts()`` is a subcategory of
+    ``B.SignedTensorProducts()`` (see also
+    :class:`~sage.categories.covariant_functorial_construction.CovariantFunctorialConstruction`). Hence,
+    the role of ``Algebras(QQ).Graded().SignedTensorProducts()`` is solely
+    to provide mathematical information and algorithms which are relevant to
+    signed tensor product of graded algebras.
+
+    Those are implemented in the nested class
+    :class:`~sage.categories.algebras.Algebras.SignedTensorProducts`
+    of ``Algebras(QQ).Graded()``. This nested class is itself a subclass of
+    :class:`~sage.categories.signed_tensor.SignedTensorProductsCategory`.
+
+    EXAMPLES::
+
+        sage: tensor_signed
+        The signed tensor functorial construction
+
+    TESTS::
+
+        sage: TestSuite(tensor_signed).run()
+    """
+    _functor_name = "tensor"
+    _functor_category = "SignedTensorProducts"
+    symbol = " # "
+    unicode_symbol = f" {unicode_otimes} "
+
+    def _repr_(self):
+        """
+        EXAMPLES::
+
+            sage: tensor_signed
+            The signed tensor functorial construction
+        """
+        # We need this to distinguish it from tensor(), but we want
+        #   it to have the same _functor_name (which is used in the
+        #   default _repr_
+        return "The signed tensor functorial construction"
+
+
+tensor_signed = SignedTensorProductFunctor()
+
+
+class SignedTensorProductsCategory(CovariantConstructionCategory):
+    r"""
+    An abstract base class for all SignedTensorProducts's categories.
+
+    TESTS::
+
+        sage: C = AlgebrasWithBasis(QQ).Graded().SignedTensorProducts()
+        sage: C
+        Category of signed tensor products of graded algebras with basis over Rational Field
+        sage: C.base_category()
+        Category of graded algebras with basis over Rational Field
+        sage: latex(C)
+        \mathbf{SignedTensorProducts}(\mathbf{GradedAlgebrasWithBasis}(\mathbf{AlgebrasWithBasis}_{\Bold{Q}}))
+        sage: TestSuite(C).run()
+    """
+    _functor_category = "SignedTensorProducts"
+
+    def SignedTensorProducts(self):
+        r"""
+        Return the category of signed tensor products of objects of ``self``.
+
+        By associativity of signed tensor products, this is ``self`` (a tensor
+        product of signed tensor products of `Cat`'s is a tensor product of
+        `Cat`'s with the same twisting morphism)
+
+        EXAMPLES::
+
+            sage: AlgebrasWithBasis(QQ).Graded().SignedTensorProducts().SignedTensorProducts()
+            Category of signed tensor products of graded algebras with basis
+             over Rational Field
+        """
+        return self
+
+    def base(self):
+        """
+        The base of a signed tensor product is the base (usually a ring)
+        of the underlying category.
+
+        EXAMPLES::
+
+            sage: AlgebrasWithBasis(ZZ).Graded().SignedTensorProducts().base()
+            Integer Ring
+        """
+        return self.base_category().base()