passagemath-combinat 10.6.42__cp314-cp314-musllinux_1_2_x86_64.whl

sage/algebras/lie_conformal_algebras/abelian_lie_conformal_algebra.py

@@ -0,0 +1,113 @@
+# sage_setup: distribution = sagemath-combinat
+# sage.doctest: needs sage.combinat sage.modules
+r"""
+Abelian Lie Conformal Algebra
+
+For a commutative ring `R` and a free `R`-module `M`. The *Abelian Lie
+conformal algebra* generated by `M` is the free `R[T]` module
+generated by `M` with vanishing `\lambda`-brackets.
+
+AUTHORS:
+
+- Reimundo Heluani (2020-06-15): 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 .graded_lie_conformal_algebra import GradedLieConformalAlgebra
+from sage.structure.indexed_generators import standardize_names_index_set
+
+
+class AbelianLieConformalAlgebra(GradedLieConformalAlgebra):
+    r"""
+    The Abelian Lie conformal algebra.
+
+    INPUT:
+
+    - ``R`` -- a commutative ring; the base ring of this Lie
+      conformal algebra
+    - ``ngens`` -- positive integer (default: `1`); the number
+      of generators of this Lie conformal algebra
+    - ``weights`` -- list of positive rational numbers (default:
+      `1` for each generator); the weights of the generators. The resulting
+      Lie conformal algebra is `H`-graded.
+    - ``parity`` -- ``None`` or a list of ``0`` or ``1`` (default:
+      ``None``); the parity of the generators. If not ``None`` the
+      resulting Lie Conformal algebra is a Super Lie conformal
+      algebra
+    - ``names`` -- tuple of strings or ``None`` (default: ``None``);
+      the list of names of the generators of this algebra.
+    - ``index_set`` -- an enumerated set or ``None`` (default:
+      ``None``); a set indexing the generators of this Lie
+      conformal algebra
+
+    OUTPUT:
+
+    The Abelian Lie conformal algebra with generators `a_i`,
+    `i=1,...,n` and vanishing `\lambda`-brackets, where `n` is
+    ``ngens``.
+
+    EXAMPLES::
+
+        sage: R = lie_conformal_algebras.Abelian(QQ,2); R
+        The Abelian Lie conformal algebra with generators (a0, a1) over Rational Field
+        sage: R.inject_variables()
+        Defining a0, a1
+        sage: a0.bracket(a1.T(2))
+        {}
+
+    TESTS::
+
+        sage: R.central_elements()
+        ()
+        sage: R.structure_coefficients()
+        Finite family {}
+
+    .. TODO::
+
+        implement its own class to speed up arithmetics in this
+        case.
+    """
+    def __init__(self, R, ngens=1, weights=None,
+                 parity=None, names=None, index_set=None):
+        """
+        Initialize ``self``.
+
+        EXAMPLES::
+
+            sage: V = lie_conformal_algebras.Abelian(QQ)
+            sage: TestSuite(V).run()
+        """
+        if (names is None) and (index_set is None):
+            names = 'a'
+            self._latex_names = tuple(r'a_{%d}' % i for i in range(ngens))
+
+        names, index_set = standardize_names_index_set(names=names,
+                                                       index_set=index_set,
+                                                       ngens=ngens)
+        abeliandict = {}
+
+        GradedLieConformalAlgebra.__init__(self, R, abeliandict, names=names,
+                                           index_set=index_set,
+                                           weights=weights,
+                                           parity=parity)
+
+    def _repr_(self) -> str:
+        """
+        String representation.
+
+        EXAMPLES::
+
+            sage: lie_conformal_algebras.Abelian(QQ)
+            The Abelian Lie conformal algebra with generators (a,) over Rational Field
+        """
+        return "The Abelian Lie conformal algebra with generators {} over {}"\
+                .format(self.gens(), self.base_ring())

sage/algebras/lie_conformal_algebras/affine_lie_conformal_algebra.py

@@ -0,0 +1,156 @@
+# sage_setup: distribution = sagemath-combinat
+# sage.doctest: needs sage.combinat sage.modules
+r"""
+Affine Lie Conformal Algebra
+
+The affine Kac-Moody Lie conformal algebra associated to the
+finite dimensional simple Lie algebra `\mathfrak{g}`. For a commutative
+ring `R`, it is the `R[T]`-module freely generated by `\mathfrak{g}`
+plus a central element `K` satisfying `TK = 0`. The non-vanishing
+`\lambda`-brackets are given by
+
+.. MATH::
+
+    [a_\lambda b] = [a,b] + \lambda (a,b)K,
+
+where `a,b \in \mathfrak{g}` and `(a,b)` is the normalized
+form of `\mathfrak{g}` so that its longest root has square-norm
+`2`.
+
+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.rings.integer import Integer
+from sage.algebras.lie_algebras.lie_algebra import LieAlgebra
+from .graded_lie_conformal_algebra import GradedLieConformalAlgebra
+
+
+class AffineLieConformalAlgebra(GradedLieConformalAlgebra):
+    r"""
+    The current or affine Kac-Moody Lie conformal algebra.
+
+    INPUT:
+
+    - ``R`` -- a commutative Ring; the base ring for this Lie
+      conformal algebra
+    - ``ct`` -- a ``str`` or a :mod:`CartanType<sage.combinat.\
+      root_system.cartan_type>`; the Cartan Type for
+      the corresponding finite dimensional Lie algebra. It must
+      correspond to a simple finite dimensional Lie algebra.
+    - ``names`` -- list of ``str`` or ``None`` (default: ``None``);
+      alternative names for the generators. If ``None`` the
+      generators are labeled by the corresponding root and coroot
+      vectors.
+    - ``prefix`` -- a ``str``; parameter passed to
+      :class:`IndexedGenerators<sage.structure.indexed_generators.IndexedGenerators>`
+    - ``bracket`` -- a ``str``; parameter passed to
+      :class:`IndexedGenerators<sage.structure.indexed_generators.IndexedGenerators>`
+
+    EXAMPLES::
+
+        sage: R = lie_conformal_algebras.Affine(QQ, 'A1')
+        sage: R
+        The affine Lie conformal algebra of type ['A', 1] over Rational Field
+        sage: R.an_element()
+        B[alpha[1]] + B[alphacheck[1]] + B[-alpha[1]] + B['K']
+
+        sage: R = lie_conformal_algebras.Affine(QQ, 'A1', names = ('e', 'h','f'))
+        sage: R.inject_variables()
+        Defining e, h, f, K
+        sage: Family(e.bracket(f.T(3)))
+        Finite family {0: 6*T^(3)h, 1: 6*T^(2)h, 2: 6*Th, 3: 6*h, 4: 24*K}
+
+        sage: V = lie_conformal_algebras.Affine(QQ, CartanType(["A",2,1]))
+        Traceback (most recent call last):
+        ...
+        ValueError: only affine algebras of simple finite dimensionalLie algebras are implemented
+
+    OUTPUT:
+
+    The Affine Lie conformal algebra associated with the finite
+    dimensional simple Lie algebra of Cartan type ``ct``.
+    """
+    def __init__(self, R, ct, names=None, prefix=None, bracket=None):
+        """
+        Initialize ``self``.
+
+        TESTS::
+
+            sage: V = lie_conformal_algebras.Affine(QQ,'A1')
+            sage: TestSuite(V).run()
+        """
+        if type(ct) is str:
+            from sage.combinat.root_system.cartan_type import CartanType
+            try:
+                ct = CartanType(ct)
+            except IndexError:
+                raise ValueError("ct must be a valid Cartan Type")
+        if not (ct.is_finite() and ct.is_irreducible):
+            raise ValueError("only affine algebras of simple finite dimensional"
+                "Lie algebras are implemented")
+        hv = Integer(ct.dual_coxeter_number())
+        g = LieAlgebra(R, cartan_type=ct)
+        B = g.basis()
+        S = B.keys()
+        gdict = {}
+        for k1 in S:
+            for k2 in S:
+                if S.rank(k2) <= S.rank(k1):
+                    myb = B[k1].bracket(B[k2]).monomial_coefficients()
+                    myf = R(2).inverse_of_unit()*R(hv).inverse_of_unit()\
+                          * g.killing_form(B[k1], B[k2])
+                    if myb or myf:
+                        gdict[(k1, k2)] = {}
+                        if myb:
+                            gdict[(k1, k2)][0] = {(nk, 0): v
+                                                  for nk, v in myb.items()}
+                        if myf:
+                            gdict[(k1, k2)][1] = {('K', 0): myf}
+
+        weights = (1,) * B.cardinality()
+        self._ct = ct
+        if prefix is None and names is None:
+            prefix = 'B'
+
+        GradedLieConformalAlgebra.__init__(self,
+            R, gdict, index_set=S,
+            central_elements=('K',), weights=weights,
+            names=names, prefix=prefix, bracket=bracket)
+
+    def cartan_type(self):
+        """
+        The Cartan type of this Lie conformal algbera.
+
+        EXAMPLES::
+
+            sage: R = lie_conformal_algebras.Affine(QQ, 'B3')
+            sage: R
+            The affine Lie conformal algebra of type ['B', 3] over Rational Field
+            sage: R.cartan_type()
+            ['B', 3]
+        """
+        return self._ct
+
+    def _repr_(self) -> str:
+        """
+        The name of this Lie conformal algebra.
+
+        EXAMPLES::
+
+            sage: lie_conformal_algebras.Affine(QQ, 'A1')
+            The affine Lie conformal algebra of type ['A', 1] over Rational Field
+        """
+        return "The affine Lie conformal algebra of type {} over {}".format(
+                                                    self._ct, self.base_ring())

