passagemath-categories 10.6.32__cp314-cp314t-musllinux_1_2_aarch64.whl

sage/categories/super_modules.py

@@ -0,0 +1,229 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Super modules
+"""
+#*****************************************************************************
+#  Copyright (C) 2015 Travis Scrimshaw <tscrim at ucdavis.edu>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#                  http://www.gnu.org/licenses/
+#******************************************************************************
+
+from sage.categories.category_types import Category_over_base_ring
+from sage.categories.covariant_functorial_construction import CovariantConstructionCategory
+
+# Note, a commutative algebra is not a commutative super algebra,
+#   therefore the following whitelist.
+axiom_whitelist = frozenset(["Facade", "Finite", "Infinite",
+                             "FiniteDimensional", "Connected", "WithBasis",
+                             "FinitelyGeneratedAsLambdaBracketAlgebra",
+                             # "Commutative", "Cocommutative",
+                             "Supercommutative", "Supercocommutative",
+                             "Associative", "Inverse", "Unital", "Division",
+                             "AdditiveCommutative", "AdditiveAssociative",
+                             "AdditiveInverse", "AdditiveUnital",
+                             "NoZeroDivisors", "Distributive"])
+
+
+class SuperModulesCategory(CovariantConstructionCategory, Category_over_base_ring):
+    @classmethod
+    def default_super_categories(cls, category, *args):
+        """
+        Return the default super categories of `F_{Cat}(A,B,...)` for
+        `A,B,...` parents in `Cat`.
+
+        INPUT:
+
+        - ``cls`` -- the category class for the functor `F`
+        - ``category`` -- a category `Cat`
+        - ``*args`` -- further arguments for the functor
+
+        OUTPUT: a join category
+
+        This implements the property that subcategories constructed by
+        the set of whitelisted axioms is a subcategory.
+
+        EXAMPLES::
+
+            sage: HopfAlgebras(ZZ).WithBasis().FiniteDimensional().Super()  # indirect doctest
+            Category of finite dimensional super Hopf algebras with basis over Integer Ring
+        """
+        axioms = axiom_whitelist.intersection(category.axioms())
+        C = super().default_super_categories(category, *args)
+        return C._with_axioms(axioms)
+
+    def __init__(self, base_category):
+        """
+        EXAMPLES::
+
+            sage: C = Algebras(QQ).Super()
+            sage: C
+            Category of super algebras over Rational Field
+            sage: C.base_category()
+            Category of algebras over Rational Field
+            sage: sorted(C.super_categories(), key=str)
+            [Category of graded algebras over Rational Field,
+             Category of super modules over Rational Field]
+
+            sage: AlgebrasWithBasis(QQ).Super().base_ring()
+            Rational Field
+            sage: HopfAlgebrasWithBasis(QQ).Super().base_ring()
+            Rational Field
+        """
+        super().__init__(base_category, base_category.base_ring())
+
+    _functor_category = "Super"
+
+    def _repr_object_names(self):
+        """
+        EXAMPLES::
+
+            sage: AlgebrasWithBasis(QQ).Super()  # indirect doctest
+            Category of super algebras with basis over Rational Field
+        """
+        return "super {}".format(self.base_category()._repr_object_names())
+
+
+class SuperModules(SuperModulesCategory):
+    r"""
+    The category of super modules.
+
+    An `R`-*super module* (where `R` is a ring) is an `R`-module `M` equipped
+    with a decomposition `M = M_0 \oplus M_1` into two `R`-submodules
+    `M_0` and `M_1` (called the *even part* and the *odd part* of `M`,
+    respectively).
+
+    Thus, an `R`-super module automatically becomes a `\ZZ / 2 \ZZ`-graded
+    `R`-module, with `M_0` being the degree-`0` component and `M_1` being the
+    degree-`1` component.
+
+    EXAMPLES::
+
+        sage: Modules(ZZ).Super()
+        Category of super modules over Integer Ring
+        sage: Modules(ZZ).Super().super_categories()
+        [Category of graded modules over Integer Ring]
+
+    The category of super modules defines the super structure which
+    shall be preserved by morphisms::
+
+        sage: Modules(ZZ).Super().additional_structure()
+        Category of super modules over Integer Ring
+
+    TESTS::
+
+        sage: TestSuite(Modules(ZZ).Super()).run()
+    """
+    def super_categories(self):
+        """
+        EXAMPLES::
+
+            sage: Modules(ZZ).Super().super_categories()
+            [Category of graded modules over Integer Ring]
+
+        Nota bene::
+
+            sage: Modules(QQ).Super()
+            Category of super modules over Rational Field
+            sage: Modules(QQ).Super().super_categories()
+            [Category of graded modules over Rational Field]
+        """
+        return [self.base_category().Graded()]
+
+    def extra_super_categories(self):
+        r"""
+        Add :class:`VectorSpaces` to the super categories of ``self`` if
+        the base ring is a field.
+
+        EXAMPLES::
+
+            sage: Modules(QQ).Super().extra_super_categories()
+            [Category of vector spaces over Rational Field]
+            sage: Modules(ZZ).Super().extra_super_categories()
+            []
+
+        This makes sure that ``Modules(QQ).Super()`` returns an
+        instance of :class:`SuperModules` and not a join category of
+        an instance of this class and of ``VectorSpaces(QQ)``::
+
+            sage: type(Modules(QQ).Super())
+            <class 'sage.categories.super_modules.SuperModules_with_category'>
+
+        .. TODO::
+
+            Get rid of this workaround once there is a more systematic
+            approach for the alias ``Modules(QQ)`` -> ``VectorSpaces(QQ)``.
+            Probably the latter should be a category with axiom, and
+            covariant constructions should play well with axioms.
+        """
+        from sage.categories.modules import Modules
+        from sage.categories.fields import Fields
+        base_ring = self.base_ring()
+        if base_ring in Fields():
+            return [Modules(base_ring)]
+        else:
+            return []
+
+    class ParentMethods:
+        pass
+
+    class ElementMethods:
+        def is_even_odd(self):
+            """
+            Return ``0`` if ``self`` is an even element or ``1``
+            if an odd element.
+
+            .. NOTE::
+
+                The default implementation assumes that the even/odd is
+                determined by the parity of :meth:`degree`.
+
+                Overwrite this method if the even/odd behavior is desired
+                to be independent.
+
+            EXAMPLES::
+
+                sage: # needs sage.combinat sage.modules
+                sage: cat = Algebras(QQ).WithBasis().Super()
+                sage: C = CombinatorialFreeModule(QQ, Partitions(), category=cat)
+                sage: C.degree_on_basis = sum
+                sage: C.basis()[2,2,1].is_even_odd()
+                1
+                sage: C.basis()[2,2].is_even_odd()
+                0
+            """
+            return self.degree() % 2
+
+        def is_even(self):
+            """
+            Return if ``self`` is an even element.
+
+            EXAMPLES::
+
+                sage: # needs sage.combinat sage.modules
+                sage: cat = Algebras(QQ).WithBasis().Super()
+                sage: C = CombinatorialFreeModule(QQ, Partitions(), category=cat)
+                sage: C.degree_on_basis = sum
+                sage: C.basis()[2,2,1].is_even()
+                False
+                sage: C.basis()[2,2].is_even()
+                True
+            """
+            return self.is_even_odd() == 0
+
+        def is_odd(self):
+            """
+            Return if ``self`` is an odd element.
+
+            EXAMPLES::
+
+                sage: # needs sage.combinat sage.modules
+                sage: cat = Algebras(QQ).WithBasis().Super()
+                sage: C = CombinatorialFreeModule(QQ, Partitions(), category=cat)
+                sage: C.degree_on_basis = sum
+                sage: C.basis()[2,2,1].is_odd()
+                True
+                sage: C.basis()[2,2].is_odd()
+                False
+            """
+            return self.is_even_odd() == 1

sage/categories/super_modules_with_basis.py

@@ -0,0 +1,193 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Super modules with basis
+"""
+#*****************************************************************************
+#  Copyright (C) 2015 Travis Scrimshaw <tscrim at ucdavis.edu>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#                  http://www.gnu.org/licenses/
+#******************************************************************************
+
+from sage.categories.super_modules import SuperModulesCategory
+
+
+class SuperModulesWithBasis(SuperModulesCategory):
+    """
+    The category of super modules with a distinguished basis.
+
+    An `R`-*super module with a distinguished basis* is an
+    `R`-super module equipped with an `R`-module basis whose elements are
+    homogeneous.
+
+    EXAMPLES::
+
+        sage: C = GradedModulesWithBasis(QQ); C
+        Category of graded vector spaces with basis over Rational Field
+        sage: sorted(C.super_categories(), key=str)
+        [Category of filtered vector spaces with basis over Rational Field,
+         Category of graded modules with basis over Rational Field,
+         Category of graded vector spaces over Rational Field]
+        sage: C is ModulesWithBasis(QQ).Graded()
+        True
+
+    TESTS::
+
+        sage: TestSuite(C).run()
+    """
+    class ParentMethods:
+        def _even_odd_on_basis(self, m):
+            """
+            Return the parity of the basis element indexed by ``m``.
+
+            OUTPUT:
+
+            ``0`` if ``m`` is for an even element or ``1`` if ``m``
+            is for an odd element.
+
+            .. NOTE::
+
+                The default implementation assumes that the even/odd is
+                determined by the parity of :meth:`degree`.
+
+                Overwrite this method if the even/odd behavior is desired
+                to be independent.
+
+            EXAMPLES::
+
+                sage: # needs sage.modules
+                sage: Q = QuadraticForm(QQ, 2, [1,2,3])
+                sage: C.<x,y> = CliffordAlgebra(Q)
+                sage: C._even_odd_on_basis((0,))
+                1
+                sage: C._even_odd_on_basis((0,1))
+                0
+            """
+            return self.degree_on_basis(m) % 2
+
+    class ElementMethods:
+        def is_super_homogeneous(self):
+            r"""
+            Return whether this element is homogeneous, in the sense
+            of a super module (i.e., is even or odd).
+
+            EXAMPLES::
+
+                sage: # needs sage.modules
+                sage: Q = QuadraticForm(QQ, 2, [1,2,3])
+                sage: C.<x,y> = CliffordAlgebra(Q)
+                sage: a = x + y
+                sage: a.is_super_homogeneous()
+                True
+                sage: a = x*y + 4
+                sage: a.is_super_homogeneous()
+                True
+                sage: a = x*y + x - 3*y + 4
+                sage: a.is_super_homogeneous()
+                False
+
+            The exterior algebra has a `\ZZ` grading, which induces the
+            `\ZZ / 2\ZZ` grading. However the definition of homogeneous
+            elements differs because of the different gradings::
+
+                sage: # needs sage.combinat sage.modules
+                sage: E.<x,y> = ExteriorAlgebra(QQ)
+                sage: a = x*y + 4
+                sage: a.is_super_homogeneous()
+                True
+                sage: a.is_homogeneous()
+                False
+            """
+            even_odd = self.parent()._even_odd_on_basis
+            degree = None
+            for m in self.support():
+                if degree is None:
+                    degree = even_odd(m)
+                else:
+                    if degree != even_odd(m):
+                        return False
+            return True
+
+        def is_even_odd(self):
+            """
+            Return ``0`` if ``self`` is an even element and ``1`` if
+            ``self`` is an odd element.
+
+            EXAMPLES::
+
+                sage: # needs sage.modules
+                sage: Q = QuadraticForm(QQ, 2, [1,2,3])
+                sage: C.<x,y> = CliffordAlgebra(Q)
+                sage: a = x + y
+                sage: a.is_even_odd()
+                1
+                sage: a = x*y + 4
+                sage: a.is_even_odd()
+                0
+                sage: a = x + 4
+                sage: a.is_even_odd()
+                Traceback (most recent call last):
+                ...
+                ValueError: element is not homogeneous
+
+                sage: E.<x,y> = ExteriorAlgebra(QQ)                                     # needs sage.modules
+                sage: (x*y).is_even_odd()                                               # needs sage.modules
+                0
+            """
+            if not self.support():
+                raise ValueError("the zero element does not have a well-defined degree")
+            if not self.is_super_homogeneous():
+                raise ValueError("element is not homogeneous")
+            return self.parent()._even_odd_on_basis(self.leading_support())
+
+        def even_component(self):
+            """
+            Return the even component of ``self``.
+
+            EXAMPLES::
+
+                sage: # needs sage.modules
+                sage: Q = QuadraticForm(QQ, 2, [1,2,3])
+                sage: C.<x,y> = CliffordAlgebra(Q)
+                sage: a = x*y + x - 3*y + 4
+                sage: a.even_component()
+                x*y + 4
+
+            TESTS:
+
+            Check that this really return ``A.zero()`` and not a plain ``0``::
+
+                sage: a = x + y                                                         # needs sage.modules
+                sage: a.even_component().parent() is C                                  # needs sage.modules
+                True
+            """
+            even_odd = self.parent()._even_odd_on_basis
+            return self.parent().sum_of_terms((i, c)
+                                              for (i, c) in self
+                                              if even_odd(i) == 0)
+
+        def odd_component(self):
+            """
+            Return the odd component of ``self``.
+
+            EXAMPLES::
+
+                sage: # needs sage.modules
+                sage: Q = QuadraticForm(QQ, 2, [1,2,3])
+                sage: C.<x,y> = CliffordAlgebra(Q)
+                sage: a = x*y + x - 3*y + 4
+                sage: a.odd_component()
+                x - 3*y
+
+            TESTS:
+
+            Check that this really return ``A.zero()`` and not a plain ``0``::
+
+                sage: a = x*y                                                           # needs sage.modules
+                sage: a.odd_component().parent() is C                                   # needs sage.modules
+                True
+            """
+            even_odd = self.parent()._even_odd_on_basis
+            return self.parent().sum_of_terms((i, c)
+                                              for (i, c) in self
+                                              if even_odd(i) == 1)

