passagemath-combinat 10.6.42__cp314-cp314-musllinux_1_2_x86_64.whl

sage/algebras/lie_conformal_algebras/lie_conformal_algebra_element.py

@@ -0,0 +1,236 @@
+# sage_setup: distribution = sagemath-combinat
+# sage.doctest: needs sage.combinat sage.modules
+"""
+Lie Conformal Algebra Element
+
+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.
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+from sage.arith.misc import factorial
+from sage.misc.misc_c import prod
+from sage.misc.repr import repr_lincomb
+from sage.misc.latex import latex
+from sage.modules.with_basis.indexed_element import IndexedFreeModuleElement
+
+
+class LCAWithGeneratorsElement(IndexedFreeModuleElement):
+    """
+    The element class of a Lie conformal algebra with a
+    preferred set of generators.
+    """
+    def T(self, n=1):
+        r"""
+        The `n`-th derivative of this element.
+
+        INPUT:
+
+        - ``n`` -- nonnegative integer (default: `1`); how many
+          times to apply `T` to this element
+
+        We use the *divided powers* notation
+        `T^{(j)} = \frac{T^j}{j!}`.
+
+        EXAMPLES::
+
+            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
+
+            sage: R = lie_conformal_algebras.NeveuSchwarz(QQbar); R.inject_variables()
+            Defining L, G, C
+            sage: (L + 2*G.T() + 4*C).T(2)
+            2*T^(2)L + 12*T^(3)G
+        """
+        from sage.rings.integer_ring import ZZ
+        if n not in ZZ or n < 0:
+            raise ValueError("n must be a nonnegative Integer")
+        if n == 0 or self.is_zero():
+            return self
+        # it's faster to sum than to use recursion
+        if self.is_monomial():
+            p = self.parent()
+            a, m = self.index()
+            coef = self._monomial_coefficients[(a, m)]
+            if (a, m + n) in p._indices:
+                return coef * prod(range(m + 1, m + n + 1))\
+                    * p.monomial((a, m + n))
+            else:
+                return p.zero()
+        return sum(mon.T(n) for mon in self.terms())
+
+    def is_monomial(self):
+        """
+        Whether this element is a monomial.
+
+        EXAMPLES::
+
+            sage: Vir = lie_conformal_algebras.Virasoro(QQ); L = Vir.0
+            sage: (L + L.T()).is_monomial()
+            False
+            sage: L.T().is_monomial()
+            True
+        """
+        return len(self._monomial_coefficients) == 1 or self.is_zero()
+
+
+class LCAStructureCoefficientsElement(LCAWithGeneratorsElement):
+    """
+    An element of a Lie conformal algebra given by structure
+    coefficients.
+    """
+    def _bracket_(self, right):
+        """
+        The lambda bracket of these two elements.
+
+        The result is a dictionary with nonnegative integer keys.
+        The value corresponding to the entry `j` is ``self_{(j)}right``.
+
+        EXAMPLES::
+
+            sage: Vir = lie_conformal_algebras.Virasoro(QQ); L = Vir.0
+            sage: L.bracket(L)
+            {0: TL, 1: 2*L, 3: 1/2*C}
+            sage: L.T().bracket(L)
+            {1: -TL, 2: -4*L, 4: -2*C}
+
+            sage: R = lie_conformal_algebras.Affine(QQbar, 'A1', names=('e','h','f')); R
+            The affine Lie conformal algebra of type ['A', 1] over Algebraic Field
+            sage: R.inject_variables()
+            Defining e, h, f, K
+            sage: e.bracket(f)
+            {0: h, 1: K}
+            sage: h.bracket(h.T())
+            {2: 4*K}
+        """
+        p = self.parent()
+        if self.is_monomial() and right.is_monomial():
+            if self.is_zero() or right.is_zero():
+                return {}
+            s_coeff = p._s_coeff
+            a, k = self.index()
+            coefa = self.monomial_coefficients()[(a, k)]
+            b, m = right.index()
+            coefb = right.monomial_coefficients()[(b, m)]
+            try:
+                mbr = dict(s_coeff[(a, b)])
+            except KeyError:
+                return {}
+            pole = max(mbr.keys())
+            ret = {l: coefa * coefb * (-1)**k / factorial(k) *
+                   sum(factorial(l) / factorial(m + k + j - l)
+                       / factorial(l - k - j) / factorial(j)
+                       * mbr[j].T(m + k + j - l)
+                       for j in mbr if l - m - k <= j <= l - k)
+                   for l in range(m + k + pole + 1)}
+            return {k: v for k, v in ret.items() if v}
+
+        diclist = [i._bracket_(j) for i in self.terms()
+                   for j in right.terms()]
+        ret = {}
+        pz = p.zero()
+        for d in diclist:
+            for k in d:
+                ret[k] = ret.get(k, pz) + d[k]
+        return {k: v for k, v in ret.items() if v}
+
+    def _repr_(self):
+        r"""
+        A visual representation of this element.
+
+        For a free generator `L`, the element `\frac{T^{j}}{j!}L` is
+        denoted by ``T^(j)L``.
+
+        EXAMPLES::
+
+            sage: V = lie_conformal_algebras.Virasoro(QQ); V.inject_variables()
+            Defining L, C
+            sage: v = L.T(5).nproduct(L,6); v
+            -1440*L
+            sage: L.T(2) + L + C
+            2*T^(2)L + L + C
+            sage: L.T(4)
+            24*T^(4)L
+
+            sage: R = lie_conformal_algebras.Affine(QQ, 'B3')
+            sage: R.2.T()+3*R.3
+            TB[alpha[1]] + 3*B[alpha[2] + alpha[3]]
+        """
+        if self.is_zero():
+            return "0"
+        p = self.parent()
+        if p._names:
+            terms = [("T^({}){}".format(k1, p._names[p._index_to_pos[k0]]), v) if k1 > 1
+                     else ("T{}".format(p._names[p._index_to_pos[k0]]), v) if k1 == 1
+                     else ("{}".format(p._names[p._index_to_pos[k0]]), v)
+                     for (k0, k1), v in self.monomial_coefficients().items()]
+        else:
+            terms = [("T^({}){}".format(k1, p._repr_generator(k0)), v) if k1 > 1
+                     else ("T{}".format(p._repr_generator(k0)), v) if k1 == 1
+                     else ("{}".format(p._repr_generator(k0)), v)
+                     for (k0, k1), v in self.monomial_coefficients().items()]
+
+        return repr_lincomb(terms, strip_one=True)
+
+    def _latex_(self):
+        r"""
+        A visual representation of this element.
+
+        For a free generator `L`, the element `\frac{T^{j}}{j!}L` is
+        denoted by ``T^(j)L``.
+
+        EXAMPLES::
+
+            sage: V = lie_conformal_algebras.Virasoro(QQ); V.inject_variables()
+            Defining L, C
+            sage: latex(L.T(2))
+            2 T^{(2)}L
+
+            sage: R = lie_conformal_algebras.Affine(QQbar, 'A1', names=('e','h','f')); R.inject_variables()
+            Defining e, h, f, K
+            sage: latex(e.bracket(f))
+            \left\{0 : h, 1 : K\right\}
+            sage: latex(e.T(3))
+            6 T^{(3)}e
+
+            sage: R = lie_conformal_algebras.Affine(QQbar, 'A1')
+            sage: latex(R.0.bracket(R.2))
+            \left\{0 : \alpha^\vee_{1}, 1 : \text{\texttt{K}}\right\}
+
+            sage: R = lie_conformal_algebras.Affine(QQ, 'A1'); latex(R.0.T(3))
+            6 T^{(3)}\alpha_{1}
+        """
+        if self.is_zero():
+            return "0"
+        p = self.parent()
+        try:
+            names = p.latex_variable_names()
+        except ValueError:
+            names = None
+        if names:
+            terms = [("T^{{({})}}{}".format(k1, names[p._index_to_pos[k0]]), v) if k1 > 1
+                     else ("T{}".format(names[p._index_to_pos[k0]]), v) if k1 == 1
+                     else ("{}".format(names[p._index_to_pos[k0]]), v)
+                     for (k0, k1), v in self.monomial_coefficients().items()]
+        else:
+            terms = [("T^{{({})}}{}".format(k1, latex(k0)), v) if k1 > 1
+                     else ("T{}".format(latex(k0)), v) if k1 == 1
+                     else ("{}".format(latex(k0)), v)
+                     for (k0, k1), v in self.monomial_coefficients().items()]
+
+        return repr_lincomb(terms, is_latex=True, strip_one=True)

sage/algebras/lie_conformal_algebras/lie_conformal_algebra_with_basis.py

@@ -0,0 +1,78 @@
+# sage_setup: distribution = sagemath-combinat
+# sage.doctest: needs sage.combinat sage.modules
+"""
+Lie Conformal Algebras With Basis
+
+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.categories.lie_conformal_algebras import LieConformalAlgebras
+from sage.combinat.free_module import CombinatorialFreeModule
+
+
+class LieConformalAlgebraWithBasis(CombinatorialFreeModule):
+    """
+    Abstract base class for a Lie conformal algebra with a
+    preferred basis.
+
+    This class provides no functionality, it simply passes the
+    arguments to :class:`CombinatorialFreeModule`.
+
+    EXAMPLES::
+
+        sage: R = lie_conformal_algebras.Virasoro(QQbar);R
+        The Virasoro Lie conformal algebra over Algebraic Field
+
+    TESTS::
+
+        sage: R = lie_conformal_algebras.Virasoro(QQ)
+        sage: R.0
+        L
+        sage: R._repr_generator(R.0)
+        'L'
+        sage: R = lie_conformal_algebras.Affine(QQ, 'A1')
+        sage: R.0
+        B[alpha[1]]
+        sage: R._repr_generator(R.0)
+        'B[alpha[1]]'
+        sage: R = lie_conformal_algebras.Affine(QQ, 'A1', names = ('e', 'h','f'))
+        sage: R.0
+        e
+        sage: R._repr_generator(R.0)
+        'e'
+    """
+    def __init__(self, R, basis_keys=None, element_class=None, category=None,
+                 prefix=None, **kwds):
+        """
+        Initialize ``self``.
+
+        TESTS::
+
+            sage: V = lie_conformal_algebras.Affine(QQ,'A1')
+            sage: TestSuite(V).run()
+        """
+        if prefix is None:
+            prefix = ''
+            kwds['bracket'] = ''
+            kwds['string_quotes'] = False
+
+        default_category = LieConformalAlgebras(R).WithBasis()
+        try:
+            category = default_category.or_subcategory(category)
+        except ValueError:
+            category = default_category.Super().or_subcategory(category)
+
+        super().__init__(R, basis_keys=basis_keys, element_class=element_class,
+                         category=category, prefix=prefix, names=None, **kwds)

