passagemath-categories 10.6.32__cp314-cp314t-musllinux_1_2_aarch64.whl

sage/categories/super_algebras.py

@@ -0,0 +1,149 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Super Algebras
+"""
+# ****************************************************************************
+#  Copyright (C) 2015 Travis Scrimshaw <tscrim at ucdavis.edu>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#                  https://www.gnu.org/licenses/
+# *****************************************************************************
+
+from sage.categories.super_modules import SuperModulesCategory
+from sage.categories.signed_tensor import SignedTensorProductsCategory, tensor_signed
+from sage.categories.tensor import tensor
+from sage.misc.lazy_import import LazyImport
+from sage.misc.cachefunc import cached_method
+
+
+class SuperAlgebras(SuperModulesCategory):
+    r"""
+    The category of super algebras.
+
+    An `R`-*super algebra* is an `R`-super module `A` endowed with an
+    `R`-algebra structure satisfying
+
+    .. MATH::
+
+        A_0 A_0 \subseteq A_0, \qquad
+        A_0 A_1 \subseteq A_1, \qquad
+        A_1 A_0 \subseteq A_1, \qquad
+        A_1 A_1 \subseteq A_0
+
+    and `1 \in A_0`.
+
+    EXAMPLES::
+
+        sage: Algebras(ZZ).Super()
+        Category of super algebras over Integer Ring
+
+    TESTS::
+
+        sage: TestSuite(Algebras(ZZ).Super()).run()
+    """
+    def extra_super_categories(self):
+        """
+        EXAMPLES::
+
+            sage: Algebras(ZZ).Super().super_categories() # indirect doctest
+            [Category of graded algebras over Integer Ring,
+             Category of super modules over Integer Ring]
+        """
+        return [self.base_category().Graded()]
+
+    Supercommutative = LazyImport('sage.categories.supercommutative_algebras',
+                                  'SupercommutativeAlgebras')
+
+    class ParentMethods:
+        def graded_algebra(self):
+            r"""
+            Return the associated graded algebra to ``self``.
+
+            .. WARNING::
+
+                Because a super module `M` is naturally `\ZZ / 2 \ZZ`-graded, and
+                graded modules have a natural filtration induced by the grading, if
+                `M` has a different filtration, then the associated graded module
+                `\operatorname{gr} M \neq M`. This is most apparent with super
+                algebras, such as the :class:`differential Weyl algebra
+                <sage.algebras.weyl_algebra.DifferentialWeylAlgebra>`, and the
+                multiplication may not coincide.
+            """
+            raise NotImplementedError
+
+        def tensor(*parents, **kwargs):
+            """
+            Return the tensor product of the parents.
+
+            EXAMPLES::
+
+                sage: # needs sage.combinat sage.modules
+                sage: A.<x,y,z> = ExteriorAlgebra(ZZ); A.rename('A')
+                sage: T = A.tensor(A,A); T
+                A # A # A
+                sage: T in Algebras(ZZ).Graded().SignedTensorProducts()
+                True
+                sage: T in Algebras(ZZ).Graded().TensorProducts()
+                False
+                sage: A.rename(None)
+
+            This also works when the other elements do not have
+            a signed tensor product (:issue:`31266`)::
+
+                sage: # needs sage.combinat sage.modules
+                sage: a = SteenrodAlgebra(3).an_element()
+                sage: M = CombinatorialFreeModule(GF(3), ['s', 't', 'u'])
+                sage: s = M.basis()['s']
+                sage: tensor([a, s])                                                    # needs sage.rings.finite_rings
+                2*Q_1 Q_3 P(2,1) # B['s']
+            """
+            constructor = kwargs.pop('constructor', tensor_signed)
+            try:
+                cat = constructor.category_from_parents(parents)
+            except AttributeError:
+                # Fall back to the usual tensor product if the other parents
+                #   do not support signed tensor products
+                cat = tensor.category_from_parents(parents)
+            return parents[0].__class__.Tensor(parents, category=cat)
+
+    class SubcategoryMethods:
+        @cached_method
+        def Supercommutative(self):
+            r"""
+            Return the full subcategory of the supercommutative objects
+            of ``self``.
+
+            A super algebra `M` is *supercommutative* if, for all
+            homogeneous `x,y\in M`,
+
+            .. MATH::
+
+                x \cdot y = (-1)^{|x||y|} y \cdot x.
+
+            REFERENCES:
+
+            :wikipedia:`Supercommutative_algebra`
+
+            EXAMPLES::
+
+                sage: Algebras(ZZ).Super().Supercommutative()
+                Category of supercommutative algebras over Integer Ring
+                sage: Algebras(ZZ).Super().WithBasis().Supercommutative()
+                Category of supercommutative algebras with basis over Integer Ring
+            """
+            return self._with_axiom('Supercommutative')
+
+    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/super_algebras_with_basis.py

@@ -0,0 +1,144 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Super algebras with basis
+"""
+# ****************************************************************************
+#  Copyright (C) 2015,2019 Travis Scrimshaw <tcscrims at gmail.com>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#                  https://www.gnu.org/licenses/
+# *****************************************************************************
+
+from sage.categories.super_modules import SuperModulesCategory
+from sage.categories.signed_tensor import SignedTensorProductsCategory
+from sage.misc.cachefunc import cached_method
+
+
+class SuperAlgebrasWithBasis(SuperModulesCategory):
+    """
+    The category of super algebras with a distinguished basis.
+
+    EXAMPLES::
+
+        sage: C = Algebras(ZZ).WithBasis().Super(); C
+        Category of super algebras with basis over Integer Ring
+
+    TESTS::
+
+        sage: TestSuite(C).run()
+    """
+    def extra_super_categories(self):
+        """
+        EXAMPLES::
+
+            sage: C = Algebras(ZZ).WithBasis().Super()
+            sage: sorted(C.super_categories(), key=str) # indirect doctest
+            [Category of graded algebras with basis over Integer Ring,
+             Category of super algebras over Integer Ring,
+             Category of super modules with basis over Integer Ring]
+        """
+        return [self.base_category().Graded()]
+
+    class ParentMethods:
+        def graded_algebra(self):
+            r"""
+            Return the associated graded module to ``self``.
+
+            See :class:`~sage.algebras.associated_graded.AssociatedGradedAlgebra`
+            for the definition and the properties of this.
+
+            .. SEEALSO::
+
+                :meth:`~sage.categories.filtered_modules_with_basis.ParentMethods.graded_algebra`
+
+            EXAMPLES::
+
+                sage: W.<x,y> = algebras.DifferentialWeyl(QQ)                           # needs sage.modules
+                sage: W.graded_algebra()                                                # needs sage.combinat sage.modules
+                Graded Algebra of Differential Weyl algebra of
+                 polynomials in x, y over Rational Field
+            """
+            from sage.algebras.associated_graded import AssociatedGradedAlgebra
+            return AssociatedGradedAlgebra(self)
+
+    class ElementMethods:
+        def supercommutator(self, x):
+            r"""
+            Return the supercommutator of ``self`` and ``x``.
+
+            Let `A` be a superalgebra. The *supercommutator* of homogeneous
+            elements `x, y \in A` is defined by
+
+            .. MATH::
+
+                [x, y\} = x y - (-1)^{|x| |y|} y x
+
+            and extended to all elements by linearity.
+
+            EXAMPLES::
+
+                sage: # needs sage.modules
+                sage: Q = QuadraticForm(ZZ, 3, [1,2,3,4,5,6])
+                sage: Cl.<x,y,z> = CliffordAlgebra(Q)
+                sage: a = x*y - z
+                sage: b = x - y + y*z
+                sage: a.supercommutator(b)
+                -5*x*y + 8*x*z - 2*y*z - 6*x + 12*y - 5*z
+                sage: a.supercommutator(Cl.one())
+                0
+                sage: Cl.one().supercommutator(a)
+                0
+                sage: Cl.zero().supercommutator(a)
+                0
+                sage: a.supercommutator(Cl.zero())
+                0
+
+                sage: # needs sage.modules
+                sage: Q = QuadraticForm(ZZ, 2, [-1,1,-3])
+                sage: Cl.<x,y> = CliffordAlgebra(Q)
+                sage: [a.supercommutator(b) for a in Cl.basis() for b in Cl.basis()]
+                [0, 0, 0, 0, 0, -2, 1, -x - 2*y, 0, 1,
+                 -6, 6*x + y, 0, x + 2*y, -6*x - y, 0]
+                sage: [a*b-b*a for a in Cl.basis() for b in Cl.basis()]
+                [0, 0, 0, 0, 0, 0, 2*x*y - 1, -x - 2*y, 0,
+                 -2*x*y + 1, 0, 6*x + y, 0, x + 2*y, -6*x - y, 0]
+
+            Exterior algebras inherit from Clifford algebras, so
+            supercommutators work as well. We verify the exterior algebra
+            is supercommutative::
+
+                sage: E.<x,y,z,w> = ExteriorAlgebra(QQ)                                 # needs sage.modules
+                sage: all(b1.supercommutator(b2) == 0                                   # needs sage.modules
+                ....:     for b1 in E.basis() for b2 in E.basis())
+                True
+            """
+            P = self.parent()
+            ret = P.zero()
+            for ms, cs in self:
+                term_s = P.term(ms, cs)
+                sign_s = (-1)**P.degree_on_basis(ms)
+                for mx, cx in x:
+                    ret += term_s * P.term(mx, cx)
+                    s = sign_s**P.degree_on_basis(mx)
+                    ret -= s * P.term(mx, cx) * term_s
+            return ret
+
+    class SignedTensorProducts(SignedTensorProductsCategory):
+        """
+        The category of super algebras with basis constructed by tensor
+        product of super algebras with basis.
+        """
+        @cached_method
+        def extra_super_categories(self):
+            """
+            EXAMPLES::
+
+                sage: Algebras(QQ).Super().SignedTensorProducts().extra_super_categories()
+                [Category of super algebras over Rational Field]
+                sage: Algebras(QQ).Super().SignedTensorProducts().super_categories()
+                [Category of signed tensor products of graded algebras over Rational Field,
+                 Category of super algebras over Rational Field]
+
+            Meaning: a signed tensor product of super algebras is a super algebra
+            """
+            return [self.base_category()]

