passagemath-categories 10.6.32__cp314-cp314t-musllinux_1_2_aarch64.whl

sage/categories/graded_algebras_with_basis.py

@@ -0,0 +1,258 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Graded algebras with basis
+"""
+#*****************************************************************************
+#  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, tensor_signed
+from sage.misc.cachefunc import cached_method
+from sage.categories.category_with_axiom import CategoryWithAxiom_over_base_ring
+
+
+class GradedAlgebrasWithBasis(GradedModulesCategory):
+    """
+    The category of graded algebras with a distinguished basis.
+
+    EXAMPLES::
+
+        sage: C = GradedAlgebrasWithBasis(ZZ); C
+        Category of graded algebras with basis over Integer Ring
+        sage: sorted(C.super_categories(), key=str)
+        [Category of filtered algebras with basis over Integer Ring,
+         Category of graded algebras over Integer Ring,
+         Category of graded modules with basis over Integer Ring]
+
+    TESTS::
+
+        sage: TestSuite(C).run()
+    """
+    class ParentMethods:
+        # This needs to be copied in GradedAlgebras because we need to have
+        #   FilteredAlgebrasWithBasis as an extra super category
+        def graded_algebra(self):
+            """
+            Return the associated graded algebra to ``self``.
+
+            This is ``self``, because ``self`` is already graded.
+            See :meth:`~sage.categories.filtered_algebras_with_basis.FilteredAlgebrasWithBasis.graded_algebra`
+            for the general behavior of this method, and see
+            :class:`~sage.algebras.associated_graded.AssociatedGradedAlgebra`
+            for the definition and properties of associated graded
+            algebras.
+
+            EXAMPLES::
+
+                sage: m = SymmetricFunctions(QQ).m()                                    # needs sage.combinat sage.modules
+                sage: m.graded_algebra() is m                                           # needs sage.combinat sage.modules
+                True
+
+            TESTS:
+
+            Let us check that the three methods
+            :meth:`to_graded_conversion`, :meth:`from_graded_conversion`
+            and :meth:`projection` (which form the interface of the
+            associated graded algebra) work correctly here::
+
+                sage: # needs sage.combinat sage.modules
+                sage: to_gr = m.to_graded_conversion()
+                sage: from_gr = m.from_graded_conversion()
+                sage: m[2] == to_gr(m[2]) == from_gr(m[2])
+                True
+                sage: u = 3*m[1] - (1/2)*m[3]
+                sage: u == to_gr(u) == from_gr(u)
+                True
+                sage: m.zero() == to_gr(m.zero()) == from_gr(m.zero())
+                True
+                sage: p2 = m.projection(2)
+                sage: p2(m[2] - 4*m[1,1] + 3*m[1] - 2*m[[]])
+                -4*m[1, 1] + m[2]
+                sage: p2(4*m[1])
+                0
+                sage: p2(m.zero()) == m.zero()
+                True
+            """
+            return self
+
+        # .. TODO::
+        # Possibly override ``to_graded_conversion`` and
+        # ``from_graded_conversion`` with identity morphisms?
+        # I have to admit I don't know the right way to construct
+        # identity morphisms other than using the identity matrix.
+        # Also, ``projection`` could be overridden by, well, a
+        # projection.
+
+        def free_graded_module(self, generator_degrees, names=None):
+            """
+            Create a finitely generated free graded module over ``self``.
+
+            INPUT:
+
+            - ``generator_degrees`` -- tuple of integers defining the
+              number of generators of the module and their degrees
+
+            - ``names`` -- (optional) the names of the generators. If
+              ``names`` is a comma-separated string like ``'a, b,
+              c'``, then those will be the names. Otherwise, for
+              example if ``names`` is ``abc``, then the names will be
+              ``abc[d,i]``.
+
+            By default, if all generators are in distinct degrees,
+            then the ``names`` of the generators will have the form
+            ``g[d]`` where ``d`` is the degree of the generator. If
+            the degrees are not distinct, then the generators will be
+            called ``g[d,i]`` where ``d`` is the degree and ``i`` is
+            its index in the list of generators in that degree.
+
+            See :mod:`sage.modules.fp_graded.free_module` for more
+            examples and details.
+
+            EXAMPLES::
+
+                sage: # needs sage.combinat sage.modules
+                sage: Q = QuadraticForm(QQ, 3, [1,2,3,4,5,6])
+                sage: Cl = CliffordAlgebra(Q)
+                sage: M = Cl.free_graded_module((0, 2, 3))
+                sage: M.gens()
+                (g[0], g[2], g[3])
+                sage: N.<xy, z> = Cl.free_graded_module((1, 2))
+                sage: N.generators()
+                (xy, z)
+            """
+            try:
+                return self._free_graded_module_class(self, generator_degrees, names=names)
+            except AttributeError:
+                from sage.modules.fp_graded.free_module import FreeGradedModule
+                return FreeGradedModule(self, generator_degrees, names=names)
+
+        def formal_series_ring(self):
+            r"""
+            Return the completion of all formal linear combinations of
+            ``self`` with finite linear combinations in each homogeneous
+            degree (computed lazily).
+
+            EXAMPLES::
+
+                sage: # needs sage.combinat sage.modules
+                sage: NCSF = NonCommutativeSymmetricFunctions(QQ)
+                sage: S = NCSF.Complete()
+                sage: L = S.formal_series_ring()
+                sage: L
+                Lazy completion of Non-Commutative Symmetric Functions over
+                 the Rational Field in the Complete basis
+            """
+            from sage.rings.lazy_series_ring import LazyCompletionGradedAlgebra
+            return LazyCompletionGradedAlgebra(self)
+
+        completion = formal_series_ring
+
+    class ElementMethods:
+        pass
+
+    class FiniteDimensional(CategoryWithAxiom_over_base_ring):
+        class ParentMethods:
+            @cached_method
+            def top_degree(self):
+                r"""
+                Return the top degree of the finite dimensional graded algebra.
+
+                EXAMPLES::
+
+                    sage: # needs sage.graphs sage.modules
+                    sage: ch = matroids.Uniform(4,6).chow_ring(QQ, False)
+                    sage: ch.top_degree()
+                    3
+                    sage: ch = matroids.Wheel(3).chow_ring(QQ, True, 'atom-free')
+                    sage: ch.top_degree()
+                    3
+                """
+                return max(b.degree() for b in self.basis())
+
+    class SignedTensorProducts(SignedTensorProductsCategory):
+        """
+        The category of algebras with basis constructed by signed tensor
+        product of algebras with basis.
+        """
+        @cached_method
+        def extra_super_categories(self):
+            """
+            EXAMPLES::
+
+                sage: Cat = AlgebrasWithBasis(QQ).Graded()
+                sage: Cat.SignedTensorProducts().extra_super_categories()
+                [Category of graded algebras with basis over Rational Field]
+                sage: Cat.SignedTensorProducts().super_categories()
+                [Category of graded algebras with basis over Rational Field,
+                 Category of signed tensor products of graded algebras over Rational Field]
+            """
+            return [self.base_category()]
+
+        class ParentMethods:
+            """
+            Implement operations on tensor products of super algebras
+            with basis.
+            """
+            @cached_method
+            def one_basis(self):
+                """
+                Return the index of the one of this signed tensor product of
+                algebras, as per ``AlgebrasWithBasis.ParentMethods.one_basis``.
+
+                It is the tuple whose operands are the indices of the
+                ones of the operands, as returned by their
+                :meth:`.one_basis` methods.
+
+                EXAMPLES::
+
+                    sage: # needs sage.combinat sage.modules
+                    sage: A.<x,y> = ExteriorAlgebra(QQ)
+                    sage: A.one_basis()
+                    0
+                    sage: B = tensor((A, A, A))
+                    sage: B.one_basis()
+                    (0, 0, 0)
+                    sage: B.one()
+                    1 # 1 # 1
+                """
+                # FIXME: this method should be conditionally defined,
+                # so that B.one_basis returns NotImplemented if not
+                # all modules provide one_basis
+                if all(hasattr(module, "one_basis") for module in self._sets):
+                    return tuple(module.one_basis() for module in self._sets)
+                else:
+                    raise NotImplementedError
+
+            def product_on_basis(self, t0, t1):
+                """
+                The product of the algebra on the basis, as per
+                ``AlgebrasWithBasis.ParentMethods.product_on_basis``.
+
+                EXAMPLES:
+
+                Test the sign in the super tensor product::
+
+                    sage: # needs sage.combinat sage.modules
+                    sage: A = SteenrodAlgebra(3)
+                    sage: x = A.Q(0)
+                    sage: y = x.coproduct()
+                    sage: y^2
+                    0
+
+                TODO: optimize this implementation!
+                """
+                basic = tensor_signed(module.monomial(x0) * module.monomial(x1)
+                                      for (module, x0, x1) in zip(self._sets, t0, t1))
+                n = len(self._sets)
+                parity0 = [self._sets[idx].degree_on_basis(x0)
+                           for (idx, x0) in enumerate(t0)]
+                parity1 = [self._sets[idx].degree_on_basis(x1)
+                           for (idx, x1) in enumerate(t1)]
+                parity = sum(parity0[i] * parity1[j]
+                             for j in range(n) for i in range(j+1,n))
+                return (-1)**parity * basic

sage/categories/graded_bialgebras.py

@@ -0,0 +1,32 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Graded bialgebras
+"""
+#*****************************************************************************
+#  Copyright (C) 2008 Teresa Gomez-Diaz (CNRS) <Teresa.Gomez-Diaz@univ-mlv.fr>
+#                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/
+#******************************************************************************
+
+
+def GradedBialgebras(base_ring):
+    """
+    The category of graded bialgebras.
+
+    EXAMPLES::
+
+        sage: C = GradedBialgebras(QQ); C
+        Join of Category of graded algebras over Rational Field
+            and Category of bialgebras over Rational Field
+            and Category of graded coalgebras over Rational Field
+        sage: C is Bialgebras(QQ).Graded()
+        True
+
+    TESTS::
+
+        sage: TestSuite(C).run()
+    """
+    from sage.categories.bialgebras import Bialgebras
+    return Bialgebras(base_ring).Graded()

