passagemath-categories 10.6.32__cp314-cp314t-musllinux_1_2_aarch64.whl

sage/categories/hopf_algebras.py

@@ -0,0 +1,219 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Hopf algebras
+"""
+# ****************************************************************************
+#  Copyright (C) 2008 Teresa Gomez-Diaz (CNRS) <Teresa.Gomez-Diaz@univ-mlv.fr>
+#                     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.bialgebras import Bialgebras
+from sage.categories.category import Category
+from sage.categories.category_types import Category_over_base_ring
+from sage.categories.realizations import RealizationsCategory
+from sage.categories.super_modules import SuperModulesCategory
+from sage.categories.tensor import TensorProductsCategory  # tensor
+from sage.misc.cachefunc import cached_method
+from sage.misc.lazy_import import LazyImport
+
+
+class HopfAlgebras(Category_over_base_ring):
+    """
+    The category of Hopf algebras.
+
+    EXAMPLES::
+
+        sage: HopfAlgebras(QQ)
+        Category of Hopf algebras over Rational Field
+        sage: HopfAlgebras(QQ).super_categories()
+        [Category of bialgebras over Rational Field]
+
+    TESTS::
+
+        sage: TestSuite(HopfAlgebras(ZZ)).run()
+    """
+    def super_categories(self):
+        """
+        EXAMPLES::
+
+            sage: HopfAlgebras(QQ).super_categories()
+            [Category of bialgebras over Rational Field]
+        """
+        R = self.base_ring()
+        return [Bialgebras(R)]
+
+    def dual(self):
+        """
+        Return the dual category.
+
+        EXAMPLES:
+
+        The category of Hopf algebras over any field is self dual::
+
+            sage: C = HopfAlgebras(QQ)
+            sage: C.dual()
+            Category of Hopf algebras over Rational Field
+        """
+        return self
+
+    WithBasis = LazyImport('sage.categories.hopf_algebras_with_basis', 'HopfAlgebrasWithBasis')
+
+    class ElementMethods:
+
+        def antipode(self):
+            """
+            Return the antipode of ``self``.
+
+            EXAMPLES::
+
+                sage: # needs sage.groups sage.modules
+                sage: A = HopfAlgebrasWithBasis(QQ).example(); A
+                An example of Hopf algebra with basis: the group algebra of the
+                 Dihedral group of order 6 as a permutation group over Rational Field
+                sage: [a,b] = A.algebra_generators()
+                sage: a, a.antipode()
+                (B[(1,2,3)], B[(1,3,2)])
+                sage: b, b.antipode()
+                (B[(1,3)], B[(1,3)])
+
+            TESTS::
+
+                sage: all(x.antipode() * x == A.one() for x in A.basis())               # needs sage.groups sage.modules
+                True
+            """
+            return self.parent().antipode(self)
+            # Variant: delegates to the overloading mechanism
+            # result not guaranteed to be in self
+            # This choice should be done consistently with coproduct, ...
+            # return operator.antipode(self)
+
+    class ParentMethods:
+        # def __setup__(self): # Check the conventions for _setup_ or __setup__
+        #    if self.implements("antipode"):
+        #        coercion.declare(operator.antipode, [self], self.antipode)
+        #
+        # @lazy_attribute
+        # def antipode(self):
+        #    # delegates to the overloading mechanism but
+        #    # guarantees that the result is in self
+        #    compose(self, operator.antipode, domain=self)
+        pass
+
+    class Morphism(Category):
+        """
+        The category of Hopf algebra morphisms.
+        """
+        pass
+
+    class Super(SuperModulesCategory):
+        r"""
+        The category of super Hopf algebras.
+
+        .. NOTE::
+
+            A super Hopf algebra is *not* simply a Hopf
+            algebra with a `\ZZ/2\ZZ` grading due to the
+            signed bialgebra compatibility conditions.
+        """
+        def dual(self):
+            """
+            Return the dual category.
+
+            EXAMPLES:
+
+            The category of super Hopf algebras over any field is self dual::
+
+                sage: C = HopfAlgebras(QQ).Super()
+                sage: C.dual()
+                Category of super Hopf algebras over Rational Field
+            """
+            return self
+
+        class ElementMethods:
+            def antipode(self):
+                """
+                Return the antipode of ``self``.
+
+                EXAMPLES::
+
+                    sage: A = SteenrodAlgebra(3)                                        # needs sage.combinat sage.modules
+                    sage: a = A.an_element()                                            # needs sage.combinat sage.modules
+                    sage: a, a.antipode()                                               # needs sage.combinat sage.modules
+                    (2 Q_1 Q_3 P(2,1), Q_1 Q_3 P(2,1))
+                """
+                return self.parent().antipode(self)
+
+    class TensorProducts(TensorProductsCategory):
+        """
+        The category of Hopf algebras constructed by tensor product of Hopf algebras
+        """
+        @cached_method
+        def extra_super_categories(self):
+            """
+            EXAMPLES::
+
+                sage: C = HopfAlgebras(QQ).TensorProducts()
+                sage: C.extra_super_categories()
+                [Category of Hopf algebras over Rational Field]
+                sage: sorted(C.super_categories(), key=str)
+                [Category of Hopf algebras over Rational Field,
+                 Category of tensor products of algebras over Rational Field,
+                 Category of tensor products of coalgebras over Rational Field]
+            """
+            return [self.base_category()]
+
+        class ParentMethods:
+            # TODO: enable when tensor product of morphisms will be implemented
+            # @lazy_attribute
+            # def antipode(self):
+            #    return tensor([module.antipode for module in self.modules])
+            pass
+
+        class ElementMethods:
+            pass
+
+    class DualCategory(Category_over_base_ring):
+        """
+        The category of Hopf algebras constructed as dual of a Hopf algebra
+        """
+
+        class ParentMethods:
+            # @lazy_attribute
+            # def antipode(self):
+            #    self.dual().antipode.dual() # Check that this is the correct formula
+            pass
+
+    class Realizations(RealizationsCategory):
+
+        class ParentMethods:
+
+            # TODO:
+            # - Use @conditionally_defined once it's in Sage, for a nicer idiom
+            # - Do the right thing (TM): once we will have proper
+            #   overloaded operators (as in MuPAD-Combinat; see #8900),
+            #   we won't need to specify explicitly to which parent one
+            #   should coerce the input to calculate the antipode; so it
+            #   will be sufficient to put this default implementation in
+            #   HopfAlgebras.ParentMethods.
+            def antipode_by_coercion(self, x):
+                """
+                Return the image of ``x`` by the antipode.
+
+                This default implementation coerces to the default
+                realization, computes the antipode there, and coerces the
+                result back.
+
+                EXAMPLES::
+
+                    sage: # needs sage.combinat sage.modules
+                    sage: N = NonCommutativeSymmetricFunctions(QQ)
+                    sage: R = N.ribbon()
+                    sage: R.antipode_by_coercion.__module__
+                    'sage.categories.hopf_algebras'
+                    sage: R.antipode_by_coercion(R[1,3,1])
+                    -R[2, 1, 2]
+                """
+                R = self.realization_of().a_realization()
+                return self(R(x).antipode())

sage/categories/hopf_algebras_with_basis.py

@@ -0,0 +1,309 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Hopf algebras with basis
+"""
+# ****************************************************************************
+#  Copyright (C) 2008 Teresa Gomez-Diaz (CNRS) <Teresa.Gomez-Diaz@univ-mlv.fr>
+#  Copyright (C) 2008-2011 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_over_base_ring
+from sage.categories.tensor import TensorProductsCategory
+from sage.misc.abstract_method import abstract_method
+from sage.misc.cachefunc import cached_method
+from sage.misc.lazy_attribute import lazy_attribute
+from sage.misc.lazy_import import LazyImport
+
+
+class HopfAlgebrasWithBasis(CategoryWithAxiom_over_base_ring):
+    """
+    The category of Hopf algebras with a distinguished basis.
+
+    EXAMPLES::
+
+        sage: C = HopfAlgebrasWithBasis(QQ)
+        sage: C
+        Category of Hopf algebras with basis over Rational Field
+        sage: C.super_categories()
+        [Category of Hopf algebras over Rational Field,
+         Category of bialgebras with basis over Rational Field]
+
+    We now show how to use a simple Hopf algebra, namely the group algebra of the dihedral group
+    (see also AlgebrasWithBasis)::
+
+        sage: # needs sage.groups sage.modules
+        sage: A = C.example(); A
+        An example of Hopf algebra with basis: the group algebra of the
+         Dihedral group of order 6 as a permutation group over Rational Field
+        sage: A.rename('A')
+        sage: A.category()
+        Category of finite dimensional Hopf algebras with basis over Rational Field
+        sage: A.one_basis()
+        ()
+        sage: A.one()
+        B[()]
+        sage: A.base_ring()
+        Rational Field
+        sage: A.basis().keys()
+        Dihedral group of order 6 as a permutation group
+
+        sage: # needs sage.groups sage.modules
+        sage: [a,b] = A.algebra_generators()
+        sage: a, b
+        (B[(1,2,3)], B[(1,3)])
+        sage: a^3, b^2
+        (B[()], B[()])
+        sage: a*b
+        B[(1,2)]
+
+        sage: A.product           # todo: not quite ...                                 # needs sage.groups sage.modules
+        <bound method MagmaticAlgebras.WithBasis.ParentMethods._product_from_product_on_basis_multiply of A>
+        sage: A.product(b, b)                                                           # needs sage.groups sage.modules
+        B[()]
+
+        sage: A.zero().coproduct()                                                      # needs sage.groups sage.modules
+        0
+        sage: A.zero().coproduct().parent()                                             # needs sage.groups sage.modules
+        A # A
+        sage: a.coproduct()                                                             # needs sage.groups sage.modules
+        B[(1,2,3)] # B[(1,2,3)]
+
+        sage: TestSuite(A).run(verbose=True)                                            # needs sage.groups sage.modules
+        running ._test_additive_associativity() . . . pass
+        running ._test_an_element() . . . pass
+        running ._test_antipode() . . . pass
+        running ._test_associativity() . . . pass
+        running ._test_cardinality() . . . pass
+        running ._test_category() . . . pass
+        running ._test_characteristic() . . . pass
+        running ._test_construction() . . . pass
+        running ._test_distributivity() . . . pass
+        running ._test_elements() . . .
+          Running the test suite of self.an_element()
+          running ._test_category() . . . pass
+          running ._test_eq() . . . pass
+          running ._test_monomial_coefficients() . . . pass
+          running ._test_new() . . . pass
+          running ._test_nonzero_equal() . . . 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_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
+        running ._test_zero() . . . pass
+        sage: A.__class__                                                               # needs sage.groups sage.modules
+        <class 'sage.categories.examples.hopf_algebras_with_basis.MyGroupAlgebra_with_category'>
+        sage: A.element_class                                                           # needs sage.groups sage.modules
+        <class 'sage.categories.examples.hopf_algebras_with_basis.MyGroupAlgebra_with_category.element_class'>
+
+    Let us look at the code for implementing A::
+
+        sage: A??                               # not implemented                       # needs sage.groups sage.modules
+
+    TESTS::
+
+        sage: TestSuite(A).run()                                                        # needs sage.groups sage.modules
+        sage: TestSuite(C).run()
+    """
+
+    def example(self, G=None):
+        """
+        Return an example of algebra with basis::
+
+            sage: HopfAlgebrasWithBasis(QQ['x']).example()                              # needs sage.groups sage.modules
+            An example of Hopf algebra with basis: the group algebra of the
+            Dihedral group of order 6 as a permutation group
+            over Univariate Polynomial Ring in x over Rational Field
+
+        An other group can be specified as optional argument::
+
+            sage: HopfAlgebrasWithBasis(QQ).example(SymmetricGroup(4))                  # needs sage.groups sage.modules
+            An example of Hopf algebra with basis: the group algebra of the
+            Symmetric group of order 4! as a permutation group over Rational Field
+        """
+        from sage.categories.examples.hopf_algebras_with_basis import MyGroupAlgebra
+        from sage.groups.perm_gps.permgroup_named import DihedralGroup
+        if G is None:
+            G = DihedralGroup(3)
+        return MyGroupAlgebra(self.base_ring(), G)
+
+#     This is only correct in the finite dimensional / graded case
+#     def dual(self):
+#         """
+#         Returns the dual category
+
+#         EXAMPLES:
+
+#         The category of Hopf algebras over any field is self dual::
+
+#             sage: C = HopfAlgebrasWithBasis(QQ)
+#             sage: C.dual()
+#             Category of Hopf algebras with basis over Rational Field
+#         """
+#         return self
+
+    FiniteDimensional = LazyImport('sage.categories.finite_dimensional_hopf_algebras_with_basis',
+                                   'FiniteDimensionalHopfAlgebrasWithBasis')
+    Filtered = LazyImport('sage.categories.filtered_hopf_algebras_with_basis',
+                          'FilteredHopfAlgebrasWithBasis')
+    Graded = LazyImport('sage.categories.graded_hopf_algebras_with_basis',
+                        'GradedHopfAlgebrasWithBasis')
+    Super = LazyImport('sage.categories.super_hopf_algebras_with_basis',
+                       'SuperHopfAlgebrasWithBasis')
+
+    class ParentMethods:
+
+        @abstract_method(optional=True)
+        def antipode_on_basis(self, x):
+            """
+            The antipode of the Hopf algebra on the basis (optional).
+
+            INPUT:
+
+            - ``x`` -- an index of an element of the basis of ``self``
+
+            Returns the antipode of the basis element indexed by ``x``.
+
+            If this method is implemented, then :meth:`antipode` is defined
+            from this by linearity.
+
+            EXAMPLES::
+
+                sage: # needs sage.groups sage.modules
+                sage: A = HopfAlgebrasWithBasis(QQ).example()
+                sage: W = A.basis().keys(); W
+                Dihedral group of order 6 as a permutation group
+                sage: w = W.gen(0); w
+                (1,2,3)
+                sage: A.antipode_on_basis(w)
+                B[(1,3,2)]
+            """
+
+        @lazy_attribute
+        def antipode(self):
+            """
+            The antipode of this Hopf algebra.
+
+            If :meth:`.antipode_basis` is available, this constructs the
+            antipode morphism from ``self`` to ``self`` by extending it by
+            linearity. Otherwise, :meth:`self.antipode_by_coercion` is used, if
+            available.
+
+            EXAMPLES::
+
+                sage: # needs sage.groups sage.modules
+                sage: A = HopfAlgebrasWithBasis(ZZ).example(); A
+                An example of Hopf algebra with basis: the group algebra of the
+                 Dihedral group of order 6 as a permutation group over Integer Ring
+                sage: A = HopfAlgebrasWithBasis(QQ).example()
+                sage: [a,b] = A.algebra_generators()
+                sage: a, A.antipode(a)
+                (B[(1,2,3)], B[(1,3,2)])
+                sage: b, A.antipode(b)
+                (B[(1,3)], B[(1,3)])
+
+            TESTS::
+
+                sage: all(A.antipode(x) * x == A.one() for x in A.basis())              # needs sage.groups sage.modules
+                True
+            """
+            if self.antipode_on_basis is not NotImplemented:
+                # Should give the information that this is an anti-morphism of algebra
+                return self._module_morphism(self.antipode_on_basis,
+                                             codomain=self)
+            elif hasattr(self, "antipode_by_coercion"):
+                return self.antipode_by_coercion
+
+        def _test_antipode(self, **options):
+            r"""
+            Test the antipode.
+
+            An *antipode* `S` of a Hopf algebra is a linear endomorphism of the
+            Hopf algebra that satisfies the following conditions (see
+            :wikipedia:`HopfAlgebra`).
+
+            - If `\mu` and `\Delta` denote the product and coproduct of the
+              Hopf algebra, respectively, then `S` satisfies
+
+              .. MATH::
+
+                  \mu \circ (S \tensor 1) \circ \Delta = unit \circ counit
+                  \mu \circ (1 \tensor S) \circ \Delta = unit \circ counit
+
+            - `S` is an *anti*-homomorphism
+
+            These properties are tested on :meth:`some_elements`.
+
+            TESTS::
+
+                sage: R = NonCommutativeSymmetricFunctions(QQ).ribbon()                 # needs sage.combinat sage.modules
+                sage: R._test_antipode()                                                # needs sage.combinat sage.modules
+
+            ::
+
+                sage: s = SymmetricFunctions(QQ).schur()                                # needs sage.combinat sage.modules
+                sage: s._test_antipode()                                                # needs lrcalc_python sage.combinat sage.modules
+            """
+            tester = self._tester(**options)
+
+            S = self.antipode
+
+            IS = lambda x: self.sum(c * self.monomial(t1) * S(self.monomial(t2))
+                                for ((t1, t2), c) in x.coproduct())
+
+            SI = lambda x: self.sum(c * S(self.monomial(t1)) * self.monomial(t2)
+                                for ((t1, t2), c) in x.coproduct())
+
+            for x in tester.some_elements():
+
+                # antipode is an anti-homomorphism
+                for y in tester.some_elements():
+                    tester.assertEqual(S(x) * S(y), S(y * x))
+
+                # mu * (S # I) * delta == counit * unit
+                tester.assertEqual(SI(x), self.counit(x) * self.one())
+
+                # mu * (I # S) * delta == counit * unit
+                tester.assertEqual(IS(x), self.counit(x) * self.one())
+
+    class ElementMethods:
+        pass
+
+    class TensorProducts(TensorProductsCategory):
+        """
+        The category of Hopf algebras with basis constructed by tensor product of Hopf algebras with basis
+        """
+
+        @cached_method
+        def extra_super_categories(self):
+            """
+            EXAMPLES::
+
+                sage: C = HopfAlgebrasWithBasis(QQ).TensorProducts()
+                sage: C.extra_super_categories()
+                [Category of Hopf algebras with basis over Rational Field]
+                sage: sorted(C.super_categories(), key=str)
+                [Category of Hopf algebras with basis over Rational Field,
+                 Category of tensor products of Hopf algebras over Rational Field,
+                 Category of tensor products of algebras with basis over Rational Field]
+            """
+            return [self.base_category()]
+
+        class ParentMethods:
+            # todo: antipode
+            pass
+
+        class ElementMethods:
+            pass