sage/categories/super_hopf_algebras_with_basis.py

@@ -0,0 +1,126 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Super Hopf algebras with basis
+"""
+# ****************************************************************************
+#  Copyright (C) 2015 Travis Scrimshaw <tscrim at ucdavis.edu>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#                  https://www.gnu.org/licenses/
+# *****************************************************************************
+from sage.misc.lazy_attribute import lazy_attribute
+from sage.categories.super_modules import SuperModulesCategory
+
+
+class SuperHopfAlgebrasWithBasis(SuperModulesCategory):
+    """
+    The category of super Hopf algebras with a distinguished basis.
+
+    EXAMPLES::
+
+        sage: C = HopfAlgebras(ZZ).WithBasis().Super(); C
+        Category of super Hopf algebras with basis over Integer Ring
+        sage: sorted(C.super_categories(), key=str)
+        [Category of super Hopf algebras over Integer Ring,
+         Category of super algebras with basis over Integer Ring,
+         Category of super coalgebras with basis over Integer Ring]
+
+    TESTS::
+
+        sage: C = HopfAlgebras(ZZ).WithBasis().Super()
+        sage: TestSuite(C).run()
+    """
+    class ParentMethods:
+        @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: A = SteenrodAlgebra(7)                                            # needs sage.combinat sage.modules
+                sage: a = A.an_element()                                                # needs sage.combinat sage.modules
+                sage: a, A.antipode(a)                                                  # needs sage.combinat sage.modules
+                (6 Q_1 Q_3 P(2,1), Q_1 Q_3 P(2,1))
+
+            TESTS::
+
+                sage: E.<x,y> = ExteriorAlgebra(QQ)                                     # needs sage.modules
+                sage: [b.antipode() for b in E.basis()]                                 # needs sage.modules
+                [1, -x, -y, x*y]
+            """
+            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 (super) 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:
+
+               .. MATH::
+
+                   S(ab) = (-1)^{\deg a \deg b} S(b) S(a)
+
+               for homogeneous `a` and `b`.
+
+            These properties are tested on :meth:`some_elements`.
+
+            TESTS::
+
+                sage: A = SteenrodAlgebra(7)                                            # needs sage.combinat sage.modules
+                sage: A._test_antipode()        # long time                             # needs 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():
+                x_even = x.even_component()
+                x_odd = x.odd_component()
+                for y in tester.some_elements():
+                    y_even = y.even_component()
+                    y_odd = y.odd_component()
+
+                    # The antipode is a graded anti-homomorphism.
+                    tester.assertEqual(S(x_even) * S(y_even),
+                                       S(y_even * x_even))
+                    tester.assertEqual(S(x_even) * S(y_odd),
+                                       S(y_odd * x_even))
+                    tester.assertEqual(S(x_odd) * S(y_even),
+                                       S(y_even * x_odd))
+                    tester.assertEqual(S(x_odd) * S(y_odd),
+                                       -S(y_odd * x_odd))
+
+                # 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())

