passagemath-categories 10.6.32__cp314-cp314t-musllinux_1_2_aarch64.whl

sage/categories/lie_algebras_with_basis.py

@@ -0,0 +1,261 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Lie Algebras With Basis
+
+AUTHORS:
+
+- Travis Scrimshaw (07-15-2013): Initial implementation
+"""
+
+#*****************************************************************************
+#       Copyright (C) 2013-2024 Travis Scrimshaw <tcscrims at gmail.com>
+#
+# 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.
+#                  https://www.gnu.org/licenses/
+#*****************************************************************************
+
+from sage.misc.abstract_method import abstract_method
+from sage.misc.lazy_import import LazyImport
+from sage.categories.category_with_axiom import CategoryWithAxiom_over_base_ring
+from sage.categories.lie_algebras import LieAlgebras
+
+
+class LieAlgebrasWithBasis(CategoryWithAxiom_over_base_ring):
+    """
+    Category of Lie algebras with a basis.
+    """
+    _base_category_class_and_axiom = (LieAlgebras, "WithBasis")
+
+    def example(self, gens=None):
+        """
+        Return an example of a Lie algebra as per
+        :meth:`Category.example <sage.categories.category.Category.example>`.
+
+        EXAMPLES::
+
+            sage: LieAlgebras(QQ).WithBasis().example()                                 # needs sage.modules
+            An example of a Lie algebra: the abelian Lie algebra on the
+             generators indexed by Partitions over Rational Field
+
+        Another set of generators can be specified as an optional argument::
+
+            sage: LieAlgebras(QQ).WithBasis().example(Compositions())                   # needs sage.modules
+            An example of a Lie algebra: the abelian Lie algebra on the
+             generators indexed by Compositions of nonnegative integers
+             over Rational Field
+        """
+        if gens is None:
+            from sage.combinat.partition import Partitions
+            gens = Partitions()
+        from sage.categories.examples.lie_algebras_with_basis import Example
+        return Example(self.base_ring(), gens)
+
+    Graded = LazyImport('sage.categories.graded_lie_algebras_with_basis',
+                        'GradedLieAlgebrasWithBasis',
+                        as_name='Graded')
+
+    class ParentMethods:
+        def _basis_key(self, x):
+            """
+            Return the key used to compare two basis element indices.
+
+            The default is to call the element itself.
+
+            TESTS::
+
+                sage: L = LieAlgebras(QQ).WithBasis().example()                         # needs sage.modules
+                sage: L._basis_key(Partition([3,1]))                                    # needs sage.modules
+                [3, 1]
+            """
+            return x
+
+        @abstract_method(optional=True)
+        def bracket_on_basis(self, x, y):
+            """
+            Return the bracket of basis elements indexed by ``x`` and ``y``
+            where ``x < y``. If this is not implemented, then the method
+            ``_bracket_()`` for the elements must be overwritten.
+
+            EXAMPLES::
+
+                sage: L = LieAlgebras(QQ).WithBasis().example()                         # needs sage.modules
+                sage: L.bracket_on_basis(Partition([3,1]), Partition([2,2,1,1]))        # needs sage.modules
+                0
+            """
+
+        def module(self):
+            """
+            Return an `R`-module which is isomorphic to the
+            underlying `R`-module of ``self``.
+
+            See
+            :meth:`sage.categories.lie_algebras.LieAlgebras.module` for
+            an explanation.
+
+            EXAMPLES::
+
+                sage: L = LieAlgebras(QQ).WithBasis().example()                         # needs sage.modules
+                sage: L.module()                                                        # needs sage.modules
+                Free module generated by Partitions over Rational Field
+            """
+            from sage.combinat.free_module import CombinatorialFreeModule
+            try:
+                # Try to see if it has an indexing set
+                return CombinatorialFreeModule(self.base_ring(), self.basis().keys())
+            except AttributeError:
+                # Otherwise just index by the basis of ``self`` as a fallback
+                return CombinatorialFreeModule(self.base_ring(), self.basis())
+
+        def from_vector(self, v, order=None, coerce=False):
+            """
+            Return the element of ``self`` corresponding to the
+            vector ``v`` in ``self.module()``.
+
+            Implement this if you implement :meth:`module`; see the
+            documentation of
+            :meth:`sage.categories.lie_algebras.LieAlgebras.module`
+            for how this is to be done.
+
+            EXAMPLES::
+
+                sage: L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example()     # needs sage.combinat sage.libs.singular sage.modules
+                sage: u = L.from_vector(vector(QQ, (1, 0, 0))); u                       # needs sage.combinat sage.libs.singular sage.modules
+                (1, 0, 0)
+                sage: parent(u) is L                                                    # needs sage.combinat sage.libs.singular sage.modules
+                True
+            """
+            B = self.basis()
+            return self.sum(v[i] * B[i] for i in v.support())
+
+        # Remove once #22629 is merged
+        def dimension(self):
+            """
+            Return the dimension of ``self``.
+
+            EXAMPLES::
+
+                sage: L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example()     # needs sage.combinat sage.libs.singular sage.modules
+                sage: L.dimension()                                                     # needs sage.combinat sage.libs.singular sage.modules
+                3
+
+            ::
+
+                sage: L = LieAlgebra(QQ, 'x,y', {('x','y'): {'x':1}})                   # needs sage.combinat sage.modules
+                sage: L.dimension()                                                     # needs sage.combinat sage.modules
+                2
+            """
+            return self.basis().cardinality()
+
+        def pbw_basis(self, basis_key=None, **kwds):
+            """
+            Return the Poincare-Birkhoff-Witt basis of the universal
+            enveloping algebra corresponding to ``self``.
+
+            EXAMPLES::
+
+                sage: L = lie_algebras.sl(QQ, 2)                                        # needs sage.combinat sage.graphs sage.modules
+                sage: PBW = L.pbw_basis()                                               # needs sage.combinat sage.graphs sage.modules
+            """
+            from sage.algebras.lie_algebras.poincare_birkhoff_witt \
+                import PoincareBirkhoffWittBasis
+            return PoincareBirkhoffWittBasis(self, basis_key, **kwds)
+
+        poincare_birkhoff_witt_basis = pbw_basis
+
+        _construct_UEA = pbw_basis
+
+    class ElementMethods:
+        def _bracket_(self, y):
+            """
+            Return the Lie bracket ``[self, y]``, where ``y`` is an
+            element of the same Lie algebra as ``self``.
+
+            EXAMPLES::
+
+                sage: # needs sage.combinat sage.modules
+                sage: L = LieAlgebras(QQ).WithBasis().example()
+                sage: G = L.lie_algebra_generators()
+                sage: x = G[Partition([4,3,3,1])]
+                sage: y = G[Partition([6,1])]
+                sage: x.bracket(y)
+                0
+            """
+            P = self.parent()
+
+            def term(ml, mr):
+                key_ml = P._basis_key(ml)
+                key_mr = P._basis_key(mr)
+                if key_ml == key_mr:
+                    return P.zero()
+                if key_ml < key_mr:
+                    return P.bracket_on_basis(ml, mr)
+                return -P.bracket_on_basis(mr, ml)
+
+            return P.sum(cl * cr * term(ml, mr)
+                         for ml, cl in self for mr, cr in y)
+
+        def to_vector(self, order=None):
+            """
+            Return the vector in ``g.module()`` corresponding to the
+            element ``self`` of ``g`` (where ``g`` is the parent of
+            ``self``).
+
+            Implement this if you implement ``g.module()``.
+            See :meth:`sage.categories.lie_algebras.LieAlgebras.module`
+            for how this is to be done.
+
+            EXAMPLES::
+
+                sage: L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example()     # needs sage.combinat sage.libs.singular sage.modules
+                sage: L.an_element().to_vector()                                        # needs sage.combinat sage.libs.singular sage.modules
+                (0, 0, 0)
+
+            .. TODO::
+
+                Doctest this implementation on an example not overshadowed.
+            """
+            M = self.parent().module()
+            B = M.basis()
+            return M.sum(self[i] * B[i] for i in self.support())
+
+        def lift(self):
+            """
+            Lift ``self`` to the universal enveloping algebra.
+
+            EXAMPLES::
+
+                sage: # needs sage.combinat sage.groups
+                sage: S = SymmetricGroup(3).algebra(QQ)
+                sage: L = LieAlgebra(associative=S)
+                sage: x = L.gen(3)
+                sage: y = L.gen(1)
+                sage: x.lift()
+                b3
+                sage: y.lift()
+                b1
+                sage: x * y
+                b1*b3 + b4 - b5
+            """
+            P = self.parent()
+            UEA = P.universal_enveloping_algebra()
+            s = UEA.zero()
+            if not self:
+                return s
+            # Special hook for when the index set of the parent of ``self``
+            #   does not match the generators index set of the UEA.
+            if hasattr(P, '_UEA_names_map'):
+                names_map = P._UEA_names_map
+                gen_dict = UEA.gens_dict()
+                for t, c in self.monomial_coefficients(copy=False).items():
+                    s += c * gen_dict[names_map[t]]
+            else:
+                try:
+                    gen_dict = UEA.algebra_generators()
+                except (TypeError, AttributeError):
+                    gen_dict = UEA.gens_dict()
+                for t, c in self.monomial_coefficients(copy=False).items():
+                    s += c * gen_dict[t]
+            return s

sage/categories/lie_conformal_algebras.py

@@ -0,0 +1,350 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Lie Conformal Algebras
+
+Let `R` be a commutative ring, a *super Lie conformal algebra*
+[Kac1997]_ over `R` (also known as a *vertex Lie algebra*) is an `R[T]`
+super module `L` together with a `\mathbb{Z}/2\mathbb{Z}`-graded `R`-bilinear
+operation (called the `\lambda`-bracket) `L\otimes L \rightarrow L[\lambda]`
+(polynomials in `\lambda` with coefficients in `L`),
+`a \otimes b \mapsto [a_\lambda b]` satisfying
+
+1. Sesquilinearity:
+
+   .. MATH::
+
+        [Ta_\lambda b] = - \lambda [a_\lambda b], \qquad [a_\lambda Tb] =
+        (\lambda+ T) [a_\lambda b].
+
+2. Skew-Symmetry:
+
+   .. MATH::
+
+        [a_\lambda b] = - (-1)^{p(a)p(b)} [b_{-\lambda - T} a],
+
+   where `p(a)` is `0` if `a` is *even* and `1` if `a` is *odd*. The
+   bracket in the RHS is computed as follows. First we evaluate
+   `[b_\mu a]` with the formal parameter `\mu` to the *left*, then
+   replace each appearance of the formal variable `\mu` by `-\lambda - T`.
+   Finally apply `T` to the coefficients in `L`.
+
+3. Jacobi identity:
+
+   .. MATH::
+
+       [a_\lambda [b_\mu c]] = [ [a_{\lambda + \mu} b]_\mu c] +
+       (-1)^{p(a)p(b)} [b_\mu [a_\lambda c]],
+
+   which is understood as an equality in `L[\lambda, \mu]`.
+
+   `T` is usually called the *translation operation* or the *derivative*.
+   For an element `a \in L` we will say that `Ta` is the *derivative of*
+   `a`. We define the `n`-*th products* `a_{(n)} b` for `a,b \in L` by
+
+   .. MATH::
+
+        [a_\lambda b] = \sum_{n \geq 0} \frac{\lambda^n}{n!} a_{(n)} b.
+
+   A Lie conformal algebra is called *H-Graded* [DSK2006]_ if there exists
+   a decomposition `L = \oplus L_n` such that the
+   `\lambda`-bracket becomes graded of degree `-1`, that is:
+
+   .. MATH::
+
+        a_{(n)} b \in L_{p + q -n -1} \qquad
+        a \in L_p, \: b \in L_q, \: n \geq 0.
+
+   In particular this implies that the action of `T` increases
+   degree by `1`.
+
+.. NOTE::
+
+    In the literature arbitrary gradings are allowed. In this
+    implementation we only support nonnegative rational gradings.
+
+EXAMPLES:
+
+1. The **Virasoro** Lie conformal algebra `Vir` over a ring `R`
+   where `12` is invertible has two generators `L, C` as an `R[T]`-module.
+   It is the direct sum of a free module of rank `1` generated by `L`, and
+   a free rank one `R` module generated by `C` satisfying `TC = 0`.  `C`
+   is central (the `\lambda`-bracket of `C` with any other vector
+   vanishes). The remaining `\lambda`-bracket is given by
+
+   .. MATH::
+
+        [L_\lambda L] = T L + 2 \lambda L + \frac{\lambda^3}{12} C.
+
+2. The **affine** or current Lie conformal algebra `L(\mathfrak{g})`
+   associated to a finite dimensional Lie algebra `\mathfrak{g}` with
+   non-degenerate, invariant `R`-bilinear form `(,)` is given as a central
+   extension of the free
+   `R[T]` module generated by `\mathfrak{g}` by a central element `K`. The
+   `\lambda`-bracket of generators is given by
+
+   .. MATH::
+
+        [a_\lambda b] = [a,b] + \lambda (a,b) K, \qquad a,b \in \mathfrak{g}
+
+3. The **Weyl** Lie conformal algebra, or `\beta-\gamma` system is
+   given as the central extension of a free `R[T]` module with two
+   generators `\beta` and `\gamma`, by a central element `K`.
+   The only non-trivial brackets among generators are
+
+   .. MATH::
+
+        [\beta_\lambda \gamma] = - [\gamma_\lambda \beta] = K
+
+4. The **Neveu-Schwarz** super Lie conformal algebra is a super Lie
+   conformal algebra which is an extension of the Virasoro Lie conformal
+   algebra. It consists of a Virasoro generator `L` as in example 1 above
+   and an *odd* generator `G`. The remaining brackets are given by:
+
+   .. MATH::
+
+        [L_\lambda G] = \left( T + \frac{3}{2} \lambda \right) G \qquad
+        [G_\lambda G] = 2 L + \frac{\lambda^2}{3} C
+
+.. SEEALSO::
+
+    - :mod:`sage.algebras.lie_conformal_algebras.lie_conformal_algebra`
+    - :mod:`sage.algebras.lie_conformal_algebras.examples`
+
+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.lambda_bracket_algebras import LambdaBracketAlgebras
+from sage.misc.cachefunc import cached_method
+from sage.misc.lazy_import import LazyImport
+
+
+class LieConformalAlgebras(Category_over_base_ring):
+    r"""
+    The category of Lie conformal algebras.
+
+    This is the base category for all Lie conformal algebras.
+    Subcategories with axioms are ``FinitelyGenerated`` and
+    ``WithBasis``. A *finitely generated* Lie conformal algebra is a
+    Lie conformal algebra over `R` which is finitely generated as an
+    `R[T]`-module. A Lie conformal algebra *with basis* is one with a
+    preferred basis as an `R`-module.
+
+    EXAMPLES:
+
+    The base category::
+
+        sage: C = LieConformalAlgebras(QQ); C
+        Category of Lie conformal algebras over Rational Field
+        sage: C.is_subcategory(VectorSpaces(QQ))
+        True
+
+    Some subcategories::
+
+        sage: LieConformalAlgebras(QQbar).FinitelyGenerated().WithBasis()               # needs sage.rings.number_field
+        Category of finitely generated Lie conformal algebras with basis
+         over Algebraic Field
+
+    In addition we support functorial constructions ``Graded`` and
+    ``Super``. These functors commute::
+
+        sage: CGS = LieConformalAlgebras(AA).Graded().Super(); CGS                      # needs sage.rings.number_field
+        Category of H-graded super Lie conformal algebras over Algebraic Real Field
+        sage: CGS is LieConformalAlgebras(AA).Super().Graded()                          # needs sage.rings.number_field
+        True
+
+    That is, we only consider gradings on super Lie conformal algebras
+    that are compatible with the `\ZZ/2\ZZ` grading.
+
+    The base ring needs to be a commutative ring::
+
+        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
+    """
+    @cached_method
+    def super_categories(self):
+        """
+        The list of super categories of this category.
+
+        EXAMPLES::
+
+            sage: C = LieConformalAlgebras(QQ)
+            sage: C.super_categories()
+            [Category of Lambda bracket algebras over Rational Field]
+            sage: C = LieConformalAlgebras(QQ).FinitelyGenerated(); C
+            Category of finitely generated Lie conformal algebras over Rational Field
+            sage: C.super_categories()
+            [Category of finitely generated lambda bracket algebras over Rational Field,
+             Category of Lie conformal algebras over Rational Field]
+            sage: C.all_super_categories()
+            [Category of finitely generated Lie conformal algebras over Rational Field,
+             Category of finitely generated lambda bracket algebras over Rational Field,
+             Category of Lie conformal algebras over Rational Field,
+             Category of Lambda bracket algebras over Rational Field,
+             Category of vector spaces over Rational Field,
+             Category of modules over Rational Field,
+             Category of bimodules over Rational Field on the left and Rational Field on the right,
+             Category of right modules over Rational Field,
+             Category of left modules over Rational Field,
+             Category of commutative additive groups,
+             Category of additive groups,
+             Category of additive inverse additive unital additive magmas,
+             Category of commutative additive monoids,
+             Category of additive monoids,
+             Category of additive unital additive magmas,
+             Category of commutative additive semigroups,
+             Category of additive commutative additive magmas,
+             Category of additive semigroups,
+             Category of additive magmas,
+             Category of sets,
+             Category of sets with partial maps,
+             Category of objects]
+        """
+        return [LambdaBracketAlgebras(self.base_ring())]
+
+    def example(self):
+        """
+        An example of parent in this category.
+
+        EXAMPLES::
+
+            sage: LieConformalAlgebras(QQ).example()                                    # needs sage.combinat sage.modules
+            The Virasoro Lie conformal algebra over Rational Field
+        """
+        from sage.algebras.lie_conformal_algebras.virasoro_lie_conformal_algebra import (
+            VirasoroLieConformalAlgebra,
+        )
+        return VirasoroLieConformalAlgebra(self.base_ring())
+
+    def _repr_object_names(self):
+        """
+        The name of the objects of this category.
+
+        EXAMPLES::
+
+            sage: LieConformalAlgebras(QQ)
+            Category of Lie conformal algebras over Rational Field
+        """
+        return "Lie conformal algebras over {}".format(self.base_ring())
+
+    class ParentMethods:
+
+        def _test_jacobi(self, **options):
+            """
+            Test the Jacobi axiom of this 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, names=('a', 'b'), parity=(1, 0))       # needs sage.combinat sage.modules
+                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()
+            from sage.arith.misc import binomial
+            from sage.misc.misc import some_tuples
+            pz = tester._instance.zero()
+            for x,y,z in some_tuples(S, 3, tester._max_runs):
+                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) - v
+                jacobiator = {k: v for k,v in jac1.items() if v}
+                tester.assertDictEqual(jacobiator, {})
+
+    class ElementMethods:
+
+        def is_even_odd(self):
+            """
+            Return ``0`` if this element is *even* and ``1`` if it is
+            *odd*.
+
+            .. NOTE::
+
+                This method returns ``0`` by default since every Lie
+                conformal algebra can be thought as a purely even Lie
+                conformal algebra. In order to
+                implement a super Lie conformal algebra, the user
+                needs to implement this method.
+
+            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
+            """
+            return 0
+
+    Graded = LazyImport("sage.categories.graded_lie_conformal_algebras",
+                        "GradedLieConformalAlgebras", "Graded")
+
+    Super = LazyImport("sage.categories.super_lie_conformal_algebras",
+                       "SuperLieConformalAlgebras", "Super")
+
+    WithBasis = LazyImport("sage.categories.lie_conformal_algebras_with_basis",
+                           "LieConformalAlgebrasWithBasis", "WithBasis")
+
+    FinitelyGeneratedAsLambdaBracketAlgebra = LazyImport(
+        'sage.categories.finitely_generated_lie_conformal_algebras',
+        'FinitelyGeneratedLieConformalAlgebras')