passagemath-categories 10.6.32__cp314-cp314t-musllinux_1_2_aarch64.whl

sage/categories/finite_semigroups.py

@@ -0,0 +1,136 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Finite semigroups
+"""
+# ****************************************************************************
+#  Copyright (C) 2008      Teresa Gomez-Diaz (CNRS) <Teresa.Gomez-Diaz@univ-mlv.fr>
+#                2008-2009 Florent Hivert <florent.hivert at univ-rouen.fr>
+#                2008-2014 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.call import attrcall
+from sage.categories.category_with_axiom import CategoryWithAxiom
+
+
+class FiniteSemigroups(CategoryWithAxiom):
+    r"""
+    The category of finite (multiplicative) semigroups.
+
+    A finite semigroup is a :class:`finite set <FiniteSets>` endowed
+    with an associative binary operation `*`.
+
+    .. WARNING::
+
+        Finite semigroups in Sage used to be automatically endowed
+        with an :class:`enumerated set <EnumeratedSets>` structure;
+        the default enumeration is then obtained by iteratively
+        multiplying the semigroup generators. This forced any finite
+        semigroup to either implement an enumeration, or provide
+        semigroup generators; this was often inconvenient.
+
+        Instead, finite semigroups that provide a distinguished finite
+        set of generators with :meth:`semigroup_generators` should now
+        explicitly declare themselves in the category of
+        :class:`finitely generated semigroups
+        <Semigroups.FinitelyGeneratedSemigroup>`::
+
+            sage: Semigroups().FinitelyGenerated()
+            Category of finitely generated semigroups
+
+        This is a backward incompatible change.
+
+    EXAMPLES::
+
+        sage: C = FiniteSemigroups(); C
+        Category of finite semigroups
+        sage: C.super_categories()
+        [Category of semigroups, Category of finite sets]
+        sage: sorted(C.axioms())
+        ['Associative', 'Finite']
+        sage: C.example()
+        An example of a finite semigroup:
+         the left regular band generated by ('a', 'b', 'c', 'd')
+
+    TESTS::
+
+        sage: TestSuite(C).run()
+    """
+
+    class ParentMethods:
+        def idempotents(self):
+            r"""
+            Return the idempotents of the semigroup.
+
+            EXAMPLES::
+
+                sage: S = FiniteSemigroups().example(alphabet=('x','y'))
+                sage: sorted(S.idempotents())
+                ['x', 'xy', 'y', 'yx']
+            """
+            return [x for x in self if x.is_idempotent()]
+
+        @cached_method
+        def j_classes(self):
+            r"""
+            Return the `J`-classes of the semigroup.
+
+            Two elements `u` and `v` of a monoid are in the same `J`-class
+            if `u` divides `v` and `v` divides `u`.
+
+            OUTPUT:
+
+             All the `J`-classes of self, as a list of lists.
+
+            EXAMPLES::
+
+                sage: S = FiniteSemigroups().example(alphabet=('a','b', 'c'))
+                sage: sorted(map(sorted, S.j_classes()))                                # needs sage.graphs
+                [['a'], ['ab', 'ba'], ['abc', 'acb', 'bac', 'bca', 'cab', 'cba'],
+                 ['ac', 'ca'], ['b'], ['bc', 'cb'], ['c']]
+            """
+            return self.cayley_graph(side='twosided', simple=True).strongly_connected_components()
+
+        @cached_method
+        def j_classes_of_idempotents(self):
+            r"""
+            Return all the idempotents of self, grouped by J-class.
+
+            OUTPUT: list of lists
+
+            EXAMPLES::
+
+                sage: S = FiniteSemigroups().example(alphabet=('a','b', 'c'))
+                sage: sorted(map(sorted, S.j_classes_of_idempotents()))                 # needs sage.graphs
+                [['a'], ['ab', 'ba'], ['abc', 'acb', 'bac', 'bca', 'cab', 'cba'],
+                 ['ac', 'ca'], ['b'], ['bc', 'cb'], ['c']]
+            """
+            return [l for l in ([x for x in cl if attrcall('is_idempotent')(x)] for cl in self.j_classes()) if len(l) > 0]
+
+        @cached_method
+        def j_transversal_of_idempotents(self):
+            r"""
+            Return a list of one idempotent per regular J-class.
+
+            EXAMPLES::
+
+                sage: S = FiniteSemigroups().example(alphabet=('a','b', 'c'))
+
+            The chosen elements depend on the order of each `J`-class,
+            and that order is random when using Python 3. ::
+
+                sage: sorted(S.j_transversal_of_idempotents())  # random                # needs sage.graphs
+                ['a', 'ab', 'abc', 'ac', 'b', 'c', 'cb']
+            """
+            def first_idempotent(l):
+                for x in l:
+                    if x.is_idempotent():
+                        return x
+                return None
+            return [x for x in (first_idempotent(_) for _ in self.j_classes()) if x is not None]
+
+        # TODO: compute eJe, where J is the J-class of e
+        # TODO: construct the action of self on it, as a permutation group

sage/categories/finite_sets.py

@@ -0,0 +1,93 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Finite sets
+"""
+#*****************************************************************************
+#  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.categories.category_with_axiom import CategoryWithAxiom
+from sage.categories.algebra_functor import AlgebrasCategory
+from sage.categories.subquotients import SubquotientsCategory
+
+
+class FiniteSets(CategoryWithAxiom):
+    r"""
+    The category of finite sets.
+
+    EXAMPLES::
+
+        sage: C = FiniteSets(); C
+        Category of finite sets
+        sage: C.super_categories()
+        [Category of sets]
+        sage: C.all_super_categories()
+        [Category of finite sets,
+         Category of sets,
+         Category of sets with partial maps,
+         Category of objects]
+        sage: C.example()
+        NotImplemented
+
+    TESTS::
+
+        sage: TestSuite(C).run()
+        sage: C is Sets().Finite()
+        True
+    """
+
+    class ParentMethods:
+
+        def is_finite(self):
+            """
+            Return ``True`` since ``self`` is finite.
+
+            EXAMPLES::
+
+                sage: C = FiniteEnumeratedSets().example()
+                sage: C.is_finite()
+                True
+            """
+            return True
+
+    class Subquotients(SubquotientsCategory):
+
+        def extra_super_categories(self):
+            r"""
+            EXAMPLES::
+
+                sage: FiniteSets().Subquotients().extra_super_categories()
+                [Category of finite sets]
+
+            This implements the fact that a subquotient (and therefore
+            a quotient or subobject) of a finite set is finite::
+
+                sage: FiniteSets().Subquotients().is_subcategory(FiniteSets())
+                True
+                sage: FiniteSets().Quotients   ().is_subcategory(FiniteSets())
+                True
+                sage: FiniteSets().Subobjects  ().is_subcategory(FiniteSets())
+                True
+            """
+            return [FiniteSets()]
+
+    class Algebras(AlgebrasCategory):
+
+        def extra_super_categories(self):
+            r"""
+            EXAMPLES::
+
+                sage: FiniteSets().Algebras(QQ).extra_super_categories()
+                [Category of finite dimensional vector spaces with basis over Rational Field]
+
+            This implements the fact that the algebra of a finite set
+            is finite dimensional::
+
+                sage: FiniteMonoids().Algebras(QQ).is_subcategory(AlgebrasWithBasis(QQ).FiniteDimensional())
+                True
+            """
+            from sage.categories.modules_with_basis import ModulesWithBasis
+            return [ModulesWithBasis(self.base_ring()).FiniteDimensional()]

