passagemath-categories 10.6.32__cp314-cp314t-musllinux_1_2_aarch64.whl

sage/categories/examples/finite_monoids.py

@@ -0,0 +1,150 @@
+# sage_setup: distribution = sagemath-categories
+"""
+Examples of finite monoids
+"""
+#*****************************************************************************
+#  Copyright (C) 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.misc.cachefunc import cached_method
+from sage.sets.family import Family
+from sage.structure.parent import Parent
+from sage.structure.unique_representation import UniqueRepresentation
+from sage.structure.element_wrapper import ElementWrapper
+from sage.categories.monoids import Monoids
+from sage.rings.integer import Integer
+from sage.rings.integer_ring import ZZ
+
+
+class IntegerModMonoid(UniqueRepresentation, Parent):
+    r"""
+    An example of a finite monoid: the integers mod `n`.
+
+    This class illustrates a minimal implementation of a finite monoid.
+
+    EXAMPLES::
+
+        sage: S = FiniteMonoids().example(); S
+        An example of a finite multiplicative monoid: the integers modulo 12
+
+        sage: S.category()
+        Category of finitely generated finite enumerated monoids
+
+    We conclude by running systematic tests on this monoid::
+
+        sage: TestSuite(S).run(verbose = True)
+        running ._test_an_element() . . . pass
+        running ._test_associativity() . . . pass
+        running ._test_cardinality() . . . pass
+        running ._test_category() . . . pass
+        running ._test_construction() . . . pass
+        running ._test_elements() . . .
+          Running the test suite of self.an_element()
+          running ._test_category() . . . pass
+          running ._test_eq() . . . pass
+          running ._test_new() . . . pass
+          running ._test_not_implemented_methods() . . . pass
+          running ._test_pickling() . . . pass
+          pass
+        running ._test_elements_eq_reflexive() . . . pass
+        running ._test_elements_eq_symmetric() . . . pass
+        running ._test_elements_eq_transitive() . . . pass
+        running ._test_elements_neq() . . . pass
+        running ._test_enumerated_set_contains() . . . pass
+        running ._test_enumerated_set_iter_cardinality() . . . pass
+        running ._test_enumerated_set_iter_list() . . . pass
+        running ._test_eq() . . . pass
+        running ._test_new() . . . pass
+        running ._test_not_implemented_methods() . . . pass
+        running ._test_one() . . . pass
+        running ._test_pickling() . . . pass
+        running ._test_prod() . . . pass
+        running ._test_some_elements() . . . pass
+    """
+
+    def __init__(self, n=12):
+        r"""
+        EXAMPLES::
+
+            sage: M = FiniteMonoids().example(6); M
+            An example of a finite multiplicative monoid: the integers modulo 6
+
+        TESTS::
+
+            sage: TestSuite(M).run()
+        """
+        self.n = n
+        Parent.__init__(self, category=Monoids().Finite().FinitelyGenerated())
+
+    def _repr_(self):
+        r"""
+        TESTS::
+
+            sage: M = FiniteMonoids().example()
+            sage: M._repr_()
+            'An example of a finite multiplicative monoid: the integers modulo 12'
+        """
+        return "An example of a finite multiplicative monoid: the integers modulo %s" % self.n
+
+    def semigroup_generators(self):
+        r"""
+
+        Returns a set of generators for ``self``, as per
+        :meth:`Semigroups.ParentMethods.semigroup_generators`.
+        Currently this returns all integers mod `n`, which is of
+        course far from optimal!
+
+        EXAMPLES::
+
+            sage: M = FiniteMonoids().example()
+            sage: M.semigroup_generators()
+            Family (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)
+        """
+        return Family(tuple(self(ZZ(i)) for i in range(self.n)))
+
+    @cached_method
+    def one(self):
+        r"""
+        Return the one of the monoid, as per :meth:`Monoids.ParentMethods.one`.
+
+        EXAMPLES::
+
+            sage: M = FiniteMonoids().example()
+            sage: M.one()
+            1
+        """
+        return self(ZZ.one())
+
+    def product(self, x, y):
+        r"""
+        Return the product of two elements `x` and `y` of the monoid, as
+        per :meth:`Semigroups.ParentMethods.product`.
+
+        EXAMPLES::
+
+            sage: M = FiniteMonoids().example()
+            sage: M.product(M(3), M(5))
+            3
+        """
+        return self((x.value * y.value) % self.n)
+
+    def an_element(self):
+        r"""
+        Return an element of the monoid, as per :meth:`Sets.ParentMethods.an_element`.
+
+        EXAMPLES::
+
+            sage: M = FiniteMonoids().example()
+            sage: M.an_element()
+            6
+        """
+        return self(ZZ(42) % self.n)
+
+    class Element (ElementWrapper):
+        wrapped_class = Integer
+
+
+Example = IntegerModMonoid