sage/algebras/lie_conformal_algebras/lie_conformal_algebra_with_structure_coefs.py

@@ -0,0 +1,328 @@
+# sage_setup: distribution = sagemath-combinat
+# sage.doctest: needs sage.combinat sage.modules
+"""
+Lie Conformal Algebras With Structure Coefficients
+
+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.
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+from sage.arith.misc import binomial
+from sage.sets.family import Family
+from .lie_conformal_algebra_element import LCAStructureCoefficientsElement
+from sage.categories.lie_conformal_algebras import LieConformalAlgebras
+from .finitely_freely_generated_lca import FinitelyFreelyGeneratedLCA
+from sage.sets.disjoint_union_enumerated_sets import DisjointUnionEnumeratedSets
+from sage.structure.indexed_generators import (IndexedGenerators,
+                                               standardize_names_index_set)
+
+
+class LieConformalAlgebraWithStructureCoefficients(
+                                        FinitelyFreelyGeneratedLCA):
+    r"""
+    A Lie conformal algebra with a set of specified structure
+    coefficients.
+
+    INPUT:
+
+    - ``R`` -- a ring (default: ``None``); the base ring of this Lie
+      conformal algebra. Behaviour is undefined if it is not a field
+      of characteristic zero.
+
+    - ``s_coeff`` -- dictionary (default: ``None``);
+      a dictionary containing the `\lambda` brackets of the
+      generators of this Lie conformal algebra. The family encodes a
+      dictionary whose keys
+      are pairs of either names or indices of the generators
+      and the values are themselves dictionaries. For a pair of
+      generators `a` and `b`, the value of ``s_coeff[('a','b')]`` is
+      a dictionary whose keys are positive integer numbers and the
+      corresponding value for the key `j` is a dictionary itself
+      representing the `j`-th product `a_{(j)}b`.
+      Thus, for a positive integer number `j`, the value of
+      ``s_coeff[('a','b')][j]`` is a dictionary whose entries are
+      pairs ``('c',n)`` where ``'c'`` is the name of a generator
+      and `n` is a positive number. The value for this key is the
+      coefficient of `\frac{T^{n}}{n!} c` in `a_{(j)}b`. For example
+      the ``s_coeff`` for the *Virasoro* Lie conformal algebra is::
+
+            {('L','L'):{0:{('L',1):1}, 1:{('L',0):2}, 3:{('C',0):1/2}}}
+
+
+      Do not include central elements in this dictionary. Also, if
+      the key ``('a','b')`` is present, there is no need to include
+      ``('b','a')`` as it is defined by skew-symmetry.
+      Any missing pair (besides the ones
+      defined by skew-symmetry) is assumed to have vanishing
+      `\lambda`-bracket.
+
+    - ``names`` -- tuple of strings (default: ``None``); the list of
+      names for generators of this Lie conformal algebra. Do not
+      include central elements in this list.
+
+    - ``central_elements`` -- tuple of strings (default: ``None``);
+      a list of names for central elements of this Lie conformal algebra
+
+    - ``index_set`` -- enumerated set (default: ``None``);
+      an indexing set for the generators of this Lie
+      conformal algebra. Do not include central elements in this
+      list.
+
+    - ``parity`` -- tuple of `0` or `1` (default: tuple of `0`);
+      a tuple specifying the parity of each non-central generator
+
+    EXAMPLES:
+
+    - We construct the `\beta-\gamma` system by directly giving the
+      `\lambda`-brackets of the generators::
+
+        sage: betagamma_dict = {('b','a'):{0:{('K',0):1}}}
+        sage: V = LieConformalAlgebra(QQ, betagamma_dict, names=('a','b'),
+        ....:         weights=(1,0), central_elements=('K',))
+        sage: V.category()
+        Category of H-graded finitely generated Lie conformal algebras
+        with basis over Rational Field
+        sage: V.inject_variables()
+        Defining a, b, K
+        sage: a.bracket(b)
+        {0: -K}
+
+    - We construct the centerless Virasoro Lie conformal algebra::
+
+        sage: virdict =  {('L','L'):{0:{('L',1):1}, 1:{('L',0): 2}}}
+        sage: R = LieConformalAlgebra(QQbar, virdict, names='L')
+        sage: R.inject_variables()
+        Defining L
+        sage: L.bracket(L)
+        {0: TL, 1: 2*L}
+
+    - The construction checks that skew-symmetry is violated::
+
+        sage: wrongdict =  {('L','L'):{0:{('L',1):2}, 1:{('L',0): 2}}}
+        sage: LieConformalAlgebra(QQbar, wrongdict, names='L')
+        Traceback (most recent call last):
+        ...
+        ValueError: two distinct values given for one and the same bracket. Skew-symmetry is not satisfied?
+    """
+    @staticmethod
+    def _standardize_s_coeff(s_coeff, index_set, ce, parity=None):
+        """
+        Convert an input dictionary to structure constants of this
+        Lie conformal algebra.
+
+        INPUT:
+
+        - ``s_coeff`` -- dictionary as in
+          :class:`~sage.algebras.lie_conformal_algebras.lie_conformal_algebra_with_structure_coefficients.LieConformalAlgebraWithStructureCoefficients`
+        - ``index_set`` -- a finite enumerated set indexing the
+          generators (not counting the central elements).
+        - ``ce`` -- tuple of strings; a list of names for the central
+          generators of this Lie conformal algebra
+        - ``parity`` -- tuple of `0` or `1` (default: tuple of `0`);
+          this tuple specifies the parity of each non-central generator
+
+        OUTPUT:
+
+        A finite Family representing ``s_coeff`` in the input.
+        It contains superfluous information that can be obtained by
+        skew-symmetry but that improves speed in computing OPE for
+        vertex algebras.
+
+        EXAMPLES::
+
+            sage: virdict =  {('L','L'):{0:{('L',1):1}, 1:{('L',0): 2},3:{('C', 0):1/2}}}
+            sage: Vir = lie_conformal_algebras.Virasoro(QQ)
+            sage: Vir._standardize_s_coeff(virdict, Family(('L',)), ('C',))
+            Finite family {('L', 'L'): ((0, ((('L', 1), 1),)),               (1, ((('L', 0), 2),)),               (3, ((('C', 0), 1/2),)))}
+        """
+        if parity is None:
+            parity = (0,) * index_set.cardinality()
+        index_to_parity = dict(zip(index_set, parity))
+        sc = {}
+        # mypair has a pair of generators
+        for mypair, v in s_coeff.items():
+            # e.g.  v = { 0: { (L,2):3, (G,3):1}, 1:{(L,1),2} }
+            key = tuple(mypair)
+            vals = {}
+            for l in v:
+                lth_product = {k: y for k, y in v[l].items() if y}
+                if lth_product:
+                    vals[l] = lth_product
+
+            myvals = tuple((k, tuple(v.items())) for k, v in vals.items() if v)
+
+            if key in sc and sorted(sc[key]) != sorted(myvals):
+                raise ValueError("two distinct values given for one "
+                                 "and the same bracket, skew-symmetry"
+                                 "is not satisfied?")
+            if myvals:
+                sc[key] = myvals
+
+            # We now add the skew-symmetric part to optimize
+            # brackets computations later
+            key = (mypair[1], mypair[0])
+            if index_to_parity[mypair[0]]*index_to_parity[mypair[1]]:
+                parsgn = -1
+            else:
+                parsgn = 1
+            maxpole = max(v)
+            vals = {}
+            for k in range(maxpole+1):
+                kth_product = {}
+                for j in range(maxpole+1-k):
+                    if k+j in v.keys():
+                        for i in v[k+j]:
+                            if (i[0] not in ce) or (
+                                    i[0] in ce and i[1] + j == 0):
+                                kth_product[(i[0], i[1] + j)] = \
+                                    kth_product.get((i[0], i[1] + j), 0)
+                                kth_product[(i[0], i[1] + j)] += parsgn *\
+                                    v[k+j][i]*(-1)**(k+j+1)*binomial(i[1]+j, j)
+                kth_product = {k: v for k, v in kth_product.items() if v}
+                if kth_product:
+                    vals[k] = kth_product
+
+            myvals = tuple((k, tuple(v.items())) for k, v in vals.items() if v)
+
+            if key in sc and sorted(sc[key]) != sorted(myvals):
+                raise ValueError("two distinct values given for one "
+                                 "and the same bracket. "
+                                 "Skew-symmetry is not satisfied?")
+            if myvals:
+                sc[key] = myvals
+        return Family(sc)
+
+    def __init__(self, R, s_coeff, index_set=None, central_elements=None,
+                 category=None, element_class=None, prefix=None, names=None,
+                 latex_names=None, parity=None, **kwds):
+        """
+        Initialize ``self``.
+
+        TESTS::
+
+            sage: V = lie_conformal_algebras.NeveuSchwarz(QQ)
+            sage: TestSuite(V).run()
+        """
+        names, index_set = standardize_names_index_set(names, index_set)
+        if central_elements is None:
+            central_elements = ()
+
+        if names is not None and names != tuple(index_set):
+            names2 = names + tuple(central_elements)
+            index_set2 = DisjointUnionEnumeratedSets((index_set,
+                Family(tuple(central_elements))))
+            d = {x: index_set2[i] for i, x in enumerate(names2)}
+            try:
+                # If we are given a dictionary with names as keys,
+                # convert to index_set as keys
+                s_coeff = {(d[k[0]], d[k[1]]):
+                           {a: {(d[x[1]], x[2]): sck[a][x] for x in sck[a]}
+                            for a in s_coeff[k]}
+                           for k, sck in s_coeff.items()}
+
+            except KeyError:
+                # We assume the dictionary was given with keys in the
+                # index_set
+                pass
+
+        issuper = kwds.pop('super', False)
+        if parity is None:
+            parity = (0,) * index_set.cardinality()
+        else:
+            issuper = True
+
+        try:
+            assert len(parity) == index_set.cardinality()
+        except AssertionError:
+            raise ValueError("parity should have the same length as the "
+                             f"number of generators, got {parity}")
+
+        s_coeff = LieConformalAlgebraWithStructureCoefficients\
+            ._standardize_s_coeff(s_coeff, index_set, central_elements,
+                                  parity)
+
+        if names is not None and central_elements is not None:
+            names += tuple(central_elements)
+
+        self._index_to_pos = {k: i for i, k in enumerate(index_set)}
+        # Add central parameters to index_to_pos so that we can
+        # represent names
+        if central_elements is not None:
+            for i, ce in enumerate(central_elements):
+                self._index_to_pos[ce] = len(index_set) + i
+
+        default_category = LieConformalAlgebras(R).WithBasis().FinitelyGenerated()
+        if issuper:
+            category = default_category.Super().or_subcategory(category)
+        else:
+            category = default_category.or_subcategory(category)
+
+        if element_class is None:
+            element_class = LCAStructureCoefficientsElement
+
+        FinitelyFreelyGeneratedLCA.__init__(
+            self, R, index_set=index_set, central_elements=central_elements,
+            category=category, element_class=element_class,
+            prefix=prefix, names=names, latex_names=latex_names, **kwds)
+
+        s_coeff = dict(s_coeff)
+        self._s_coeff = Family({k:
+                                tuple((j, sum(c * self.monomial(i)
+                                              for i, c in v)) for j, v in sck)
+                                for k, sck in s_coeff.items()})
+        self._parity = dict(zip(self.gens(),
+                                parity + (0,) * len(central_elements)))
+
+    def structure_coefficients(self):
+        """
+        The structure coefficients of this Lie conformal algebra.
+
+        EXAMPLES::
+
+            sage: Vir = lie_conformal_algebras.Virasoro(AA)
+            sage: Vir.structure_coefficients()
+            Finite family {('L', 'L'): ((0, TL), (1, 2*L), (3, 1/2*C))}
+
+            sage: lie_conformal_algebras.NeveuSchwarz(QQ).structure_coefficients()
+            Finite family {('G', 'G'): ((0, 2*L), (2, 2/3*C)),
+            ('G', 'L'): ((0, 1/2*TG), (1, 3/2*G)),
+            ('L', 'G'): ((0, TG), (1, 3/2*G)),
+            ('L', 'L'): ((0, TL), (1, 2*L), (3, 1/2*C))}
+        """
+        return self._s_coeff
+
+    def _repr_generator(self, x) -> str:
+        """
+        String representation of the generator ``x``.
+
+        INPUT:
+
+        - ``x`` -- an index parametrizing a generator or a generator of
+          this Lie conformal algebra
+
+        EXAMPLES::
+
+            sage: Vir = lie_conformal_algebras.Virasoro(QQbar)
+            sage: Vir._repr_generator(Vir.0)
+            'L'
+            sage: R = lie_conformal_algebras.Affine(QQ, 'A1')
+            sage: R._repr_generator(R.0)
+            'B[alpha[1]]'
+            sage: R = lie_conformal_algebras.Affine(QQ, 'A1', names=('e','h','f'))
+            sage: R._repr_generator(R.0)
+            'e'
+        """
+        if x in self:
+            return repr(x)
+        return IndexedGenerators._repr_generator(self, x)