sage/categories/supercommutative_algebras.py

@@ -0,0 +1,99 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Supercommutative Algebras
+"""
+#*****************************************************************************
+#  Copyright (C) 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.categories.category_with_axiom import CategoryWithAxiom_over_base_ring
+from sage.categories.super_algebras import SuperAlgebras
+from sage.categories.signed_tensor import SignedTensorProductsCategory
+from sage.misc.cachefunc import cached_method
+
+
+class SupercommutativeAlgebras(CategoryWithAxiom_over_base_ring):
+    r"""
+    The category of supercommutative algebras.
+
+    An `R`-*supercommutative algebra* is an `R`-super algebra
+    `A = A_0 \oplus A_1` endowed with an `R`-super algebra structure
+    satisfying:
+
+    .. MATH::
+
+        x_0 x'_0 = x'_0 x_0, \qquad
+        x_1 x'_1 = -x'_1 x_1, \qquad
+        x_0 x_1 = x_1 x_0,
+
+    for all `x_0, x'_0 \in A_0` and `x_1, x'_1 \in A_1`.
+
+    EXAMPLES::
+
+        sage: Algebras(ZZ).Supercommutative()
+        Category of supercommutative algebras over Integer Ring
+
+    TESTS::
+
+        sage: TestSuite(Algebras(ZZ).Supercommutative()).run()
+    """
+    _base_category_class_and_axiom = (SuperAlgebras, "Supercommutative")
+
+    class SignedTensorProducts(SignedTensorProductsCategory):
+        @cached_method
+        def extra_super_categories(self):
+            """
+            Return the extra super categories of ``self``.
+
+            A signed tensor product of supercommutative algebras is a
+            supercommutative algebra.
+
+            EXAMPLES::
+
+                sage: C = Algebras(ZZ).Supercommutative().SignedTensorProducts()
+                sage: C.extra_super_categories()
+                [Category of supercommutative algebras over Integer Ring]
+            """
+            return [self.base_category()]
+
+    class WithBasis(CategoryWithAxiom_over_base_ring):
+        class ParentMethods:
+            def _test_supercommutativity(self, **options):
+                r"""
+                Test supercommutativity for (not necessarily all) elements
+                of this supercommutative algebra.
+
+                INPUT:
+
+                - ``options`` -- any keyword arguments accepted by :meth:`_tester`
+
+                EXAMPLES:
+
+                By default, this method tests only the elements returned by
+                ``self.some_elements()``::
+
+                    sage: E.<x,y,z> = ExteriorAlgebra(QQ)                               # needs sage.modules
+                    sage: E._test_supercommutativity()                                  # needs sage.modules
+
+                However, the elements tested can be customized with the
+                ``elements`` keyword argument, but the elements must be
+                homogeneous::
+
+                    sage: E._test_supercommutativity(elements=[x+y, x*y-3*y*z, x*y*z])  # needs sage.modules
+                    sage: E._test_supercommutativity(elements=[x+x*y])                  # needs sage.modules
+                    Traceback (most recent call last):
+                    ...
+                    ValueError: element is not homogeneous
+
+                See the documentation for :class:`TestSuite` for more information.
+                """
+                elements = options.pop("elements", self.basis())
+                tester = self._tester(**options)
+                from sage.misc.misc import some_tuples
+                for x,y in some_tuples(elements, 2, tester._max_runs):
+                    tester.assertEqual((x * y),
+                                       (-1)**(x.is_even_odd() * y.is_even_odd())
+                                       * (y * x))