sage/categories/examples/finite_semigroups.py

@@ -0,0 +1,190 @@
+# sage_setup: distribution = sagemath-categories
+"""
+Examples of finite semigroups
+"""
+#*****************************************************************************
+#  Copyright (C) 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.misc.cachefunc import cached_method
+from sage.sets.family import Family
+from sage.categories.semigroups import Semigroups
+from sage.structure.parent import Parent
+from sage.structure.unique_representation import UniqueRepresentation
+from sage.structure.element_wrapper import ElementWrapper
+
+
+class LeftRegularBand(UniqueRepresentation, Parent):
+    r"""
+    An example of a finite semigroup.
+
+    This class provides a minimal implementation of a finite semigroup.
+
+    EXAMPLES::
+
+        sage: S = FiniteSemigroups().example(); S
+        An example of a finite semigroup:
+         the left regular band generated by ('a', 'b', 'c', 'd')
+
+    This is the semigroup generated by::
+
+        sage: S.semigroup_generators()
+        Family ('a', 'b', 'c', 'd')
+
+    such that `x^2 = x` and `x y x = xy` for any `x` and `y` in `S`::
+
+        sage: S('dab')
+        'dab'
+        sage: S('dab') * S('acb')
+        'dabc'
+
+    It follows that the elements of `S` are strings without
+    repetitions over the alphabet `a`, `b`, `c`, `d`::
+
+        sage: sorted(S.list())
+        ['a', 'ab', 'abc', 'abcd', 'abd', 'abdc', 'ac', 'acb', 'acbd', 'acd',
+         'acdb', 'ad', 'adb', 'adbc', 'adc', 'adcb', 'b', 'ba', 'bac',
+         'bacd', 'bad', 'badc', 'bc', 'bca', 'bcad', 'bcd', 'bcda', 'bd',
+         'bda', 'bdac', 'bdc', 'bdca', 'c', 'ca', 'cab', 'cabd', 'cad',
+         'cadb', 'cb', 'cba', 'cbad', 'cbd', 'cbda', 'cd', 'cda', 'cdab',
+         'cdb', 'cdba', 'd', 'da', 'dab', 'dabc', 'dac', 'dacb', 'db',
+         'dba', 'dbac', 'dbc', 'dbca', 'dc', 'dca', 'dcab', 'dcb', 'dcba']
+
+    It also follows that there are finitely many of them::
+
+        sage: S.cardinality()
+        64
+
+    Indeed::
+
+        sage: 4 * ( 1 + 3 * (1 + 2 * (1 + 1)))
+        64
+
+    As expected, all the elements of `S` are idempotents::
+
+        sage: all( x.is_idempotent() for x in S )
+        True
+
+    Now, let us look at the structure of the semigroup::
+
+        sage: S = FiniteSemigroups().example(alphabet = ('a','b','c'))
+        sage: S.cayley_graph(side='left', simple=True).plot()                           # needs sage.graphs sage.plot
+        Graphics object consisting of 60 graphics primitives
+        sage: S.j_transversal_of_idempotents()  # random (arbitrary choice)             # needs sage.graphs
+        ['acb', 'ac', 'ab', 'bc', 'a', 'c', 'b']
+
+    We conclude by running systematic tests on this semigroup::
+
+        sage: TestSuite(S).run(verbose = True)
+        running ._test_an_element() . . . pass
+        running ._test_associativity() . . . pass
+        running ._test_cardinality() . . . pass
+        running ._test_category() . . . pass
+        running ._test_construction() . . . pass
+        running ._test_elements() . . .
+          Running the test suite of self.an_element()
+          running ._test_category() . . . pass
+          running ._test_eq() . . . pass
+          running ._test_new() . . . pass
+          running ._test_not_implemented_methods() . . . pass
+          running ._test_pickling() . . . pass
+          pass
+        running ._test_elements_eq_reflexive() . . . pass
+        running ._test_elements_eq_symmetric() . . . pass
+        running ._test_elements_eq_transitive() . . . pass
+        running ._test_elements_neq() . . . pass
+        running ._test_enumerated_set_contains() . . . pass
+        running ._test_enumerated_set_iter_cardinality() . . . pass
+        running ._test_enumerated_set_iter_list() . . . pass
+        running ._test_eq() . . . pass
+        running ._test_new() . . . pass
+        running ._test_not_implemented_methods() . . . pass
+        running ._test_pickling() . . . pass
+        running ._test_some_elements() . . . pass
+    """
+
+    def __init__(self, alphabet=('a','b','c','d')):
+        r"""
+        A left regular band.
+
+        EXAMPLES::
+
+            sage: S = FiniteSemigroups().example(); S
+            An example of a finite semigroup: the left regular band generated by ('a', 'b', 'c', 'd')
+            sage: S = FiniteSemigroups().example(alphabet=('x','y')); S
+            An example of a finite semigroup: the left regular band generated by ('x', 'y')
+            sage: TestSuite(S).run()
+        """
+        self.alphabet = alphabet
+        Parent.__init__(self,
+                        category=Semigroups().Finite().FinitelyGenerated())
+
+    def _repr_(self):
+        r"""
+        TESTS::
+
+            sage: S = FiniteSemigroups().example()
+            sage: S._repr_()
+            "An example of a finite semigroup: the left regular band generated by ('a', 'b', 'c', 'd')"
+        """
+        return "An example of a finite semigroup: the left regular band generated by %s" % (self.alphabet,)
+
+    def product(self, x, y):
+        r"""
+        Return the product of two elements of the semigroup.
+
+        EXAMPLES::
+
+            sage: S = FiniteSemigroups().example()
+            sage: S('a') * S('b')
+            'ab'
+            sage: S('a') * S('b') * S('a')
+            'ab'
+            sage: S('a') * S('a')
+            'a'
+        """
+        assert x in self
+        assert y in self
+        x = x.value
+        y = y.value
+        return self(x + ''.join(c for c in y if c not in x))
+
+    @cached_method
+    def semigroup_generators(self):
+        r"""
+        Return the generators of the semigroup.
+
+        EXAMPLES::
+
+            sage: S = FiniteSemigroups().example(alphabet=('x','y'))
+            sage: S.semigroup_generators()
+            Family ('x', 'y')
+        """
+        return Family([self(i) for i in self.alphabet])
+
+    def an_element(self):
+        r"""
+        Return an element of the semigroup.
+
+        EXAMPLES::
+
+            sage: S = FiniteSemigroups().example()
+            sage: S.an_element()
+            'cdab'
+
+            sage: S = FiniteSemigroups().example(("b"))
+            sage: S.an_element()
+            'b'
+        """
+
+        return self(''.join(self.alphabet[2:]+self.alphabet[0:2]))
+
+    class Element (ElementWrapper):
+        wrapped_class = str
+        __lt__ = ElementWrapper._lt_by_value
+
+
+Example = LeftRegularBand

