passagemath-combinat 10.6.42__cp314-cp314-musllinux_1_2_x86_64.whl

sage/algebras/lie_conformal_algebras/finitely_freely_generated_lca.py

@@ -0,0 +1,139 @@
+# sage_setup: distribution = sagemath-combinat
+# sage.doctest: needs sage.combinat sage.modules
+"""
+Finitely and Freely Generated Lie Conformal Algebras.
+
+AUTHORS:
+
+- Reimundo Heluani (2019-08-09): 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.misc.cachefunc import cached_method
+from sage.categories.lie_conformal_algebras import LieConformalAlgebras
+from .freely_generated_lie_conformal_algebra import \
+                                            FreelyGeneratedLieConformalAlgebra
+
+
+class FinitelyFreelyGeneratedLCA(FreelyGeneratedLieConformalAlgebra):
+    """
+    Abstract base class for finitely generated Lie conformal
+    algebras.
+
+    This class provides minimal functionality, simply sets the
+    number of generators.
+    """
+    def __init__(self, R, index_set=None, central_elements=None, category=None,
+                 element_class=None, prefix=None, names=None, latex_names=None,
+                 **kwds):
+        """
+        Initialize ``self``.
+
+        TESTS::
+
+            sage: V = lie_conformal_algebras.Virasoro(QQ)
+            sage: TestSuite(V).run()
+        """
+        default_category = LieConformalAlgebras(R).FinitelyGenerated()
+        try:
+            category = default_category.or_subcategory(category)
+        except ValueError:
+            category = default_category.Super().or_subcategory(category)
+
+        from sage.categories.sets_cat import Sets
+        if index_set not in Sets().Finite():
+            raise TypeError("index_set must be a finite set")
+
+        super().__init__(R,
+                         index_set=index_set, central_elements=central_elements,
+                         category=category, element_class=element_class,
+                         prefix=prefix, **kwds)
+        self._ngens = len(self._generators)
+        self._names = names
+        self._latex_names = latex_names
+
+    def _repr_(self) -> str:
+        """
+        The name of this Lie conformal algebra.
+
+        EXAMPLES::
+
+            sage: bosondict = {('a','a'):{1:{('K',0):1}}}
+            sage: R = LieConformalAlgebra(QQ,bosondict,names=('a',),central_elements=('K',))
+            sage: R
+            Lie conformal algebra with generators (a, K) over Rational Field
+        """
+        if self._ngens == 1:
+            return "Lie conformal algebra generated by {} over {}".format(
+                self.gen(0), self.base_ring())
+        return "Lie conformal algebra with generators {} over {}".format(
+            self.gens(), self.base_ring())
+
+    def _an_element_(self):
+        """
+        An element of this Lie conformal algebra.
+
+        EXAMPLES::
+
+            sage: R = lie_conformal_algebras.NeveuSchwarz(QQ); R.an_element()
+            L + G + C
+        """
+        return self.sum(self.gens())
+
+    def ngens(self):
+        """
+        The number of generators of this Lie conformal algebra.
+
+        EXAMPLES::
+
+            sage: Vir = lie_conformal_algebras.Virasoro(QQ); Vir.ngens()
+            2
+            sage: V = lie_conformal_algebras.Affine(QQ, 'A1'); V.ngens()
+            4
+        """
+        return self._ngens
+
+    @cached_method
+    def gens(self):
+        """
+        The generators for this Lie conformal algebra.
+
+        OUTPUT:
+
+        This method returns a tuple with the (finite) generators
+        of this Lie conformal algebra.
+
+        EXAMPLES::
+
+            sage: Vir = lie_conformal_algebras.Virasoro(QQ);
+            sage: Vir.gens()
+            (L, C)
+
+        .. SEEALSO::
+
+            :meth:`lie_conformal_algebra_generators<\
+            FreelyGeneratedLieConformalAlgebra.\
+            lie_conformal_algebra_generators>`
+        """
+        return self.lie_conformal_algebra_generators()
+
+    @cached_method
+    def central_elements(self):
+        """
+        The central elements of this Lie conformal algebra.
+
+        EXAMPLES::
+
+            sage: R = lie_conformal_algebras.NeveuSchwarz(QQ); R.central_elements()
+            (C,)
+        """
+        return tuple(FreelyGeneratedLieConformalAlgebra.central_elements(self))

sage/algebras/lie_conformal_algebras/free_bosons_lie_conformal_algebra.py

@@ -0,0 +1,174 @@
+# sage_setup: distribution = sagemath-combinat
+# sage.doctest: needs sage.combinat sage.modules
+r"""
+Free Bosons Lie Conformal Algebra
+
+Given an `R`-module `M` with a symmetric, bilinear pairing
+`(\cdot, \cdot): M\otimes_R M \rightarrow R`. The *Free Bosons*
+Lie conformal algebra associated to this datum is the free
+`R[T]`-module generated by `M` plus a central vector `K` satisfying
+`TK=0`. The remaining `\lambda`-brackets are given by:
+
+.. MATH::
+
+    [v_\lambda w] = \lambda (v,w)K,
+
+where `v,w \in M`.
+
+This is an H-graded Lie conformal algebra where every generator
+`v \in M` has degree 1.
+
+AUTHORS:
+
+- Reimundo Heluani (2019-08-09): 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.matrix.special import identity_matrix
+from .graded_lie_conformal_algebra import GradedLieConformalAlgebra
+from sage.structure.indexed_generators import standardize_names_index_set
+
+
+class FreeBosonsLieConformalAlgebra(GradedLieConformalAlgebra):
+    r"""
+    The Free Bosons Lie conformal algebra.
+
+    INPUT:
+
+    - ``R`` -- a commutative ring
+    - ``ngens`` -- a positive Integer (default: `1`); the number of
+      non-central generators of this Lie conformal algebra.
+    - ``gram_matrix`` -- a symmetric square matrix with coefficients
+      in ``R`` (default: ``identity_matrix(ngens)``); the Gram
+      matrix of the inner product
+    - ``names`` -- tuple of strings; alternative names for the
+      generators
+    - ``index_set`` -- an enumerated set; alternative indexing set
+      for the generators
+
+    OUTPUT:
+
+    The Free Bosons Lie conformal algebra with generators
+     `\alpha_i`, `i=1,...,n` and `\lambda`-brackets
+
+     .. MATH::
+
+        [{\alpha_i}_{\lambda} \alpha_j] = \lambda M_{ij} K,
+
+    where `n` is the number of generators ``ngens`` and `M` is
+    the ``gram_matrix``. This Lie conformal
+    algebra is `H`-graded where every generator has conformal weight
+    `1`.
+
+    EXAMPLES::
+
+        sage: R = lie_conformal_algebras.FreeBosons(AA); R
+        The free Bosons Lie conformal algebra with generators (alpha, K) over Algebraic Real Field
+        sage: R.inject_variables()
+        Defining alpha, K
+        sage: alpha.bracket(alpha)
+        {1: K}
+        sage: M = identity_matrix(QQ,2); R = lie_conformal_algebras.FreeBosons(QQ,gram_matrix=M, names='alpha,beta'); R
+        The free Bosons Lie conformal algebra with generators (alpha, beta, K) over Rational Field
+        sage: R.inject_variables(); alpha.bracket(beta)
+        Defining alpha, beta, K
+        {}
+        sage: alpha.bracket(alpha)
+        {1: K}
+        sage: R = lie_conformal_algebras.FreeBosons(QQbar, ngens=3); R
+        The free Bosons Lie conformal algebra with generators (alpha0, alpha1, alpha2, K) over Algebraic Field
+
+    TESTS::
+        sage: R = lie_conformal_algebras.FreeBosons(QQ); R.0.degree()
+        1
+        sage: R = lie_conformal_algebras.FreeBosons(QQbar, ngens=2, gram_matrix=identity_matrix(QQ,1,1))
+        Traceback (most recent call last):
+        ...
+        ValueError: the gram_matrix should be a symmetric 2 x 2 matrix, got [1]
+        sage: R = lie_conformal_algebras.FreeBosons(QQbar, ngens=2, gram_matrix=Matrix(QQ,[[0,1],[-1,0]]))
+        Traceback (most recent call last):
+        ...
+        ValueError: the gram_matrix should be a symmetric 2 x 2 matrix, got [ 0  1]
+        [-1  0]
+    """
+    def __init__(self, R, ngens=None, gram_matrix=None, names=None,
+                 index_set=None):
+        """
+        Initialize ``self``.
+
+        TESTS::
+
+            sage: V = lie_conformal_algebras.FreeBosons(QQ)
+            sage: TestSuite(V).run()
+        """
+        from sage.matrix.matrix_space import MatrixSpace
+        if (gram_matrix is not None):
+            if ngens is None:
+                ngens = gram_matrix.dimensions()[0]
+            try:
+                assert (gram_matrix in MatrixSpace(R, ngens, ngens))
+            except AssertionError:
+                raise ValueError("the gram_matrix should be a symmetric " +
+                    "{0} x {0} matrix, got {1}".format(ngens, gram_matrix))
+            if not gram_matrix.is_symmetric():
+                raise ValueError("the gram_matrix should be a symmetric " +
+                    "{0} x {0} matrix, got {1}".format(ngens, gram_matrix))
+        else:
+            if ngens is None:
+                ngens = 1
+            gram_matrix = identity_matrix(R, ngens, ngens)
+
+        latex_names = None
+        if names is None and index_set is None:
+            names = 'alpha'
+            latex_names = tuple(r'\alpha_{%d}' % i
+                                for i in range(ngens)) + ('K',)
+        names, index_set = standardize_names_index_set(names=names,
+                                                       index_set=index_set,
+                                                       ngens=ngens)
+        bosondict = {(i, j): {1: {('K', 0): gram_matrix[index_set.rank(i),
+                                                        index_set.rank(j)]}}
+                     for i in index_set for j in index_set}
+
+        GradedLieConformalAlgebra.__init__(self, R, bosondict,
+                                           names=names,
+                                           latex_names=latex_names,
+                                           index_set=index_set,
+                                           central_elements=('K',))
+
+        self._gram_matrix = gram_matrix
+
+    def _repr_(self) -> str:
+        """
+        String representation.
+
+        EXAMPLES::
+
+            sage: lie_conformal_algebras.FreeBosons(AA)
+            The free Bosons Lie conformal algebra with generators (alpha, K) over Algebraic Real Field
+        """
+        return "The free Bosons Lie conformal algebra with generators {}"\
+            " over {}".format(self.gens(), self.base_ring())
+
+    def gram_matrix(self):
+        r"""
+        The Gram matrix that specifies the `\lambda`-brackets of the
+        generators.
+
+        EXAMPLES::
+
+            sage: R = lie_conformal_algebras.FreeBosons(QQ,ngens=2);
+            sage: R.gram_matrix()
+            [1 0]
+            [0 1]
+        """
+        return self._gram_matrix