sage/categories/graded_bialgebras_with_basis.py

@@ -0,0 +1,32 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Graded bialgebras with basis
+"""
+#*****************************************************************************
+#  Copyright (C) 2008 Teresa Gomez-Diaz (CNRS) <Teresa.Gomez-Diaz@univ-mlv.fr>
+#                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/
+#******************************************************************************
+
+
+def GradedBialgebrasWithBasis(base_ring):
+    """
+    The category of graded bialgebras with a distinguished basis.
+
+    EXAMPLES::
+
+        sage: C = GradedBialgebrasWithBasis(QQ); C
+        Join of Category of ...
+        sage: sorted(C.super_categories(), key=str)
+        [Category of bialgebras with basis over Rational Field,
+         Category of graded algebras with basis over Rational Field,
+         Category of graded coalgebras with basis over Rational Field]
+
+    TESTS::
+
+        sage: TestSuite(C).run()
+    """
+    from sage.categories.bialgebras_with_basis import BialgebrasWithBasis
+    return BialgebrasWithBasis(base_ring).Graded()

sage/categories/graded_coalgebras.py

@@ -0,0 +1,65 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Graded Coalgebras
+"""
+#*****************************************************************************
+#  Copyright (C) 2008      Teresa Gomez-Diaz (CNRS) <Teresa.Gomez-Diaz@univ-mlv.fr>
+#                2011-2013 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 GradedCoalgebras(GradedModulesCategory):
+    """
+    The category of graded coalgebras.
+
+    EXAMPLES::
+
+        sage: C = GradedCoalgebras(QQ); C
+        Category of graded coalgebras over Rational Field
+        sage: C is Coalgebras(QQ).Graded()
+        True
+
+    TESTS::
+
+        sage: TestSuite(C).run()
+    """
+    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: CoalgebrasWithBasis(QQ).Graded().SignedTensorProducts()
+                Category of signed tensor products of graded coalgebras with basis
+                 over Rational Field
+            """
+            return SignedTensorProductsCategory.category_of(self)
+
+    class SignedTensorProducts(SignedTensorProductsCategory):
+        @cached_method
+        def extra_super_categories(self):
+            """
+            EXAMPLES::
+
+                sage: Coalgebras(QQ).Graded().SignedTensorProducts().extra_super_categories()
+                [Category of graded coalgebras over Rational Field]
+                sage: Coalgebras(QQ).Graded().SignedTensorProducts().super_categories()
+                [Category of graded coalgebras over Rational Field]
+
+            Meaning: a signed tensor product of coalgebras is a coalgebra
+            """
+            return [self.base_category()]

sage/categories/graded_coalgebras_with_basis.py

@@ -0,0 +1,51 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Graded coalgebras with basis
+"""
+#*****************************************************************************
+#  Copyright (C) 2008 Teresa Gomez-Diaz (CNRS) <Teresa.Gomez-Diaz@univ-mlv.fr>
+#                2011 Nicolas M. Thiery <nthiery at users.sf.net>
+#                2019 Travis Scrimshaw <tcscrims at gmail.com>
+#
+#  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.categories.graded_modules import GradedModulesCategory
+from sage.categories.signed_tensor import SignedTensorProductsCategory
+
+
+class GradedCoalgebrasWithBasis(GradedModulesCategory):
+    """
+    The category of graded coalgebras with a distinguished basis.
+
+    EXAMPLES::
+
+        sage: C = GradedCoalgebrasWithBasis(QQ); C
+        Category of graded coalgebras with basis over Rational Field
+        sage: C is Coalgebras(QQ).WithBasis().Graded()
+        True
+
+    TESTS::
+
+        sage: TestSuite(C).run()
+    """
+    class SignedTensorProducts(SignedTensorProductsCategory):
+        """
+        The category of coalgebras with basis constructed by signed tensor
+        product of coalgebras with basis.
+        """
+        @cached_method
+        def extra_super_categories(self):
+            """
+            EXAMPLES::
+
+                sage: Cat = CoalgebrasWithBasis(QQ).Graded()
+                sage: Cat.SignedTensorProducts().extra_super_categories()
+                [Category of graded coalgebras with basis over Rational Field]
+                sage: Cat.SignedTensorProducts().super_categories()
+                [Category of graded coalgebras with basis over Rational Field,
+                 Category of signed tensor products of graded coalgebras over Rational Field]
+            """
+            return [self.base_category()]

