passagemath-categories 10.6.32__cp314-cp314t-musllinux_1_2_aarch64.whl

sage/categories/lambda_bracket_algebras.py

@@ -0,0 +1,280 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Lambda Bracket 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.category_types import Category_over_base_ring
+from sage.categories.commutative_rings import CommutativeRings
+from sage.categories.modules import Modules
+from sage.misc.abstract_method import abstract_method
+from sage.misc.cachefunc import cached_method
+from sage.misc.lazy_import import LazyImport
+from sage.structure.element import coerce_binop
+
+_CommutativeRings = CommutativeRings()
+
+
+class LambdaBracketAlgebras(Category_over_base_ring):
+    r"""
+    The category of Lambda bracket algebras.
+
+    This is an abstract base category for Lie conformal algebras and
+    super Lie conformal algebras.
+    """
+    @staticmethod
+    def __classcall_private__(cls, R, check=True):
+        r"""
+        INPUT:
+
+        - ``R`` -- a commutative ring
+        - ``check`` -- boolean (default: ``True``); whether to check
+          that `R` is a commutative ring
+
+        EXAMPLES::
+
+            sage: LieConformalAlgebras(QuaternionAlgebra(2))                            # needs sage.combinat sage.libs.singular sage.modules
+            Traceback (most recent call last):
+            ValueError: base must be a commutative ring
+            got Quaternion Algebra (-1, -1) with base ring Rational Field
+            sage: LieConformalAlgebras(ZZ)
+            Category of Lie conformal algebras over Integer Ring
+        """
+        if check:
+            if R not in _CommutativeRings:
+                    raise ValueError("base must be a commutative ring got {}".format(R))
+        return super().__classcall__(cls, R)
+
+    @cached_method
+    def super_categories(self):
+        """
+        The list of super categories of this category.
+
+        EXAMPLES::
+
+            sage: from sage.categories.lambda_bracket_algebras import LambdaBracketAlgebras
+            sage: LambdaBracketAlgebras(QQ).super_categories()
+            [Category of vector spaces over Rational Field]
+        """
+        return [Modules(self.base_ring())]
+
+    def _repr_object_names(self):
+        """
+        The name of the objects of this category.
+
+        EXAMPLES::
+
+            sage: from sage.categories.lambda_bracket_algebras import LambdaBracketAlgebras
+            sage: LambdaBracketAlgebras(QQ)
+            Category of Lambda bracket algebras over Rational Field
+        """
+        return "Lambda bracket algebras over {}".format(self.base_ring())
+
+    class SubcategoryMethods:
+
+        def FinitelyGeneratedAsLambdaBracketAlgebra(self):
+            """
+            The category of finitely generated Lambda bracket algebras.
+
+            EXAMPLES::
+
+                sage: LieConformalAlgebras(QQ).FinitelyGenerated()
+                Category of finitely generated Lie conformal algebras over Rational Field
+            """
+            return self._with_axiom("FinitelyGeneratedAsLambdaBracketAlgebra")
+
+        def FinitelyGenerated(self):
+            """
+            The category of finitely generated Lambda bracket algebras.
+
+            EXAMPLES::
+
+                sage: LieConformalAlgebras(QQ).FinitelyGenerated()
+                Category of finitely generated Lie conformal algebras over Rational Field
+            """
+            return self._with_axiom("FinitelyGeneratedAsLambdaBracketAlgebra")
+
+    class ParentMethods:
+
+        def ideal(self, *gens, **kwds):
+            r"""
+            The ideal of this Lambda bracket algebra generated by ``gens``.
+
+            .. TODO::
+
+                Ideals of Lie Conformal Algebras are not implemented yet.
+
+            EXAMPLES::
+
+                sage: Vir = lie_conformal_algebras.Virasoro(QQ)                         # needs sage.combinat sage.modules
+                sage: Vir.ideal()                                                       # needs sage.combinat sage.modules
+                Traceback (most recent call last):
+                ...
+                NotImplementedError: ideals of Lie Conformal algebras are not implemented yet
+            """
+            raise NotImplementedError("ideals of Lie Conformal algebras are "
+                                      "not implemented yet")
+
+    class ElementMethods:
+
+        @coerce_binop
+        def bracket(self, rhs):
+            r"""
+            The `\lambda`-bracket of these two elements.
+
+            EXAMPLES:
+
+            The brackets of the Virasoro Lie conformal algebra::
+
+                sage: Vir = lie_conformal_algebras.Virasoro(QQ); L = Vir.0              # needs sage.combinat sage.modules
+                sage: L.bracket(L)                                                      # needs sage.combinat sage.modules
+                {0: TL, 1: 2*L, 3: 1/2*C}
+                sage: L.bracket(L.T())                                                  # needs sage.combinat sage.modules
+                {0: 2*T^(2)L, 1: 3*TL, 2: 4*L, 4: 2*C}
+
+            Now with a current algebra::
+
+                sage: # needs sage.combinat sage.modules
+                sage: V = lie_conformal_algebras.Affine(QQ, 'A1')
+                sage: V.gens()
+                (B[alpha[1]], B[alphacheck[1]], B[-alpha[1]], B['K'])
+                sage: E = V.0; H = V.1; F = V.2
+                sage: H.bracket(H)
+                {1: 2*B['K']}
+                sage: E.bracket(F)
+                {0: B[alphacheck[1]], 1: B['K']}
+            """
+            return self._bracket_(rhs)
+
+        @abstract_method
+        def _bracket_(self, rhs):
+            r"""
+            The `\lambda`-bracket of these two elements.
+
+            .. NOTE::
+
+                It is guaranteed that both are elements of the same
+                parent.
+
+            EXAMPLES:
+
+            The brackets of the Virasoro Lie conformal Algebra::
+
+                sage: Vir = lie_conformal_algebras.Virasoro(QQ); L = Vir.0              # needs sage.combinat sage.modules
+                sage: L._bracket_(L)                                                    # needs sage.combinat sage.modules
+                {0: TL, 1: 2*L, 3: 1/2*C}
+                sage: L._bracket_(L.T())                                                # needs sage.combinat sage.modules
+                {0: 2*T^(2)L, 1: 3*TL, 2: 4*L, 4: 2*C}
+
+            Now with a current algebra::
+
+                sage: # needs sage.combinat sage.modules
+                sage: V = lie_conformal_algebras.Affine(QQ, 'A1')
+                sage: V.gens()
+                (B[alpha[1]], B[alphacheck[1]], B[-alpha[1]], B['K'])
+                sage: E = V.0; H = V.1; F = V.2
+                sage: H._bracket_(H)
+                {1: 2*B['K']}
+                sage: E._bracket_(F)
+                {0: B[alphacheck[1]], 1: B['K']}
+            """
+
+        @coerce_binop
+        def nproduct(self, rhs, n):
+            r"""
+            The ``n``-th product of these two elements.
+
+            EXAMPLES::
+
+                sage: # needs sage.combinat sage.modules
+                sage: Vir = lie_conformal_algebras.Virasoro(QQ); L = Vir.0
+                sage: L.nproduct(L, 3)
+                1/2*C
+                sage: L.nproduct(L.T(), 0)
+                2*T^(2)L
+                sage: V = lie_conformal_algebras.Affine(QQ, 'A1')
+                sage: E = V.0; H = V.1; F = V.2
+                sage: E.nproduct(H, 0) == - 2*E
+                True
+                sage: E.nproduct(F, 1)
+                B['K']
+            """
+            return self._nproduct_(rhs,n)
+
+        def _nproduct_(self, rhs, n):
+            r"""
+            The ``n``-th product of these two elements.
+
+            .. NOTE::
+
+                It is guaranteed that both are elements of the same
+                parent.
+
+            EXAMPLES::
+
+                sage: # needs sage.combinat sage.modules
+                sage: Vir = lie_conformal_algebras.Virasoro(QQ); L = Vir.0
+                sage: L._nproduct_(L, 3)
+                1/2*C
+                sage: L._nproduct_(L.T(), 0)
+                2*T^(2)L
+                sage: V = lie_conformal_algebras.Affine(QQ, 'A1')
+                sage: E = V.0; H = V.1; F = V.2
+                sage: E._nproduct_(H, 0) == - 2*E
+                True
+                sage: E._nproduct_(F, 1)
+                B['K']
+            """
+            if n >= 0:
+                return self.bracket(rhs).get(n,self.parent().zero())
+            else:
+                raise NotImplementedError("vertex algebras are not implemented")
+
+        @abstract_method
+        def T(self, n=1):
+            r"""
+            The ``n``-th derivative of ``self``.
+
+            INPUT:
+
+            - ``n`` -- integer (default: `1`); how many times
+              to apply `T` to this element
+
+            OUTPUT:
+
+            `T^n a` where `a` is this element. Notice that we use the
+            *divided powers* notation `T^{(j)} = \frac{T^j}{j!}`.
+
+            EXAMPLES::
+
+                sage: # needs sage.combinat sage.modules
+                sage: Vir = lie_conformal_algebras.Virasoro(QQ)
+                sage: Vir.inject_variables()
+                Defining L, C
+                sage: L.T()
+                TL
+                sage: L.T(3)
+                6*T^(3)L
+                sage: C.T()
+                0
+            """
+
+    WithBasis = LazyImport("sage.categories.lambda_bracket_algebras_with_basis",
+                           "LambdaBracketAlgebrasWithBasis", "WithBasis")
+
+    FinitelyGeneratedAsLambdaBracketAlgebra = LazyImport(
+        'sage.categories.finitely_generated_lambda_bracket_algebras',
+        'FinitelyGeneratedLambdaBracketAlgebras')