sage/categories/finite_weyl_groups.py

@@ -0,0 +1,39 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Finite 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.categories.category_with_axiom import CategoryWithAxiom
+
+
+class FiniteWeylGroups(CategoryWithAxiom):
+    """
+    The category of finite Weyl groups.
+
+    EXAMPLES::
+
+        sage: C = FiniteWeylGroups()
+        sage: C
+        Category of finite Weyl groups
+        sage: C.super_categories()
+        [Category of finite Coxeter groups, Category of Weyl groups]
+        sage: C.example()
+        The symmetric group on {0, ..., 3}
+
+    TESTS::
+
+        sage: W = FiniteWeylGroups().example()
+        sage: TestSuite(W).run()
+    """
+
+    class ParentMethods:
+        pass
+
+    class ElementMethods:
+        pass

sage/categories/finitely_generated_lambda_bracket_algebras.py

@@ -0,0 +1,112 @@
+# sage_setup: distribution = sagemath-categories
+"""
+Finitely Generated Lambda bracket Algebras
+
+AUTHORS:
+
+- Reimundo Heluani (2020-08-21): Initial implementation.
+"""
+
+#******************************************************************************
+#       Copyright (C) 2020 Reimundo Heluani <heluani@potuz.net>
+#
+# 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_with_axiom import CategoryWithAxiom_over_base_ring
+from sage.categories.graded_modules import GradedModulesCategory
+from sage.categories.lambda_bracket_algebras import LambdaBracketAlgebras
+
+
+class FinitelyGeneratedLambdaBracketAlgebras(CategoryWithAxiom_over_base_ring):
+    """
+    The category of finitely generated lambda bracket algebras.
+
+    EXAMPLES::
+
+        sage: from sage.categories.lambda_bracket_algebras import LambdaBracketAlgebras
+        sage: LambdaBracketAlgebras(QQbar).FinitelyGenerated()                          # needs sage.rings.number_field
+        Category of finitely generated lambda bracket algebras over Algebraic Field
+    """
+    _base_category_class_and_axiom = (LambdaBracketAlgebras, "FinitelyGeneratedAsLambdaBracketAlgebra")
+
+    class ParentMethods:
+        def ngens(self):
+            r"""
+            The number of generators of this Lie conformal algebra.
+
+            EXAMPLES::
+
+                sage: Vir = lie_conformal_algebras.Virasoro(QQ)                         # needs sage.combinat sage.modules
+                sage: Vir.ngens()                                                       # needs sage.combinat sage.modules
+                2
+
+                sage: V = lie_conformal_algebras.Affine(QQ, 'A2')                       # needs sage.combinat sage.modules
+                sage: V.ngens()                                                         # needs sage.combinat sage.modules
+                9
+            """
+            return len(self.gens())
+
+        def gen(self, i):
+            r"""
+            The ``i``-th generator of this Lie conformal algebra.
+
+            EXAMPLES::
+
+                sage: # needs sage.combinat sage.modules
+                sage: V = lie_conformal_algebras.Affine(QQ, 'A1')
+                sage: V.gens()
+                (B[alpha[1]], B[alphacheck[1]], B[-alpha[1]], B['K'])
+                sage: V.gen(0)
+                B[alpha[1]]
+                sage: V.1
+                B[alphacheck[1]]
+            """
+            return self.gens()[i]
+
+        def some_elements(self):
+            """
+            Some elements of this Lie conformal algebra.
+
+            This method returns a list with elements containing at
+            least the generators.
+
+            EXAMPLES::
+
+                sage: V = lie_conformal_algebras.Affine(QQ, 'A1',                       # needs sage.combinat sage.modules
+                ....:                                   names=('e', 'h', 'f'))
+                sage: V.some_elements()                                                 # needs sage.combinat sage.modules
+                [e, h, f, K, ...]
+                sage: all(v.parent() is V for v in V.some_elements())                   # needs sage.combinat sage.modules
+                True
+            """
+            S = list(self.gens())
+            from sage.misc.misc import some_tuples
+            for x,y in some_tuples(S, 2, 0, max_samples=self.ngens()):
+                S.append(x.T() + 2*y.T(2))
+            return S
+
+    class Graded(GradedModulesCategory):
+        """
+        The category of H-graded finitely generated Lie conformal algebras.
+
+        EXAMPLES::
+
+            sage: LieConformalAlgebras(QQbar).FinitelyGenerated().Graded()              # needs sage.rings.number_field
+            Category of H-graded finitely generated Lie conformal algebras
+             over Algebraic Field
+        """
+        def _repr_object_names(self):
+            """
+            The names of the objects of ``self``.
+
+            EXAMPLES::
+
+                sage: LieConformalAlgebras(QQbar).WithBasis().FinitelyGenerated().Graded()          # needs sage.rings.number_field
+                Category of H-graded finitely generated Lie conformal algebras with basis over Algebraic Field
+            """
+            return "H-graded {}".format(self.base_category()._repr_object_names())