sage/categories/super_lie_conformal_algebras.py

@@ -0,0 +1,193 @@
+# sage_setup: distribution = sagemath-categories
+"""
+Super Lie Conformal Algebras
+
+AUTHORS:
+
+- Reimundo Heluani (2019-10-05): Initial implementation.
+"""
+
+#******************************************************************************
+#       Copyright (C) 2019 Reimundo Heluani <heluani@potuz.net>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 2 of the License, or
+# (at your option) any later version.
+#                  http://www.gnu.org/licenses/
+#*****************************************************************************
+
+from sage.categories.graded_modules import GradedModulesCategory
+from sage.categories.super_modules import SuperModulesCategory
+from sage.misc.abstract_method import abstract_method
+from sage.categories.lambda_bracket_algebras import LambdaBracketAlgebras
+
+
+class SuperLieConformalAlgebras(SuperModulesCategory):
+    r"""
+    The category of super Lie conformal algebras.
+
+    EXAMPLES::
+
+        sage: LieConformalAlgebras(AA).Super()                                          # needs sage.rings.number_field
+        Category of super Lie conformal algebras over Algebraic Real Field
+
+    Notice that we can force to have a *purely even* super Lie
+    conformal algebra::
+
+        sage: bosondict = {('a','a'): {1:{('K',0):1}}}
+        sage: R = LieConformalAlgebra(QQ, bosondict, names=('a',),                      # needs sage.combinat sage.modules
+        ....:                         central_elements=('K',), super=True)
+        sage: [g.is_even_odd() for g in R.gens()]                                       # needs sage.combinat sage.modules
+        [0, 0]
+    """
+    def extra_super_categories(self):
+        """
+        The extra super categories of ``self``.
+
+        EXAMPLES::
+
+            sage: LieConformalAlgebras(QQ).Super().super_categories()
+            [Category of super modules over Rational Field,
+             Category of Lambda bracket algebras over Rational Field]
+        """
+        return [LambdaBracketAlgebras(self.base_ring())]
+
+    def example(self):
+        """
+        An example parent in this category.
+
+        EXAMPLES::
+
+            sage: LieConformalAlgebras(QQ).Super().example()                            # needs sage.combinat sage.modules
+            The Neveu-Schwarz super Lie conformal algebra over Rational Field
+        """
+        from sage.algebras.lie_conformal_algebras.neveu_schwarz_lie_conformal_algebra\
+                                      import NeveuSchwarzLieConformalAlgebra
+        return NeveuSchwarzLieConformalAlgebra(self.base_ring())
+
+    class ParentMethods:
+
+        def _test_jacobi(self, **options):
+            """
+            Test the Jacobi axiom of this super Lie conformal algebra.
+
+            INPUT:
+
+            - ``options`` -- any keyword arguments acceptde by :meth:`_tester`
+
+            EXAMPLES:
+
+            By default, this method tests only the elements returned by
+            ``self.some_elements()``::
+
+                sage: V = lie_conformal_algebras.Affine(QQ, 'B2')                       # needs sage.combinat sage.modules
+                sage: V._test_jacobi()          # long time (6 seconds)                 # needs sage.combinat sage.modules
+
+            It works for super Lie conformal algebras too::
+
+                sage: V = lie_conformal_algebras.NeveuSchwarz(QQ)                       # needs sage.combinat sage.modules
+                sage: V._test_jacobi()                                                  # needs sage.combinat sage.modules
+
+            We can use specific elements by passing the ``elements``
+            keyword argument::
+
+                sage: V = lie_conformal_algebras.Affine(QQ, 'A1',                       # needs sage.combinat sage.modules
+                ....:                                   names=('e', 'h', 'f'))
+                sage: V.inject_variables()                                              # needs sage.combinat sage.modules
+                Defining e, h, f, K
+                sage: V._test_jacobi(elements=(e, 2*f + h, 3*h))                        # needs sage.combinat sage.modules
+
+            TESTS::
+
+                sage: wrongdict = {('a', 'a'): {0: {('b', 0): 1}},
+                ....:              ('b', 'a'): {0: {('a', 0): 1}}}
+                sage: V = LieConformalAlgebra(QQ, wrongdict,                            # needs sage.combinat sage.modules
+                ....:                         names=('a', 'b'), parity=(1, 0))
+                sage: V._test_jacobi()                                                  # needs sage.combinat sage.modules
+                Traceback (most recent call last):
+                ...
+                AssertionError: {(0, 0): -3*a} != {} - {(0, 0): -3*a} + {}
+            """
+            tester = self._tester(**options)
+            S = tester.some_elements()
+            # Try our best to avoid non-homogeneous elements
+            elements = []
+            for s in S:
+                try:
+                    s.is_even_odd()
+                except ValueError:
+                    try:
+                        elements.extend([s.even_component(), s.odd_component()])
+                    except (AttributeError, ValueError):
+                        pass
+                    continue
+                elements.append(s)
+            S = elements
+            from sage.misc.misc import some_tuples
+            from sage.arith.misc import binomial
+            pz = tester._instance.zero()
+            for x,y,z in some_tuples(S, 3, tester._max_runs):
+                if x.is_zero() or y.is_zero():
+                    sgn = 1
+                elif x.is_even_odd() * y.is_even_odd():
+                    sgn = -1
+                else:
+                    sgn = 1
+                brxy = x.bracket(y)
+                brxz = x.bracket(z)
+                bryz = y.bracket(z)
+                br1 = {k: x.bracket(v) for k,v in bryz.items()}
+                br2 = {k: v.bracket(z) for k,v in brxy.items()}
+                br3 = {k: y.bracket(v) for k,v in brxz.items()}
+                jac1 = {(j,k): v for k in br1 for j,v in br1[k].items()}
+                jac3 = {(k,j): v for k in br3 for j,v in br3[k].items()}
+                jac2 = {}
+                for k,br in br2.items():
+                    for j,v in br.items():
+                        for r in range(j+1):
+                            jac2[(k+r, j-r)] = (jac2.get((k+r, j-r), pz)
+                                                + binomial(k+r, r)*v)
+                for k,v in jac2.items():
+                    jac1[k] = jac1.get(k, pz) - v
+                for k,v in jac3.items():
+                    jac1[k] = jac1.get(k, pz) - sgn*v
+                jacobiator = {k: v for k,v in jac1.items() if v}
+                tester.assertDictEqual(jacobiator, {})
+
+    class ElementMethods:
+
+        @abstract_method
+        def is_even_odd(self):
+            """
+            Return ``0`` if this element is *even* and ``1`` if it is
+            *odd*.
+
+            EXAMPLES::
+
+                sage: R = lie_conformal_algebras.NeveuSchwarz(QQ)                       # needs sage.combinat sage.modules
+                sage: R.inject_variables()                                              # needs sage.combinat sage.modules
+                Defining L, G, C
+                sage: G.is_even_odd()                                                   # needs sage.combinat sage.modules
+                1
+            """
+
+    class Graded(GradedModulesCategory):
+        """
+        The category of H-graded super Lie conformal algebras.
+
+        EXAMPLES::
+
+            sage: LieConformalAlgebras(AA).Super().Graded()                             # needs sage.rings.number_field
+            Category of H-graded super Lie conformal algebras over Algebraic Real Field
+        """
+        def _repr_object_names(self):
+            """
+            The names of the objects of this category.
+
+            EXAMPLES::
+
+                sage: LieConformalAlgebras(QQbar).Graded()                              # needs sage.rings.number_field
+                Category of H-graded Lie conformal algebras over Algebraic Field
+            """
+            return "H-graded {}".format(self.base_category()._repr_object_names())