passagemath-categories 10.6.32__cp314-cp314t-musllinux_1_2_aarch64.whl

sage/categories/finitely_generated_semigroups.py

@@ -0,0 +1,214 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Finitely generated semigroups
+"""
+# ****************************************************************************
+#  Copyright (C) 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/
+# *****************************************************************************
+
+import itertools
+from sage.misc.abstract_method import abstract_method
+from sage.misc.cachefunc import cached_method
+from sage.categories.category_with_axiom import CategoryWithAxiom
+from sage.categories.semigroups import Semigroups
+from sage.categories.enumerated_sets import EnumeratedSets
+
+
+class FinitelyGeneratedSemigroups(CategoryWithAxiom):
+    r"""
+    The category of finitely generated (multiplicative) semigroups.
+
+    A :class:`finitely generated semigroup <Semigroups>` is a
+    :class:`semigroup <Semigroups>` endowed with a distinguished
+    finite set of generators (see
+    :meth:`FinitelyGeneratedSemigroups.ParentMethods.semigroup_generators`).
+    This makes it into an :class:`enumerated set <EnumeratedSets>`.
+
+    EXAMPLES::
+
+        sage: C = Semigroups().FinitelyGenerated(); C
+        Category of finitely generated semigroups
+        sage: C.super_categories()
+        [Category of semigroups,
+         Category of finitely generated magmas,
+         Category of enumerated sets]
+        sage: sorted(C.axioms())
+        ['Associative', 'Enumerated', 'FinitelyGeneratedAsMagma']
+        sage: C.example()
+        An example of a semigroup: the free semigroup generated
+        by ('a', 'b', 'c', 'd')
+
+    TESTS::
+
+        sage: TestSuite(C).run()
+    """
+
+    _base_category_class_and_axiom = (Semigroups, "FinitelyGeneratedAsMagma")
+
+    @cached_method
+    def extra_super_categories(self):
+        r"""
+        State that a finitely generated semigroup is endowed with a
+        default enumeration.
+
+        EXAMPLES::
+
+            sage: Semigroups().FinitelyGenerated().extra_super_categories()
+            [Category of enumerated sets]
+        """
+        return [EnumeratedSets()]
+
+    def example(self):
+        r"""
+        EXAMPLES::
+
+            sage: Semigroups().FinitelyGenerated().example()
+            An example of a semigroup: the free semigroup generated
+            by ('a', 'b', 'c', 'd')
+        """
+        return Semigroups().example("free")
+
+    class ParentMethods:
+
+        @abstract_method
+        def semigroup_generators(self):
+            r"""
+            Return distinguished semigroup generators for ``self``.
+
+            OUTPUT: a finite family
+
+            This method should be implemented by all semigroups in
+            :class:`FinitelyGeneratedSemigroups`.
+
+            EXAMPLES::
+
+                sage: S = FiniteSemigroups().example()
+                sage: S.semigroup_generators()
+                Family ('a', 'b', 'c', 'd')
+            """
+
+        # TODO: update transitive ideal
+
+        def succ_generators(self, side='twosided'):
+            r"""
+            Return the successor function of the ``side``-sided Cayley
+            graph of ``self``.
+
+            This is a function that maps an element of ``self`` to all
+            the products of ``x`` by a generator of this semigroup,
+            where the product is taken on the left, right, or both
+            sides.
+
+            INPUT:
+
+            - ``side`` -- ``'left'``, ``'right'``, or ``'twosided'`` (default)
+
+            .. TODO:: Design choice:
+
+               - find a better name for this method
+               - should we return a set? a family?
+
+            EXAMPLES::
+
+                sage: S = FiniteSemigroups().example()
+                sage: S.succ_generators("left" )(S('ca'))
+                ('ac', 'bca', 'ca', 'dca')
+                sage: S.succ_generators("right")(S('ca'))
+                ('ca', 'cab', 'ca', 'cad')
+                sage: S.succ_generators("twosided" )(S('ca'))
+                ('ac', 'bca', 'ca', 'dca', 'ca', 'cab', 'ca', 'cad')
+            """
+            left = (side == "left" or side == "twosided")
+            right = (side == "right" or side == "twosided")
+            generators = self.semigroup_generators()
+            return lambda x: (tuple(g * x for g in generators) if left else ()) + (tuple(x * g for g in generators) if right else ())
+
+        def __iter__(self):
+            r"""
+            Return an iterator over the elements of ``self``.
+
+            This brute force implementation recursively multiplies
+            together the distinguished semigroup generators.
+
+            .. SEEALSO:: :meth:`semigroup_generators`
+
+            EXAMPLES::
+
+                sage: S = FiniteSemigroups().example(alphabet=('x','y'))
+                sage: it = S.__iter__()
+                sage: sorted(it)
+                ['x', 'xy', 'y', 'yx']
+            """
+            from sage.sets.recursively_enumerated_set import RecursivelyEnumeratedSet
+            return iter(RecursivelyEnumeratedSet(self.semigroup_generators(),
+                                                 self.succ_generators(side='right'),
+                                                 enumeration='breadth'))
+
+        def ideal(self, gens, side='twosided'):
+            r"""
+            Return the ``side``-sided ideal generated by ``gens``.
+
+            This brute force implementation recursively multiplies the
+            elements of ``gens`` by the distinguished generators of
+            this semigroup.
+
+            .. SEEALSO:: :meth:`semigroup_generators`
+
+            INPUT:
+
+            - ``gens`` -- list (or iterable) of elements of ``self``
+            - ``side`` -- [default: "twosided"] "left", "right" or "twosided"
+
+            EXAMPLES::
+
+                sage: S = FiniteSemigroups().example()
+                sage: sorted(S.ideal([S('cab')], side='left'))
+                ['abc', 'abcd', 'abdc', 'acb', 'acbd', 'acdb', 'adbc',
+                 'adcb', 'bac', 'bacd', 'badc', 'bca', 'bcad', 'bcda',
+                 'bdac', 'bdca', 'cab', 'cabd', 'cadb', 'cba', 'cbad',
+                 'cbda', 'cdab', 'cdba', 'dabc', 'dacb', 'dbac', 'dbca',
+                 'dcab', 'dcba']
+                sage: list(S.ideal([S('cab')], side='right'))
+                ['cab', 'cabd']
+                sage: sorted(S.ideal([S('cab')], side='twosided'))
+                ['abc', 'abcd', 'abdc', 'acb', 'acbd', 'acdb', 'adbc',
+                 'adcb', 'bac', 'bacd', 'badc', 'bca', 'bcad', 'bcda',
+                 'bdac', 'bdca', 'cab', 'cabd', 'cadb', 'cba', 'cbad',
+                 'cbda', 'cdab', 'cdba', 'dabc', 'dacb', 'dbac', 'dbca',
+                 'dcab', 'dcba']
+                sage: sorted(S.ideal([S('cab')]))
+                ['abc', 'abcd', 'abdc', 'acb', 'acbd', 'acdb', 'adbc',
+                 'adcb', 'bac', 'bacd', 'badc', 'bca', 'bcad', 'bcda',
+                 'bdac', 'bdca', 'cab', 'cabd', 'cadb', 'cba', 'cbad',
+                 'cbda', 'cdab', 'cdba', 'dabc', 'dacb', 'dbac', 'dbca',
+                 'dcab', 'dcba']
+            """
+            from sage.sets.recursively_enumerated_set import RecursivelyEnumeratedSet
+            return RecursivelyEnumeratedSet(gens,
+                                            self.succ_generators(side=side))
+
+    class Finite(CategoryWithAxiom):
+
+        class ParentMethods:
+            def some_elements(self):
+                r"""
+                Return an iterable containing some elements of the semigroup.
+
+                OUTPUT: the ten first elements of the semigroup, if they exist
+
+                EXAMPLES::
+
+                    sage: S = FiniteSemigroups().example(alphabet=('x','y'))
+                    sage: sorted(S.some_elements())
+                    ['x', 'xy', 'y', 'yx']
+                    sage: S = FiniteSemigroups().example(alphabet=('x','y','z'))
+                    sage: X = S.some_elements()
+                    sage: len(X)
+                    10
+                    sage: all(x in S for x in X)
+                    True
+                """
+                return list(itertools.islice(self, 10))

sage/categories/function_fields.py

@@ -0,0 +1,76 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Function fields
+"""
+#*****************************************************************************
+#  Copyright (C) 2005      David Kohel <kohel@maths.usyd.edu>
+#                          William Stein <wstein@math.ucsd.edu>
+#                2008      Teresa Gomez-Diaz (CNRS) <Teresa.Gomez-Diaz@univ-mlv.fr>
+#                2008-2009 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 import Category
+from sage.misc.cachefunc import cached_method
+from sage.categories.basic import Fields
+
+
+class FunctionFields(Category):
+    r"""
+    The category of function fields.
+
+    EXAMPLES:
+
+    We create the category of function fields::
+
+        sage: C = FunctionFields()
+        sage: C
+        Category of function fields
+
+    TESTS::
+
+        sage: TestSuite(FunctionFields()).run()
+    """
+    @cached_method
+    def super_categories(self):
+        """
+        Return the Category of which this is a direct sub-Category
+        For a list off all super categories see all_super_categories
+
+        EXAMPLES::
+
+            sage: FunctionFields().super_categories()
+            [Category of fields]
+        """
+        return [Fields()]
+
+    def _call_(self, x):
+        r"""
+        Construct an object in this category from the data in ``x``,
+        or throw a :exc:`TypeError`.
+
+        EXAMPLES::
+
+            sage: C = FunctionFields()
+            sage: K.<x> = FunctionField(QQ)
+            sage: C(K)
+            Rational function field in x over Rational Field
+            sage: Ky.<y> = K[]
+            sage: L = K.extension(y^2 - x)                                              # needs sage.rings.function_field
+            sage: C(L)                                                                  # needs sage.rings.function_field
+            Function field in y defined by y^2 - x
+            sage: C(L.equation_order())                                                 # needs sage.rings.function_field
+            Function field in y defined by y^2 - x
+        """
+        try:
+            return x.function_field()
+        except AttributeError:
+            raise TypeError("unable to canonically associate a function field to %s" % x)
+
+    class ParentMethods:
+        pass
+
+    class ElementMethods:
+        pass