sage/algebras/lie_conformal_algebras/free_fermions_lie_conformal_algebra.py

@@ -0,0 +1,167 @@
+# sage_setup: distribution = sagemath-combinat
+# sage.doctest: needs sage.combinat sage.modules
+r"""
+Free Fermions Super Lie Conformal Algebra.
+
+Given an `R`-module `M` with a skew-symmetric, bilinear pairing
+`\langle\cdot, \cdot\rangle: M\otimes_R M \rightarrow R`. The
+*Free Fermions* super Lie conformal algebra associated to this datum is
+the free `R[T]`-super module generated by `\Pi M` (a purely odd copy
+of `M`) plus a central vector `K` satisfying `TK=0`. The remaining
+`\lambda`-brackets are given by:
+
+.. MATH::
+
+    [v_\lambda w] = \langle v,w \rangle K,
+
+where `v,w \in M`.
+
+This is an H-graded Lie conformal algebra where every generator
+`v \in M` has degree `1/2`.
+
+
+AUTHORS:
+
+- Reimundo Heluani (2020-06-03): 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 .graded_lie_conformal_algebra import GradedLieConformalAlgebra
+
+
+class FreeFermionsLieConformalAlgebra(GradedLieConformalAlgebra):
+    r"""
+    The Free Fermions Super Lie conformal algebra.
+
+    INPUT:
+
+    - ``R`` -- a commutative ring
+    - ``ngens`` -- a positive Integer (default: ``1``); the number of
+      non-central generators of this Lie conformal algebra
+    - ``gram_matrix`` -- a symmetric square matrix with coefficients
+      in ``R`` (default: ``identity_matrix(ngens)``); the Gram
+      matrix of the inner product
+
+    OUTPUT:
+
+    The Free Fermions Lie conformal algebra with generators
+     `\psi_i`, `i=1,...,n` and `\lambda`-brackets
+
+     .. MATH::
+
+        [{\psi_i}_{\lambda} \psi_j] = M_{ij} K,
+
+    where `n` is the number of generators ``ngens`` and `M` is the
+    ``gram_matrix``. This super Lie conformal
+    algebra is `H`-graded where every generator has degree `1/2`.
+
+    EXAMPLES::
+
+        sage: R = lie_conformal_algebras.FreeFermions(QQbar); R
+        The free Fermions super Lie conformal algebra with generators (psi, K) over Algebraic Field
+        sage: R.inject_variables()
+        Defining psi, K
+        sage: psi.bracket(psi)
+        {0: K}
+
+        sage: R = lie_conformal_algebras.FreeFermions(QQbar,gram_matrix=Matrix([[0,1],[1,0]])); R
+        The free Fermions super Lie conformal algebra with generators (psi_0, psi_1, K) over Algebraic Field
+        sage: R.inject_variables()
+        Defining psi_0, psi_1, K
+        sage: psi_0.bracket(psi_1)
+        {0: K}
+        sage: psi_0.degree()
+        1/2
+        sage: R.category()
+        Category of H-graded super finitely generated Lie conformal algebras with basis over Algebraic Field
+    """
+    def __init__(self, R, ngens=None, gram_matrix=None, names=None,
+                 index_set=None):
+        """
+        Initialize ``self``.
+
+        TESTS::
+
+            sage: V = lie_conformal_algebras.FreeFermions(QQ)
+            sage: TestSuite(V).run()
+        """
+        from sage.matrix.matrix_space import MatrixSpace
+        from sage.matrix.special import identity_matrix
+        if gram_matrix is not None:
+            if ngens is None:
+                ngens = gram_matrix.dimensions()[0]
+            try:
+                assert (gram_matrix in MatrixSpace(R, ngens, ngens))
+            except AssertionError:
+                raise ValueError("the Gram_matrix should be a symmetric " +
+                    "{0} x {0} matrix, got {1}".format(ngens, gram_matrix))
+            if not gram_matrix.is_symmetric():
+                raise ValueError("the Gram_matrix should be a symmetric " +
+                    "{0} x {0} matrix, got {1}".format(ngens, gram_matrix))
+        else:
+            if ngens is None:
+                ngens = 1
+            gram_matrix = identity_matrix(R, ngens, ngens)
+
+        latex_names = None
+
+        if names is None and index_set is None:
+            names = 'psi' if ngens == 1 else 'psi_'
+            latex_names = tuple(r"\psi_{%d}" % i
+                                for i in range(ngens)) + ('K',)
+
+        from sage.structure.indexed_generators import \
+            standardize_names_index_set
+        names, index_set = standardize_names_index_set(names=names,
+                                                       index_set=index_set,
+                                                       ngens=ngens)
+        fermiondict = {(i, j): {0: {('K', 0): gram_matrix[index_set.rank(i),
+                                                          index_set.rank(j)]}}
+                       for i in index_set for j in index_set}
+
+        from sage.rings.rational_field import QQ
+        weights = (QQ((1, 2)),) * ngens
+        parity = (1,) * ngens
+        GradedLieConformalAlgebra.__init__(self, R, fermiondict, names=names,
+                                           latex_names=latex_names,
+                                           index_set=index_set,
+                                           weights=weights,
+                                           parity=parity,
+                                           central_elements=('K',))
+
+        self._gram_matrix = gram_matrix
+
+    def _repr_(self) -> str:
+        """
+        String representation.
+
+        EXAMPLES::
+
+            sage: lie_conformal_algebras.FreeFermions(QQ)
+            The free Fermions super Lie conformal algebra with generators (psi, K) over Rational Field
+        """
+        return "The free Fermions super Lie conformal algebra "\
+            "with generators {} over {}".format(self.gens(),
+                                                self.base_ring())
+
+    def gram_matrix(self):
+        r"""
+        The Gram matrix that specifies the `\lambda`-brackets of the
+        generators.
+
+        EXAMPLES::
+
+            sage: R = lie_conformal_algebras.FreeFermions(QQ,ngens=2);
+            sage: R.gram_matrix()
+            [1 0]
+            [0 1]
+        """
+        return self._gram_matrix

sage/algebras/lie_conformal_algebras/freely_generated_lie_conformal_algebra.py

@@ -0,0 +1,107 @@
+# sage_setup: distribution = sagemath-combinat
+# sage.doctest: needs sage.combinat sage.modules
+"""
+Freely Generated Lie Conformal Algebras
+
+AUTHORS:
+
+- Reimundo Heluani (2019-08-09): 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 .lie_conformal_algebra_with_basis import LieConformalAlgebraWithBasis
+from sage.sets.non_negative_integers import NonNegativeIntegers
+from sage.categories.cartesian_product import cartesian_product
+from sage.rings.integer import Integer
+from sage.sets.family import Family
+from sage.sets.disjoint_union_enumerated_sets import DisjointUnionEnumeratedSets
+
+
+class FreelyGeneratedLieConformalAlgebra(LieConformalAlgebraWithBasis):
+    """
+    Base class for a central extension of a freely generated Lie
+    conformal algebra.
+
+    This class provides minimal functionality, it sets up the
+    family of Lie conformal algebra generators.
+
+    .. NOTE::
+
+        We now only accept direct sums of free modules plus
+        some central generators `C_i` such that `TC_i = 0`.
+    """
+    def __init__(self, R, index_set=None, central_elements=None, category=None,
+                 element_class=None, prefix=None, **kwds):
+        """
+        Initialize ``self``.
+
+        TESTS::
+
+            sage: V = lie_conformal_algebras.Virasoro(QQ)
+            sage: TestSuite(V).run()
+        """
+        self._generators = Family(index_set)
+        E = cartesian_product([index_set, NonNegativeIntegers()])
+        if central_elements is not None:
+            self._generators = DisjointUnionEnumeratedSets([index_set,
+                                                    Family(central_elements)])
+            E = DisjointUnionEnumeratedSets((cartesian_product([
+                Family(central_elements), {Integer(0)}]), E))
+
+        super().__init__(R, basis_keys=E, element_class=element_class,
+                         category=category, prefix=prefix, **kwds)
+
+        if central_elements is not None:
+            self._central_elements = Family(central_elements)
+        else:
+            self._central_elements = ()
+
+    def lie_conformal_algebra_generators(self):
+        """
+        The generators of this Lie conformal algebra.
+
+        OUTPUT: a (possibly infinite) family of generators (as an
+        `R[T]`-module) of this Lie conformal algebra.
+
+        EXAMPLES::
+
+            sage: Vir = lie_conformal_algebras.Virasoro(QQ)
+            sage: Vir.lie_conformal_algebra_generators()
+            (L, C)
+            sage: V = lie_conformal_algebras.Affine(QQ,'A1')
+            sage: V.lie_conformal_algebra_generators()
+            (B[alpha[1]], B[alphacheck[1]], B[-alpha[1]], B['K'])
+        """
+        F = Family(self._generators,
+                   lambda i: self.monomial((i, Integer(0))),
+                   name="generator map")
+        from sage.categories.sets_cat import Sets
+        if F in Sets().Finite():
+            return tuple(F)
+        return F
+
+    def central_elements(self):
+        """
+        The central generators of this Lie conformal algebra.
+
+        EXAMPLES::
+
+            sage: Vir = lie_conformal_algebras.Virasoro(QQ)
+            sage: Vir.central_elements()
+            (C,)
+            sage: V = lie_conformal_algebras.Affine(QQ, 'A1')
+            sage: V.central_elements()
+            (B['K'],)
+        """
+        return Family(self._central_elements,
+                      lambda i: self.monomial((i, Integer(0))),
+                      name="central_element map")