sage/categories/infinite_enumerated_sets.py

@@ -0,0 +1,115 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Infinite Enumerated Sets
+
+AUTHORS:
+
+ - Florent Hivert (2009-11): initial revision.
+"""
+# ****************************************************************************
+#  Copyright (C) 2009 Florent Hivert <Florent.Hivert@univ-rouen.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
+
+
+class InfiniteEnumeratedSets(CategoryWithAxiom):
+    """
+    The category of infinite enumerated sets.
+
+    An infinite enumerated sets is a countable set together with a
+    canonical enumeration of its elements.
+
+    EXAMPLES::
+
+        sage: InfiniteEnumeratedSets()
+        Category of infinite enumerated sets
+        sage: InfiniteEnumeratedSets().super_categories()
+        [Category of enumerated sets, Category of infinite sets]
+        sage: InfiniteEnumeratedSets().all_super_categories()
+        [Category of infinite enumerated sets,
+         Category of enumerated sets,
+         Category of infinite sets,
+         Category of sets,
+         Category of sets with partial maps,
+         Category of objects]
+
+    TESTS::
+
+        sage: C = InfiniteEnumeratedSets()
+        sage: TestSuite(C).run()
+    """
+
+    class ParentMethods:
+
+        def random_element(self):
+            """
+            Raise an error because ``self`` is an infinite enumerated set.
+
+            EXAMPLES::
+
+                sage: NN = InfiniteEnumeratedSets().example()
+                sage: NN.random_element()
+                Traceback (most recent call last):
+                ...
+                NotImplementedError: infinite set
+
+            TODO: should this be an optional abstract_method instead?
+            """
+            raise NotImplementedError("infinite set")
+
+        def tuple(self):
+            """
+            Raise an error because ``self`` is an infinite enumerated set.
+
+            EXAMPLES::
+
+                sage: NN = InfiniteEnumeratedSets().example()
+                sage: NN.tuple()
+                Traceback (most recent call last):
+                ...
+                NotImplementedError: cannot list an infinite set
+            """
+            raise NotImplementedError("cannot list an infinite set")
+
+        def list(self):
+            """
+            Raise an error because ``self`` is an infinite enumerated set.
+
+            EXAMPLES::
+
+                sage: NN = InfiniteEnumeratedSets().example()
+                sage: NN.list()
+                Traceback (most recent call last):
+                ...
+                NotImplementedError: cannot list an infinite set
+            """
+            raise NotImplementedError("cannot list an infinite set")
+        _list_default = list # needed by the check system.
+
+        def _test_enumerated_set_iter_cardinality(self, **options):
+            """
+            Check that the methods :meth:`.cardinality` and
+            :meth:`.__iter__` are consistent.
+
+            See also :class:`TestSuite`.
+
+            For infinite enumerated sets:
+
+            * :meth:`.cardinality` is supposed to return ``infinity``
+
+            * :meth:`.list` is supposed to raise a :exc:`NotImplementedError`.
+
+            EXAMPLES::
+
+                sage: NN = InfiniteEnumeratedSets().example()
+                sage: NN._test_enumerated_set_iter_cardinality()
+            """
+            tester = self._tester(**options)
+            from sage.rings.infinity import infinity
+            tester.assertEqual(self.cardinality(), infinity)
+            tester.assertRaises(NotImplementedError, self.list)