sage/categories/lambda_bracket_algebras_with_basis.py

@@ -0,0 +1,107 @@
+# sage_setup: distribution = sagemath-categories
+"""
+Lambda Bracket Algebras With Basis
+
+AUTHORS:
+
+- Reimundo Heluani (2020-08-21): Initial implementation.
+"""
+
+#******************************************************************************
+#       Copyright (C) 2020 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.category_with_axiom import CategoryWithAxiom_over_base_ring
+from sage.categories.graded_modules import GradedModulesCategory
+
+
+class LambdaBracketAlgebrasWithBasis(CategoryWithAxiom_over_base_ring):
+    """
+    The category of Lambda bracket algebras with basis.
+
+    EXAMPLES::
+
+        sage: LieConformalAlgebras(QQbar).WithBasis()                                   # needs sage.rings.number_field
+        Category of Lie conformal algebras with basis over Algebraic Field
+    """
+    class ElementMethods:
+
+        def index(self):
+            """
+            The index of this basis element.
+
+            EXAMPLES::
+
+                sage: # needs sage.combinat sage.modules
+                sage: V = lie_conformal_algebras.NeveuSchwarz(QQ)
+                sage: V.inject_variables()
+                Defining L, G, C
+                sage: G.T(3).index()
+                ('G', 3)
+                sage: v = V.an_element(); v
+                L + G + C
+                sage: v.index()
+                Traceback (most recent call last):
+                ...
+                ValueError: index can only be computed for monomials, got L + G + C
+            """
+            if self.is_zero():
+                return None
+            if not self.is_monomial():
+                raise ValueError("index can only be computed for "
+                                 "monomials, got {}".format(self))
+
+            return next(iter(self.monomial_coefficients()))
+
+    class FinitelyGeneratedAsLambdaBracketAlgebra(CategoryWithAxiom_over_base_ring):
+        """
+        The category of finitely generated lambda bracket algebras with
+        basis.
+
+        EXAMPLES::
+
+            sage: # needs sage.rings.number_field
+            sage: C = LieConformalAlgebras(QQbar)
+            sage: C1 = C.WithBasis().FinitelyGenerated(); C1
+            Category of finitely generated Lie conformal algebras with basis
+             over Algebraic Field
+            sage: C2 = C.FinitelyGenerated().WithBasis(); C2
+            Category of finitely generated Lie conformal algebras with basis
+             over Algebraic Field
+            sage: C1 is C2
+            True
+        """
+        class Graded(GradedModulesCategory):
+            """
+            The category of H-graded finitely generated lambda bracket
+            algebras with basis.
+
+            EXAMPLES::
+
+                sage: C = LieConformalAlgebras(QQbar)                                   # needs sage.rings.number_field
+                sage: C.WithBasis().FinitelyGenerated().Graded()                        # needs sage.rings.number_field
+                Category of H-graded finitely generated Lie conformal algebras
+                 with basis over Algebraic Field
+            """
+            class ParentMethods:
+
+                def degree_on_basis(self, m):
+                    r"""
+                    Return the degree of the basis element indexed by ``m``
+                    in ``self``.
+
+                    EXAMPLES::
+
+                        sage: V = lie_conformal_algebras.Virasoro(QQ)                   # needs sage.combinat sage.modules
+                        sage: V.degree_on_basis(('L', 2))                               # needs sage.combinat sage.modules
+                        4
+                    """
+                    if m[0] in self._central_elements:
+                        return 0
+                    return self._weights[self._index_to_pos[m[0]]] + m[1]