sage/categories/g_sets.py

@@ -0,0 +1,77 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+G-Sets
+"""
+#*****************************************************************************
+#  Copyright (C) 2008 David Kohel <kohel@maths.usyd.edu> and
+#                     William Stein <wstein@math.ucsd.edu>
+#                     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 import Category
+from sage.categories.sets_cat import Sets
+
+
+#############################################################
+# GSets
+#     `G`-Sets play an important role in permutation groups.
+#############################################################
+class GSets(Category):
+    """
+    The category of `G`-sets, for a group `G`.
+
+    EXAMPLES::
+
+        sage: S = SymmetricGroup(3)                                                     # needs sage.groups
+        sage: GSets(S)                                                                  # needs sage.groups
+        Category of G-sets for Symmetric group of order 3! as a permutation group
+
+    TODO: should this derive from Category_over_base?
+    """
+    def __init__(self, G):
+        """
+        TESTS::
+
+            sage: S8 = SymmetricGroup(8)                                                # needs sage.groups
+            sage: TestSuite(GSets(S8)).run()                                            # needs sage.groups
+        """
+        Category.__init__(self)
+        self.__G = G
+
+    def _repr_object_names(self):
+        """
+        EXAMPLES::
+
+            sage: GSets(SymmetricGroup(8))  # indirect doctests                         # needs sage.groups
+            Category of G-sets for Symmetric group of order 8! as a permutation group
+        """
+        return "G-sets for %s" % self.__G
+
+    #def construction(self):
+    #    return (self.__class__, self.__G)
+
+    def super_categories(self):
+        """
+        EXAMPLES::
+
+            sage: GSets(SymmetricGroup(8)).super_categories()                           # needs sage.groups
+            [Category of sets]
+        """
+        return [Sets()]
+
+    @classmethod
+    def an_instance(cls):
+        """
+        Return an instance of this class.
+
+        EXAMPLES::
+
+            sage: GSets.an_instance()  # indirect doctest                               # needs sage.groups
+            Category of G-sets for Symmetric group of order 8! as a permutation group
+        """
+        from sage.groups.perm_gps.permgroup_named import SymmetricGroup
+        G = SymmetricGroup(8)
+        return cls(G)

sage/categories/gcd_domains.py

@@ -0,0 +1,65 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Gcd domains
+"""
+#*****************************************************************************
+#  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.categories.category_singleton import Category_singleton
+from sage.categories.integral_domains import IntegralDomains
+
+
+class GcdDomains(Category_singleton):
+    """
+    The category of gcd domains
+    domains where gcd can be computed but where there is no guarantee of
+    factorisation into irreducibles
+
+    EXAMPLES::
+
+        sage: GcdDomains()
+        Category of gcd domains
+        sage: GcdDomains().super_categories()
+        [Category of integral domains]
+
+    TESTS::
+
+        sage: TestSuite(GcdDomains()).run()
+    """
+
+    def super_categories(self):
+        """
+        EXAMPLES::
+
+            sage: GcdDomains().super_categories()
+            [Category of integral domains]
+        """
+        return [IntegralDomains()]
+
+    def additional_structure(self):
+        """
+        Return ``None``.
+
+        Indeed, the category of gcd domains defines no additional
+        structure: a ring morphism between two gcd domains is a gcd
+        domain morphism.
+
+        .. SEEALSO:: :meth:`Category.additional_structure`
+
+        EXAMPLES::
+
+            sage: GcdDomains().additional_structure()
+        """
+        return None
+
+    class ParentMethods:
+        pass
+
+    class ElementMethods:
+        # gcd(x,y)
+        # lcm(x,y)
+        pass