sage/categories/finitely_generated_lie_conformal_algebras.py

@@ -0,0 +1,114 @@
+# sage_setup: distribution = sagemath-categories
+"""
+Finitely Generated Lie Conformal Algebras
+
+AUTHORS:
+
+- Reimundo Heluani (2019-10-05): Initial implementation.
+"""
+
+# *****************************************************************************
+#       Copyright (C) 2019 Reimundo Heluani <heluani@potuz.net>
+#
+# 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.
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+from sage.categories.category_with_axiom import CategoryWithAxiom_over_base_ring
+from sage.categories.graded_modules import GradedModulesCategory
+from sage.categories.super_modules import SuperModulesCategory
+from sage.categories.lie_conformal_algebras import LieConformalAlgebras
+
+
+class FinitelyGeneratedLieConformalAlgebras(CategoryWithAxiom_over_base_ring):
+    """
+    The category of finitely generated Lie conformal algebras.
+
+    EXAMPLES::
+
+        sage: LieConformalAlgebras(QQbar).FinitelyGenerated()                           # needs sage.rings.number_field
+        Category of finitely generated Lie conformal algebras over Algebraic Field
+    """
+    _base_category_class_and_axiom = (LieConformalAlgebras, "FinitelyGeneratedAsLambdaBracketAlgebra")
+
+    class ParentMethods:
+
+        def some_elements(self):
+            """
+            Some elements of this Lie conformal algebra.
+
+            Returns a list with elements containing at least the
+            generators.
+
+            EXAMPLES::
+
+                sage: V = lie_conformal_algebras.Affine(QQ, 'A1',                       # needs sage.combinat sage.modules
+                ....:                                   names=('e', 'h', 'f'))
+                sage: V.some_elements()                                                 # needs sage.combinat sage.modules
+                [e, h, f, K, ...]
+                sage: all(v.parent() is V for v in V.some_elements())                   # needs sage.combinat sage.modules
+                True
+            """
+            S = list(self.gens())
+            from sage.misc.misc import some_tuples
+            for x,y in some_tuples(S, 2, 0, max_samples=self.ngens()):
+                S.append(x.T() + 2*y.T(2))
+            return S
+
+    class Super(SuperModulesCategory):
+        """
+        The category of super finitely generated Lie conformal algebras.
+
+        EXAMPLES::
+
+            sage: LieConformalAlgebras(AA).FinitelyGenerated().Super()                  # needs sage.rings.number_field
+            Category of super finitely generated Lie conformal algebras
+             over Algebraic Real Field
+        """
+        class Graded(GradedModulesCategory):
+            """
+            The category of H-graded super finitely generated Lie conformal algebras.
+
+            EXAMPLES::
+
+                sage: LieConformalAlgebras(QQbar).FinitelyGenerated().Super().Graded()  # needs sage.rings.number_field
+                Category of H-graded super finitely generated Lie conformal algebras
+                 over Algebraic Field
+            """
+            def _repr_object_names(self):
+                """
+                The names of the objects of ``self``.
+
+                EXAMPLES::
+
+                    sage: C = LieConformalAlgebras(QQbar).FinitelyGenerated()           # needs sage.rings.number_field
+                    sage: C.Super().Graded()                                            # needs sage.rings.number_field
+                    Category of H-graded super finitely generated
+                     Lie conformal algebras over Algebraic Field
+                """
+                return "H-graded {}".format(self.base_category()._repr_object_names())
+
+    class Graded(GradedModulesCategory):
+        """
+        The category of H-graded finitely generated Lie conformal algebras.
+
+        EXAMPLES::
+
+            sage: LieConformalAlgebras(QQbar).FinitelyGenerated().Graded()              # needs sage.rings.number_field
+            Category of H-graded finitely generated Lie conformal algebras
+             over Algebraic Field
+        """
+        def _repr_object_names(self):
+            """
+            The names of the objects of ``self``.
+
+            EXAMPLES::
+
+                sage: LieConformalAlgebras(QQbar).WithBasis().FinitelyGenerated().Graded()          # needs sage.rings.number_field
+                Category of H-graded finitely generated Lie conformal algebras with basis
+                 over Algebraic Field
+            """
+            return "H-graded {}".format(self.base_category()._repr_object_names())