sage/categories/lattice_posets.py

@@ -0,0 +1,89 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Lattice posets
+"""
+#*****************************************************************************
+#  Copyright (C) 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.misc.cachefunc import cached_method
+from sage.misc.abstract_method import abstract_method
+from sage.misc.lazy_import import LazyImport
+from sage.categories.category import Category
+from sage.categories.posets import Posets
+
+
+class LatticePosets(Category):
+    r"""
+    The category of lattices, i.e. partially ordered sets in which any
+    two elements have a unique supremum (the elements' least upper
+    bound; called their *join*) and a unique infimum (greatest lower bound;
+    called their *meet*).
+
+    EXAMPLES::
+
+        sage: LatticePosets()
+        Category of lattice posets
+        sage: LatticePosets().super_categories()
+        [Category of posets]
+        sage: LatticePosets().example()
+        NotImplemented
+
+    .. SEEALSO:: :class:`~sage.categories.posets.Posets`, :class:`FiniteLatticePosets`, :func:`LatticePoset`
+
+    TESTS::
+
+        sage: C = LatticePosets()
+        sage: TestSuite(C).run()
+    """
+    @cached_method
+    def super_categories(self):
+        r"""
+        Return a list of the (immediate) super categories of
+        ``self``, as per :meth:`Category.super_categories`.
+
+        EXAMPLES::
+
+            sage: LatticePosets().super_categories()
+            [Category of posets]
+        """
+        return [Posets()]
+
+    Finite = LazyImport('sage.categories.finite_lattice_posets', 'FiniteLatticePosets')
+
+    class ParentMethods:
+
+        @abstract_method
+        def meet(self, x, y):
+            """
+            Return the meet of `x` and `y` in this lattice.
+
+            INPUT:
+
+            - ``x``, ``y`` -- elements of ``self``
+
+            EXAMPLES::
+
+                sage: D = LatticePoset((divisors(30), attrcall("divides")))             # needs sage.graphs sage.modules
+                sage: D.meet( D(6), D(15) )                                             # needs sage.graphs sage.modules
+                3
+            """
+
+        @abstract_method
+        def join(self, x, y):
+            """
+            Return the join of `x` and `y` in this lattice.
+
+            INPUT:
+
+            - ``x``, ``y`` -- elements of ``self``
+
+            EXAMPLES::
+
+                sage: D = LatticePoset((divisors(60), attrcall("divides")))             # needs sage.graphs sage.modules
+                sage: D.join( D(6), D(10) )                                             # needs sage.graphs sage.modules
+                30
+            """

sage/categories/left_modules.py

@@ -0,0 +1,49 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Left modules
+"""
+#*****************************************************************************
+#  Copyright (C) 2008 Teresa Gomez-Diaz (CNRS) <Teresa.Gomez-Diaz@univ-mlv.fr>
+#
+#  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.commutative_additive_groups import CommutativeAdditiveGroups
+
+
+#?class LeftModules(Category_over_base_rng):
+class LeftModules(Category_over_base_ring):
+    """
+    The category of left modules
+    left modules over an rng (ring not necessarily with unit), i.e.
+    an abelian group with left multiplication by elements of the rng
+
+    EXAMPLES::
+
+        sage: LeftModules(ZZ)
+        Category of left modules over Integer Ring
+        sage: LeftModules(ZZ).super_categories()
+        [Category of commutative additive groups]
+
+    TESTS::
+
+        sage: TestSuite(LeftModules(ZZ)).run()
+    """
+
+    def super_categories(self):
+        """
+        EXAMPLES::
+
+            sage: LeftModules(QQ).super_categories()
+            [Category of commutative additive groups]
+        """
+        return [CommutativeAdditiveGroups()]
+
+    class ParentMethods:
+        pass
+
+    class ElementMethods:
+        ## r * x
+        pass