sage/categories/generalized_coxeter_groups.py

@@ -0,0 +1,94 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Generalized Coxeter 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.misc.cachefunc import cached_method
+from sage.categories.category_singleton import Category_singleton
+from sage.categories.category_with_axiom import CategoryWithAxiom
+from sage.categories.complex_reflection_or_generalized_coxeter_groups import ComplexReflectionOrGeneralizedCoxeterGroups
+
+
+class GeneralizedCoxeterGroups(Category_singleton):
+    r"""
+    The category of generalized Coxeter groups.
+
+    A generalized Coxeter group is a group with a presentation of
+    the following form:
+
+    .. MATH::
+
+        \langle s_i \mid s_i^{p_i}, s_i s_j \cdots = s_j s_i \cdots \rangle,
+
+    where `p_i > 1`, `i \in I`, and the factors in the braid relation
+    occur `m_{ij} = m_{ji}` times for all `i \neq j \in I`.
+
+    EXAMPLES::
+
+        sage: from sage.categories.generalized_coxeter_groups import GeneralizedCoxeterGroups
+        sage: C = GeneralizedCoxeterGroups(); C
+        Category of generalized Coxeter groups
+
+    TESTS::
+
+        sage: TestSuite(C).run()
+    """
+    @cached_method
+    def super_categories(self):
+        """
+        EXAMPLES::
+
+            sage: from sage.categories.generalized_coxeter_groups import GeneralizedCoxeterGroups
+            sage: GeneralizedCoxeterGroups().super_categories()
+            [Category of complex reflection or generalized Coxeter groups]
+        """
+        return [ComplexReflectionOrGeneralizedCoxeterGroups()]
+
+    def additional_structure(self):
+        r"""
+        Return ``None``.
+
+        Indeed, all the structure generalized Coxeter groups have in
+        addition to groups (simple reflections, ...) is already
+        defined in the super category.
+
+        .. SEEALSO:: :meth:`Category.additional_structure`
+
+        EXAMPLES::
+
+            sage: from sage.categories.generalized_coxeter_groups import GeneralizedCoxeterGroups
+            sage: GeneralizedCoxeterGroups().additional_structure()
+        """
+        return None
+
+    class Finite(CategoryWithAxiom):
+        """
+        The category of finite generalized Coxeter groups.
+        """
+        def extra_super_categories(self):
+            """
+            Implement that a finite generalized Coxeter group is a
+            well-generated complex reflection group.
+
+            EXAMPLES::
+
+                sage: from sage.categories.generalized_coxeter_groups import GeneralizedCoxeterGroups
+                sage: from sage.categories.complex_reflection_groups import ComplexReflectionGroups
+
+                sage: Cat = GeneralizedCoxeterGroups().Finite()
+                sage: Cat.extra_super_categories()
+                [Category of well generated finite complex reflection groups]
+                sage: Cat.is_subcategory(ComplexReflectionGroups().Finite().WellGenerated())
+                True
+            """
+            from sage.categories.complex_reflection_groups import ComplexReflectionGroups
+            return [ComplexReflectionGroups().Finite().WellGenerated()]