sage/categories/graded_hopf_algebras.py

@@ -0,0 +1,41 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Graded Hopf 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)
+#                  https://www.gnu.org/licenses/
+# *****************************************************************************
+
+
+def GradedHopfAlgebras(base_ring):
+    r"""
+    The category of graded Hopf algebras.
+
+    EXAMPLES::
+
+        sage: C = GradedHopfAlgebras(QQ); C
+        Join of Category of Hopf algebras over Rational Field
+            and Category of graded algebras over Rational Field
+            and Category of graded coalgebras over Rational Field
+        sage: C is HopfAlgebras(QQ).Graded()
+        True
+
+    TESTS::
+
+        sage: TestSuite(C).run()
+
+    .. NOTE::
+
+        This is not a graded Hopf algebra as is typically defined
+        in algebraic topology as the product in the tensor square
+        `(x \otimes y) (a \otimes b) = (xa) \otimes (yb)` does
+        not carry an additional sign. For this, instead use
+        :class:`super Hopf algebras
+        <sage.categories.hopf_algebras.HopfAlgebras.Super>`.
+    """
+    from sage.categories.hopf_algebras import HopfAlgebras
+    return HopfAlgebras(base_ring).Graded()

sage/categories/graded_hopf_algebras_with_basis.py

@@ -0,0 +1,169 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Graded Hopf algebras with basis
+"""
+#*****************************************************************************
+#  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.category_with_axiom import CategoryWithAxiom_over_base_ring
+from sage.categories.tensor import tensor
+from sage.categories.graded_modules import GradedModulesCategory
+from sage.categories.with_realizations import WithRealizationsCategory
+from sage.misc.cachefunc import cached_method
+
+
+class GradedHopfAlgebrasWithBasis(GradedModulesCategory):
+    """
+    The category of graded Hopf algebras with a distinguished basis.
+
+    EXAMPLES::
+
+        sage: C = GradedHopfAlgebrasWithBasis(ZZ); C
+        Category of graded Hopf algebras with basis over Integer Ring
+        sage: C.super_categories()
+        [Category of filtered Hopf algebras with basis over Integer Ring,
+         Category of graded algebras with basis over Integer Ring,
+         Category of graded coalgebras with basis over Integer Ring]
+
+        sage: C is HopfAlgebras(ZZ).WithBasis().Graded()
+        True
+        sage: C is HopfAlgebras(ZZ).Graded().WithBasis()
+        False
+
+    TESTS::
+
+        sage: TestSuite(C).run()
+    """
+    def example(self):
+        """
+        Return an example of a graded Hopf algebra with
+        a distinguished basis.
+
+        TESTS::
+
+            sage: GradedHopfAlgebrasWithBasis(QQ).example()                             # needs sage.modules
+            An example of a graded connected Hopf algebra with basis over Rational Field
+        """
+        from sage.categories.examples.graded_connected_hopf_algebras_with_basis import \
+            GradedConnectedCombinatorialHopfAlgebraWithPrimitiveGenerator
+        return GradedConnectedCombinatorialHopfAlgebraWithPrimitiveGenerator(self.base())
+
+    class ParentMethods:
+        pass
+
+    class ElementMethods:
+        pass
+
+    class WithRealizations(WithRealizationsCategory):
+        @cached_method
+        def super_categories(self):
+            """
+            EXAMPLES::
+
+                sage: GradedHopfAlgebrasWithBasis(QQ).WithRealizations().super_categories()
+                [Join of Category of Hopf algebras over Rational Field
+                 and Category of graded algebras over Rational Field
+                 and Category of graded coalgebras over Rational Field]
+
+            TESTS::
+
+                sage: TestSuite(GradedHopfAlgebrasWithBasis(QQ).WithRealizations()).run()
+            """
+            from sage.categories.graded_hopf_algebras import GradedHopfAlgebras
+            R = self.base_category().base_ring()
+            return [GradedHopfAlgebras(R)]
+
+    class Connected(CategoryWithAxiom_over_base_ring):
+        def example(self):
+            """
+            Return an example of a graded connected Hopf algebra with
+            a distinguished basis.
+
+            TESTS::
+
+                sage: GradedHopfAlgebrasWithBasis(QQ).Connected().example()             # needs sage.modules
+                An example of a graded connected Hopf algebra with basis over Rational Field
+            """
+            from sage.categories.examples.graded_connected_hopf_algebras_with_basis import \
+                GradedConnectedCombinatorialHopfAlgebraWithPrimitiveGenerator
+            return GradedConnectedCombinatorialHopfAlgebraWithPrimitiveGenerator(self.base())
+
+        class ParentMethods:
+            def counit_on_basis(self, i):
+                r"""
+                The default counit of a graded connected Hopf algebra.
+
+                INPUT:
+
+                - ``i`` -- an element of the index set
+
+                OUTPUT: an element of the base ring
+
+                .. MATH::
+
+                    c(i) := \begin{cases}
+                    1 & \hbox{if $i$ indexes the $1$ of the algebra}\\
+                    0 & \hbox{otherwise}.
+                    \end{cases}
+
+                EXAMPLES::
+
+                    sage: H = GradedHopfAlgebrasWithBasis(QQ).Connected().example()     # needs sage.modules
+                    sage: H.monomial(4).counit()  # indirect doctest                    # needs sage.modules
+                    0
+                    sage: H.monomial(0).counit()  # indirect doctest                    # needs sage.modules
+                    1
+                """
+                if i == self.one_basis():
+                    return self.base_ring().one()
+                return self.base_ring().zero()
+
+            @cached_method
+            def antipode_on_basis(self, index):
+                r"""
+                The antipode on the basis element indexed by ``index``.
+
+                INPUT:
+
+                - ``index`` -- an element of the index set
+
+                For a graded connected Hopf algebra, we can define
+                an antipode recursively by
+
+                .. MATH::
+
+                    S(x) := -\sum_{x^L \neq x} S(x^L) \times x^R
+
+                when `|x| > 0`, and by `S(x) = x` when `|x| = 0`.
+
+                TESTS::
+
+                    sage: # needs sage.modules
+                    sage: H = GradedHopfAlgebrasWithBasis(QQ).Connected().example()
+                    sage: H.monomial(0).antipode()  # indirect doctest
+                    P0
+                    sage: H.monomial(1).antipode()  # indirect doctest
+                    -P1
+                    sage: H.monomial(2).antipode()  # indirect doctest
+                    P2
+                    sage: H.monomial(3).antipode()  # indirect doctest
+                    -P3
+                """
+                if self.monomial(index) == self.one():
+                    return self.one()
+
+                S = self.antipode_on_basis
+                x__S_Id = tensor([self, self]).module_morphism(
+                    lambda ab: S(ab[0]) * self.monomial(ab[1]),
+                    codomain=self)
+                return -x__S_Id(
+                    self.monomial(index).coproduct()
+                    - tensor([self.monomial(index), self.one()])
+                )
+
+        class ElementMethods:
+            pass