sage/algebras/lie_conformal_algebras/all.py

@@ -0,0 +1,18 @@
+# sage_setup: distribution = sagemath-combinat
+# ******************************************************************************
+#       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.
+#                  https://www.gnu.org/licenses/
+# *****************************************************************************
+
+
+from sage.misc.lazy_import import lazy_import
+lazy_import('sage.algebras.lie_conformal_algebras.lie_conformal_algebra',
+            'LieConformalAlgebra')
+lazy_import('sage.algebras.lie_conformal_algebras',
+            'examples', 'lie_conformal_algebras')
+del lazy_import

sage/algebras/lie_conformal_algebras/bosonic_ghosts_lie_conformal_algebra.py

@@ -0,0 +1,134 @@
+# sage_setup: distribution = sagemath-combinat
+# sage.doctest: needs sage.combinat sage.modules
+r"""
+Bosonic Ghosts Lie Conformal Algebra
+
+The *Bosonic-ghosts* or `\beta-\gamma`-system Lie conformal algebra
+with `2n` generators is the H-graded Lie conformal algebra generated
+by `\beta_i, \gamma_i, i = 1,\ldots,n` and a central element `K`, with
+non-vanishing `\lambda`-brackets:
+
+.. MATH::
+
+    [{\beta_i}_\lambda \gamma_j] = \delta_{ij} K.
+
+The generators `\beta_i` have degree `1` while the generators `\gamma_i`
+have degree `0`.
+
+AUTHORS:
+
+- Reimundo Heluani (2020-06-15): 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 sage.structure.indexed_generators import standardize_names_index_set
+from .graded_lie_conformal_algebra import GradedLieConformalAlgebra
+
+
+class BosonicGhostsLieConformalAlgebra(GradedLieConformalAlgebra):
+    r"""
+    The Bosonic ghosts or `\beta-\gamma`-system Lie conformal
+    algebra.
+
+    INPUT:
+
+    - ``R`` -- a commutative ring
+    - ``ngens`` -- an even positive Integer (default: ``2``); the
+      number of non-central generators of this Lie conformal
+      algebra.
+    - ``names`` -- list of ``str``; alternative names for the
+      generators
+    - ``index_set`` -- an enumerated set; an indexing set for the
+      generators
+
+    OUTPUT:
+
+    The Bosonic Ghosts Lie conformal algebra with generators
+    `\beta_i,\gamma_i, i=1,\ldots,n` and `K`, where `2n` is
+    ``ngens``.
+
+    EXAMPLES::
+
+        sage: R = lie_conformal_algebras.BosonicGhosts(QQ); R
+        The Bosonic ghosts Lie conformal algebra with generators (beta, gamma, K) over Rational Field
+        sage: R.inject_variables(); beta.bracket(gamma)
+        Defining beta, gamma, K
+        {0: K}
+        sage: beta.degree()
+        1
+        sage: gamma.degree()
+        0
+
+        sage: R = lie_conformal_algebras.BosonicGhosts(QQbar, ngens = 4, names = 'abcd'); R
+        The Bosonic ghosts Lie conformal algebra with generators (a, b, c, d, K) over Algebraic Field
+        sage: R.structure_coefficients()
+        Finite family {('a', 'c'): ((0, K),),  ('b', 'd'): ((0, K),),  ('c', 'a'): ((0, -K),),  ('d', 'b'): ((0, -K),)}
+
+    TESTS::
+
+        sage: lie_conformal_algebras.BosonicGhosts(AA).category()
+        Category of H-graded finitely generated Lie conformal algebras with basis over Algebraic Real Field
+    """
+
+    def __init__(self, R, ngens=2, names=None, index_set=None):
+        """
+        Initialize ``self``.
+
+        TESTS::
+
+            sage: V = lie_conformal_algebras.BosonicGhosts(QQ)
+            sage: TestSuite(V).run()
+        """
+        from sage.rings.integer_ring import ZZ
+        try:
+            assert (ngens in ZZ and ngens > 0 and not ngens % 2)
+        except AssertionError:
+            raise ValueError("ngens should be an even positive integer, " +
+                             "got {}".format(ngens))
+        latex_names = None
+        half = ngens // 2
+        if (names is None) and (index_set is None):
+            from sage.misc.defaults import variable_names as varnames
+            from sage.misc.defaults import latex_variable_names as laxnames
+            names = varnames(half, 'beta') + varnames(half, 'gamma')
+            latex_names = tuple(laxnames(half, r'\beta') +
+                                laxnames(half, r'\gamma')) + ('K',)
+
+        names, index_set = standardize_names_index_set(names=names,
+                                                      index_set=index_set,
+                                                      ngens=ngens)
+        A = identity_matrix(R, half)
+        from sage.matrix.special import block_matrix
+        gram_matrix = block_matrix([[R.zero(), A], [-A, R.zero()]])
+        ghostsdict = {(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}
+        weights = (1,) * half + (0,) * half
+        super().__init__(R,
+                         ghostsdict, names=names,
+                         latex_names=latex_names,
+                         index_set=index_set,
+                         weights=weights,
+                         central_elements=('K',))
+
+    def _repr_(self) -> str:
+        """
+        String representation.
+
+        EXAMPLES::
+
+            sage: lie_conformal_algebras.BosonicGhosts(QQbar)
+            The Bosonic ghosts Lie conformal algebra with generators (beta, gamma, K) over Algebraic Field
+        """
+        return "The Bosonic ghosts Lie conformal algebra with generators {} "\
+            "over {}".format(self.gens(), self.base_ring())

sage/algebras/lie_conformal_algebras/examples.py

@@ -0,0 +1,43 @@
+# sage_setup: distribution = sagemath-combinat
+r"""
+Examples of Lie Conformal Algebras
+
+We implement the following examples of Lie conformal algebras:
+
+- :mod:`Abelian Lie conformal algebra<.abelian_lie_conformal_algebra>`
+- :mod:`Affine Lie conformal algebra<.affine_lie_conformal_algebra>`
+- :mod:`Bosonic Ghosts<.bosonic_ghosts_lie_conformal_algebra>`
+- :mod:`Fermionic Ghosts<.fermionic_ghosts_lie_conformal_algebra>`
+- :mod:`Free Bosons<.free_bosons_lie_conformal_algebra>`
+- :mod:`Free Fermions<.free_fermions_lie_conformal_algebra>`
+- :mod:`N=2 super Lie Conformal algebra<.n2_lie_conformal_algebra>`
+- :mod:`Neveu-Schwarz super Lie conformal
+  algebra<.neveu_schwarz_lie_conformal_algebra>`
+- :mod:`Virasoro Lie conformal algebra<.virasoro_lie_conformal_algebra>`
+- :mod:`Weyl Lie conformal algebra<.weyl_lie_conformal_algebra>`
+
+AUTHORS:
+
+- Reimundo Heluani (2020-06-15): 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.
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+from .abelian_lie_conformal_algebra import AbelianLieConformalAlgebra as Abelian
+from .affine_lie_conformal_algebra import AffineLieConformalAlgebra as Affine
+from .bosonic_ghosts_lie_conformal_algebra import BosonicGhostsLieConformalAlgebra as BosonicGhosts
+from .fermionic_ghosts_lie_conformal_algebra import FermionicGhostsLieConformalAlgebra as FermionicGhosts
+from .free_bosons_lie_conformal_algebra import FreeBosonsLieConformalAlgebra as FreeBosons
+from .free_fermions_lie_conformal_algebra import FreeFermionsLieConformalAlgebra as FreeFermions
+from .n2_lie_conformal_algebra import N2LieConformalAlgebra as N2
+from .neveu_schwarz_lie_conformal_algebra import NeveuSchwarzLieConformalAlgebra as NeveuSchwarz
+from .virasoro_lie_conformal_algebra import VirasoroLieConformalAlgebra as Virasoro
+from .weyl_lie_conformal_algebra import WeylLieConformalAlgebra as Weyl