sage/categories/finitely_generated_magmas.py

@@ -0,0 +1,57 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Finitely generated magmas
+"""
+#*****************************************************************************
+#  Copyright (C) 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.abstract_method import abstract_method
+from sage.categories.category_with_axiom import CategoryWithAxiom
+from sage.categories.magmas import Magmas
+
+
+class FinitelyGeneratedMagmas(CategoryWithAxiom):
+    r"""
+    The category of finitely generated (multiplicative) magmas.
+
+    See :meth:`Magmas.SubcategoryMethods.FinitelyGeneratedAsMagma` for
+    details.
+
+    EXAMPLES::
+
+        sage: C = Magmas().FinitelyGeneratedAsMagma(); C
+        Category of finitely generated magmas
+        sage: C.super_categories()
+        [Category of magmas]
+        sage: sorted(C.axioms())
+        ['FinitelyGeneratedAsMagma']
+
+    TESTS::
+
+        sage: TestSuite(C).run()
+    """
+
+    _base_category_class_and_axiom = (Magmas, "FinitelyGeneratedAsMagma")
+
+    class ParentMethods:
+
+        @abstract_method
+        def magma_generators(self):
+            """
+            Return distinguished magma generators for ``self``.
+
+            OUTPUT: a finite family
+
+            This method should be implemented by all
+            :class:`finitely generated magmas <FinitelyGeneratedMagmas>`.
+
+            EXAMPLES::
+
+                sage: S = FiniteSemigroups().example()
+                sage: S.magma_generators()
+                Family ('a', 'b', 'c', 'd')
+            """