sage/categories/graded_algebras.py

@@ -0,0 +1,85 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Graded Algebras
+"""
+#*****************************************************************************
+#  Copyright (C) 2008      Teresa Gomez-Diaz (CNRS) <Teresa.Gomez-Diaz@univ-mlv.fr>
+#                2008-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.graded_modules import GradedModulesCategory
+from sage.categories.signed_tensor import SignedTensorProductsCategory
+from sage.misc.cachefunc import cached_method
+
+
+class GradedAlgebras(GradedModulesCategory):
+    """
+    The category of graded algebras.
+
+    EXAMPLES::
+
+        sage: GradedAlgebras(ZZ)
+        Category of graded algebras over Integer Ring
+        sage: GradedAlgebras(ZZ).super_categories()
+        [Category of filtered algebras over Integer Ring,
+         Category of graded modules over Integer Ring]
+
+    TESTS::
+
+        sage: TestSuite(GradedAlgebras(ZZ)).run()
+    """
+    class ParentMethods:
+        def graded_algebra(self):
+            """
+            Return the associated graded algebra to ``self``.
+
+            Since ``self`` is already graded, this just returns
+            ``self``.
+
+            EXAMPLES::
+
+                sage: m = SymmetricFunctions(QQ).m()                                    # needs sage.combinat sage.modules
+                sage: m.graded_algebra() is m                                           # needs sage.combinat sage.modules
+                True
+            """
+            return self
+
+    class ElementMethods:
+        pass
+
+    class SubcategoryMethods:
+        def SignedTensorProducts(self):
+            r"""
+            Return the full subcategory of objects of ``self`` constructed
+            as signed tensor products.
+
+            .. SEEALSO::
+
+                - :class:`~sage.categories.signed_tensor.SignedTensorProductsCategory`
+                - :class:`~.covariant_functorial_construction.CovariantFunctorialConstruction`
+
+            EXAMPLES::
+
+                sage: AlgebrasWithBasis(QQ).Graded().SignedTensorProducts()
+                Category of signed tensor products of graded algebras with basis
+                 over Rational Field
+            """
+            return SignedTensorProductsCategory.category_of(self)
+
+    class SignedTensorProducts(SignedTensorProductsCategory):
+        @cached_method
+        def extra_super_categories(self):
+            """
+            EXAMPLES::
+
+                sage: Algebras(QQ).Graded().SignedTensorProducts().extra_super_categories()
+                [Category of graded algebras over Rational Field]
+                sage: Algebras(QQ).Graded().SignedTensorProducts().super_categories()
+                [Category of graded algebras over Rational Field]
+
+            Meaning: a signed tensor product of algebras is an algebra
+            """
+            return [self.base_category()]