sage/algebras/lie_conformal_algebras/fermionic_ghosts_lie_conformal_algebra.py

@@ -0,0 +1,131 @@
+# sage_setup: distribution = sagemath-combinat
+# sage.doctest: needs sage.combinat sage.modules
+r"""
+Fermionic Ghosts Super Lie Conformal Algebra
+
+The *Fermionic-ghosts* or b--c system super Lie conformal algebra
+with `2n` generators is the H-graded super Lie conformal algebra
+generated by odd vectors `b_i, c_i, i = 1,\ldots,n` and a central
+element `K`, with non-vanishing `\lambda`-brackets:
+
+.. MATH::
+
+    [{b_i}_\lambda c_j] = \delta_{ij} K.
+
+The generators `b_i` have degree `1` while the generators `c_i`
+have degree `0`.
+
+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 FermionicGhostsLieConformalAlgebra(GradedLieConformalAlgebra):
+    r"""
+    The Fermionic ghosts or `bc`-system super Lie conformal algebra.
+
+    INPUT:
+
+    - ``R`` -- a commutative ring; the base ring of this Lie
+      conformal algebra
+    - ``ngens`` -- an even positive Integer (default: ``2``); the
+      number of non-central generators of this Lie conformal
+      algebra
+    - ``names`` -- tuple of strings; alternative names for the
+      generators
+    - ``index_set`` -- an enumerated set; alternative indexing
+      set for the generators
+
+    OUTPUT:
+
+    The Fermionic Ghosts super Lie conformal algebra with generators
+    `b_i,c_i, i=1,\ldots,n` and `K` where `2n` is ``ngens``.
+
+    EXAMPLES::
+
+        sage: R = lie_conformal_algebras.FermionicGhosts(QQ); R
+        The Fermionic ghosts Lie conformal algebra with generators (b, c, K) over Rational Field
+        sage: R.inject_variables()
+        Defining b, c, K
+        sage: b.bracket(c) == c.bracket(b)
+        True
+        sage: b.degree()
+        1
+        sage: c.degree()
+        0
+        sage: R.category()
+        Category of H-graded super finitely generated Lie conformal algebras with basis over Rational Field
+
+        sage: R = lie_conformal_algebras.FermionicGhosts(QQbar, ngens=4, names = 'abcd');R
+        The Fermionic ghosts Lie conformal algebra with generators (a, b, c, d, K) over Algebraic Field
+        sage: R.structure_coefficients()
+        Finite family {('a', 'c'): ((0, K),),  ('b', 'd'): ((0, K),),  ('c', 'a'): ((0, K),),  ('d', 'b'): ((0, K),)}
+    """
+    def __init__(self, R, ngens=2, names=None, index_set=None):
+        """
+        Initialize ``self``.
+
+        TESTS::
+
+            sage: V = lie_conformal_algebras.BosonicGhosts(QQ)
+            sage: TestSuite(V).run()
+        """
+        try:
+            assert (ngens > 0 and not ngens % 2)
+        except AssertionError:
+            raise ValueError("ngens should be an even positive integer, " +
+                             "got {}".format(ngens))
+        latex_names = None
+        half = ngens // 2
+        if (names is None) and (index_set is None):
+            from sage.misc.defaults import variable_names as varnames
+            from sage.misc.defaults import latex_variable_names as laxnames
+            names = varnames(half, 'b') + varnames(half, 'c')
+            latex_names = tuple(laxnames(half, 'b') +
+                                laxnames(half, 'c')) + ('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)
+        from sage.matrix.special import identity_matrix
+        A = identity_matrix(R, half)
+        from sage.matrix.special import block_matrix
+        gram_matrix = block_matrix([[R.zero(), A], [A, R.zero()]])
+        ghostsdict = {(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}
+        weights = (1,) * half + (0,) * half
+        parity = (1,) * ngens
+        super().__init__(R,
+                         ghostsdict, names=names,
+                         latex_names=latex_names,
+                         index_set=index_set,
+                         weights=weights,
+                         parity=parity,
+                         central_elements=('K',))
+
+    def _repr_(self) -> str:
+        """
+        String representation.
+
+        EXAMPLES::
+
+            sage: lie_conformal_algebras.FermionicGhosts(QQ)
+            The Fermionic ghosts Lie conformal algebra with generators (b, c, K) over Rational Field
+        """
+        return "The Fermionic ghosts Lie conformal algebra with generators {} "\
+            "over {}".format(self.gens(), self.base_ring())