sage/categories/examples/finite_weyl_groups.py

@@ -0,0 +1,191 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Examples of finite Weyl groups
+"""
+# ****************************************************************************
+#  Copyright (C) 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.misc.cachefunc import cached_method
+from sage.structure.parent import Parent
+from sage.structure.element_wrapper import ElementWrapper
+from sage.categories.finite_weyl_groups import FiniteWeylGroups
+from sage.structure.unique_representation import UniqueRepresentation
+
+
+class SymmetricGroup(UniqueRepresentation, Parent):
+    r"""
+    An example of finite Weyl group: the symmetric group, with
+    elements in list notation.
+
+    The purpose of this class is to provide a minimal template for
+    implementing finite Weyl groups. See
+    :class:`~sage.groups.perm_gps.permgroup_named.SymmetricGroup` for
+    a full featured and optimized implementation.
+
+    EXAMPLES::
+
+        sage: S = FiniteWeylGroups().example()
+        sage: S
+        The symmetric group on {0, ..., 3}
+        sage: S.category()
+        Category of finite irreducible Weyl groups
+
+    The elements of this group are permutations of the set `\{0,\ldots,3\}`::
+
+        sage: S.one()
+        (0, 1, 2, 3)
+        sage: S.an_element()
+        (1, 2, 3, 0)
+
+    The group itself is generated by the elementary transpositions::
+
+        sage: S.simple_reflections()
+        Finite family {0: (1, 0, 2, 3), 1: (0, 2, 1, 3), 2: (0, 1, 3, 2)}
+
+    Only the following basic operations are implemented:
+
+    - :meth:`.one`
+    - :meth:`.product`
+    - :meth:`.simple_reflection`
+    - :meth:`.cartan_type`
+    - :meth:`.Element.has_right_descent`.
+
+    All the other usual Weyl group operations are inherited from the
+    categories::
+
+        sage: S.cardinality()
+        24
+        sage: S.long_element()
+        (3, 2, 1, 0)
+        sage: S.cayley_graph(side='left').plot()                                        # needs sage.graphs sage.plot
+        Graphics object consisting of 120 graphics primitives
+
+    Alternatively, one could have implemented
+    :meth:`sage.categories.coxeter_groups.CoxeterGroups.ElementMethods.apply_simple_reflection`
+    instead of :meth:`.simple_reflection` and :meth:`.product`. See
+    ``CoxeterGroups().example()``.
+
+    TESTS::
+
+        sage: TestSuite(S).run()
+    """
+
+    def __init__(self, n=4):
+        """
+        EXAMPLES::
+
+            sage: S = sage.categories.examples.finite_weyl_groups.SymmetricGroup(4)
+            sage: S == FiniteWeylGroups().example(4)
+            True
+        """
+        Parent.__init__(self, category=FiniteWeylGroups().Irreducible())
+        self.n = n
+
+    def _repr_(self):
+        """
+        EXAMPLES::
+
+            sage: FiniteWeylGroups().example()
+            The symmetric group on {0, ..., 3}
+        """
+        return "The symmetric group on {0, ..., %s}" % (self.n-1)
+
+    @cached_method
+    def one(self):
+        """
+        Implement :meth:`Monoids.ParentMethods.one`.
+
+        EXAMPLES::
+
+            sage: FiniteWeylGroups().example().one()
+            (0, 1, 2, 3)
+        """
+        return self(tuple(range(self.n)))
+
+    def index_set(self):
+        """
+        Implement :meth:`CoxeterGroups.ParentMethods.index_set`.
+
+        EXAMPLES::
+
+            sage: FiniteWeylGroups().example().index_set()
+            [0, 1, 2]
+        """
+        return list(range(self.n - 1))
+
+    def simple_reflection(self, i):
+        """
+        Implement :meth:`CoxeterGroups.ParentMethods.simple_reflection`
+        by returning the transposition `(i, i+1)`.
+
+        EXAMPLES::
+
+            sage: FiniteWeylGroups().example().simple_reflection(2)
+            (0, 1, 3, 2)
+        """
+        assert i in self.index_set()
+        return self(tuple(range(i)) + (i + 1, i) + tuple(range(i + 2, self.n)))
+
+    def cartan_type(self):
+        """
+        Return the Cartan type of ``self``.
+
+        EXAMPLES::
+
+            sage: FiniteWeylGroups().example().cartan_type()                            # needs sage.modules
+            ['A', 3] relabelled by {1: 0, 2: 1, 3: 2}
+        """
+        from sage.combinat.root_system.cartan_type import CartanType
+        C = CartanType(['A',self.n-1])
+        C = C.relabel(lambda i:i-1)
+        return C
+
+    def product(self, x, y):
+        """
+        Implement :meth:`Semigroups.ParentMethods.product`.
+
+        EXAMPLES::
+
+            sage: s = FiniteWeylGroups().example().simple_reflections()
+            sage: s[1] * s[2]
+            (0, 2, 3, 1)
+        """
+        assert x in self
+        assert y in self
+        return self(tuple(x.value[i] for i in y.value))
+
+    def degrees(self):
+        """
+        Return the degrees of ``self``.
+
+        EXAMPLES::
+
+            sage: W = FiniteWeylGroups().example()
+            sage: W.degrees()
+            (2, 3, 4)
+        """
+        from sage.rings.integer_ring import ZZ
+        return tuple(ZZ(i) for i in range(2, self.n + 1))
+
+    class Element(ElementWrapper):
+
+        def has_right_descent(self, i) -> bool:
+            """
+            Implement :meth:`CoxeterGroups.ElementMethods.has_right_descent`.
+
+            EXAMPLES::
+
+                sage: S = FiniteWeylGroups().example()
+                sage: s = S.simple_reflections()
+                sage: (s[1] * s[2]).has_descent(2)
+                True
+                sage: S._test_has_descent()
+            """
+            return (self.value[i] > self.value[i + 1])
+
+
+Example = SymmetricGroup

sage/categories/examples/graded_connected_hopf_algebras_with_basis.py

@@ -0,0 +1,152 @@
+# sage_setup: distribution = sagemath-categories
+# sage.doctest: needs sage.modules
+r"""
+Examples of graded connected Hopf algebras with basis
+"""
+# ****************************************************************************
+#  Copyright (C) 2015 Jean-Baptiste Priez <jbp@kerios.fr>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+from sage.categories.graded_hopf_algebras_with_basis import GradedHopfAlgebrasWithBasis
+from sage.combinat.free_module import CombinatorialFreeModule
+from sage.rings.integer import Integer
+from sage.misc.cachefunc import cached_method
+from sage.sets.non_negative_integers import NonNegativeIntegers
+
+
+class GradedConnectedCombinatorialHopfAlgebraWithPrimitiveGenerator(CombinatorialFreeModule):
+    r"""
+    This class illustrates an implementation of a graded Hopf algebra
+    with basis that has one primitive generator of degree 1 and basis
+    elements indexed by nonnegative integers.
+
+    This Hopf algebra example differs from what topologists refer to as
+    a graded Hopf algebra because the twist operation in the tensor rule
+    satisfies
+
+    .. MATH::
+
+        (\mu \otimes \mu) \circ (id \otimes \tau \otimes id) \circ
+        (\Delta \otimes \Delta) = \Delta \circ \mu
+
+    where `\tau(x\otimes y) = y\otimes x`.
+    """
+    def __init__(self, base_ring):
+        """
+        EXAMPLES::
+
+            sage: H = GradedHopfAlgebrasWithBasis(QQ).Connected().example()
+            sage: TestSuite(H).run()
+        """
+        CombinatorialFreeModule.__init__(self, base_ring, NonNegativeIntegers(),
+                                         category=GradedHopfAlgebrasWithBasis(base_ring).Connected())
+
+    @cached_method
+    def one_basis(self):
+        """
+        Return 0, which index the unit of the Hopf algebra.
+
+        OUTPUT: the nonnegative integer 0
+
+        EXAMPLES::
+
+            sage: H = GradedHopfAlgebrasWithBasis(QQ).Connected().example()
+            sage: H.one_basis()
+            0
+            sage: H.one()
+            P0
+        """
+        return self.basis().keys()(0)
+
+    def degree_on_basis(self, i):
+        """
+        The degree of a nonnegative integer is itself.
+
+        INPUT:
+
+        - ``i`` -- nonnegative integer
+
+        OUTPUT: nonnegative integer
+
+        TESTS::
+
+            sage: H = GradedHopfAlgebrasWithBasis(QQ).Connected().example()
+            sage: H.degree_on_basis(45)
+            45
+        """
+        return i
+
+    def _repr_(self):
+        """
+        Representation of the graded connected Hopf algebra.
+
+        EXAMPLES::
+
+            sage: GradedHopfAlgebrasWithBasis(QQ).Connected().example()
+            An example of a graded connected Hopf algebra with basis over Rational Field
+        """
+        return "An example of a graded connected Hopf algebra with basis over %s" % self.base_ring()
+
+    def _repr_term(self, i):
+        """
+        Representation for the basis element indexed by the integer ``i``.
+
+        EXAMPLES::
+
+            sage: H = GradedHopfAlgebrasWithBasis(QQ).Connected().example()
+            sage: H._repr_term(45)
+            'P45'
+        """
+        return 'P' + repr(i)
+
+    def product_on_basis(self, i, j):
+        """
+        The product of two basis elements.
+
+        The product of elements of degree ``i`` and ``j`` is an element
+        of degree ``i+j``.
+
+        INPUT:
+
+        - ``i``, ``j`` -- nonnegative integers
+
+        OUTPUT: a basis element indexed by ``i+j``
+
+        TESTS::
+
+            sage: H = GradedHopfAlgebrasWithBasis(QQ).Connected().example()
+            sage: H.monomial(4) * H.monomial(5)
+            P9
+        """
+        return self.monomial(i+j)
+
+    def coproduct_on_basis(self, i):
+        r"""
+        The coproduct of a basis element.
+
+        .. MATH::
+
+            \Delta(P_i) = \sum_{j=0}^i P_{i-j} \otimes P_j
+
+        INPUT:
+
+        - ``i`` -- nonnegative integer
+
+        OUTPUT: an element of the tensor square of ``self``
+
+        TESTS::
+
+            sage: H = GradedHopfAlgebrasWithBasis(QQ).Connected().example()
+            sage: H.monomial(3).coproduct()
+            P0 # P3 + 3*P1 # P2 + 3*P2 # P1 + P3 # P0
+        """
+        return self.sum_of_terms(
+            ((i - j, j), Integer(i).binomial(j))
+            for j in range(i + 1)
+        )
+
+
+Example = GradedConnectedCombinatorialHopfAlgebraWithPrimitiveGenerator