passagemath-combinat 10.6.42__cp314-cp314-musllinux_1_2_x86_64.whl

sage/algebras/lie_conformal_algebras/n2_lie_conformal_algebra.py

@@ -0,0 +1,117 @@
+# sage_setup: distribution = sagemath-combinat
+# sage.doctest: needs sage.combinat sage.modules sage.rings.number_field
+r"""
+N=2 Super Lie Conformal Algebra
+
+The `N=2` super Lie conformal algebra is an extension of the Virasoro
+Lie conformal algebra (with generators `L,C`) by an even generator `J`
+which is primary of conformal weight `1` and two odd generators
+`G_1,G_2` which are primary of conformal weight `3/2`. The remaining
+`\lambda`-brackets are given by:
+
+.. MATH::
+
+    [J_\lambda J] &= \frac{\lambda}{3} C, \\
+    [J_\lambda G_1] &= G_1, \\
+    [J_\lambda G_2] &= -G_2, \\
+    [{G_1}_\lambda G_1] &= [{G_2}_\lambda G_2 ] = 0, \\
+    [{G_1}_\lambda G_2] &= L + \frac{1}{2} TJ + \lambda J + \frac{\lambda^2}{6}C.
+
+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.
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+from .graded_lie_conformal_algebra import GradedLieConformalAlgebra
+
+
+class N2LieConformalAlgebra(GradedLieConformalAlgebra):
+    """
+    The N=2 super Lie conformal algebra.
+
+    INPUT:
+
+    - ``R`` -- a commutative ring; the base ring of this super
+      Lie conformal algebra
+
+    EXAMPLES::
+
+        sage: x = polygen(ZZ, 'x')
+        sage: F.<x> = NumberField(x^2 - 2)
+        sage: R = lie_conformal_algebras.N2(F); R
+        The N=2 super Lie conformal algebra over Number Field in x with defining polynomial x^2 - 2
+        sage: R.inject_variables()
+        Defining L, J, G1, G2, C
+        sage: G1.bracket(G2)
+        {0: L + 1/2*TJ, 1: J, 2: 1/3*C}
+        sage: G2.bracket(G1)
+        {0: L - 1/2*TJ, 1: -J, 2: 1/3*C}
+        sage: G1.degree()
+        3/2
+        sage: J.degree()
+        1
+
+    The topological twist is a Virasoro vector with central
+    charge 0::
+
+        sage: L2 = L - 1/2*J.T()
+        sage: L2.bracket(L2) == {0: L2.T(), 1: 2*L2}
+        True
+
+    The sum of the fermions is a generator of the Neveu-Schwarz
+    Lie conformal algebra::
+
+        sage: G = (G1 + G2)
+        sage: G.bracket(G)
+        {0: 2*L, 2: 2/3*C}
+    """
+    def __init__(self, R):
+        """
+        Initialize ``self``.
+
+        TESTS::
+
+            sage: V = lie_conformal_algebras.N2(QQ)
+            sage: TestSuite(V).run()
+        """
+        n2dict = {('L', 'L'): {0: {('L', 1): 1},
+                               1: {('L', 0): 2},
+                               3: {('C', 0): R(2).inverse_of_unit()}},
+                  ('L', 'G1'): {0: {('G1', 1): 1},
+                                1: {('G1', 0): 3 * R(2).inverse_of_unit()}},
+                  ('L', 'G2'): {0: {('G2', 1): 1},
+                                1: {('G2', 0): 3 * R(2).inverse_of_unit()}},
+                  ('G1', 'G2'): {0: {('L', 0): 1, ('J', 1): R(2).inverse_of_unit()},
+                                 1: {('J', 0): 1},
+                                 2: {('C', 0): R(3).inverse_of_unit()}},
+                  ('L', 'J'): {0: {('J', 1): 1}, 1: {('J', 0): 1}},
+                  ('J', 'J'): {1: {('C', 0): R(3).inverse_of_unit()}},
+                  ('J', 'G1'): {0: {('G1', 0): 1}},
+                  ('J', 'G2'): {0: {('G2', 0): -1}}}
+        from sage.rings.rational_field import QQ
+        weights = (2, 1, QQ(3) / 2, QQ(3) / 2)
+        parity = (0, 0, 1, 1)
+        GradedLieConformalAlgebra.__init__(self, R, n2dict,
+                                           names=('L', 'J', 'G1', 'G2'),
+                                           central_elements=('C',),
+                                           weights=weights, parity=parity)
+
+    def _repr_(self):
+        """
+        The name of this Lie conformal algebra.
+
+        EXAMPLES::
+
+            sage: R = lie_conformal_algebras.N2(QQbar); R
+            The N=2 super Lie conformal algebra over Algebraic Field
+        """
+        return f"The N=2 super Lie conformal algebra over {self.base_ring()}"

sage/algebras/lie_conformal_algebras/neveu_schwarz_lie_conformal_algebra.py

@@ -0,0 +1,86 @@
+# sage_setup: distribution = sagemath-combinat
+# sage.doctest: needs sage.combinat sage.modules
+r"""
+Neveu-Schwarz Super Lie Conformal Algebra
+
+The `N=1` or *Neveu-Schwarz* super Lie conformal algebra is a super
+extension of the Virasoro Lie conformal algebra with generators `L`
+and `C` by an odd primary generator `G` of conformal weight `3/2`. The
+remaining `\lambda`-bracket is given by:
+
+.. MATH::
+
+    [G_\lambda G] = 2L + \frac{\lambda^2}{3} C.
+
+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 NeveuSchwarzLieConformalAlgebra(GradedLieConformalAlgebra):
+    """
+    The Neveu-Schwarz super Lie conformal algebra.
+
+    INPUT:
+
+    - ``R`` -- a commutative Ring; the base ring of this Lie
+      conformal algebra
+
+    EXAMPLES::
+
+        sage: R = lie_conformal_algebras.NeveuSchwarz(AA); R
+        The Neveu-Schwarz super Lie conformal algebra over Algebraic Real Field
+        sage: R.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))}
+        sage: R.inject_variables()
+        Defining L, G, C
+        sage: G.nproduct(G,0)
+        2*L
+        sage: G.degree()
+        3/2
+    """
+    def __init__(self, R):
+        """
+        Initialize ``self``.
+
+        TESTS::
+
+            sage: V = lie_conformal_algebras.NeveuSchwarz(QQ)
+            sage: TestSuite(V).run()
+        """
+        nsdict = {('L', 'L'): {0: {('L', 1): 1},
+                               1: {('L', 0): 2},
+                               3: {('C', 0): R(2).inverse_of_unit()}},
+                  ('L', 'G'): {0: {('G', 1): 1},
+                               1: {('G', 0): R(3) * R(2).inverse_of_unit()}},
+                  ('G', 'G'): {0: {('L', 0): 2},
+                               2: {('C', 0): R(2) * R(3).inverse_of_unit()}}}
+        from sage.rings.rational_field import QQ
+        weights = (2, QQ((3, 2)))
+        parity = (0, 1)
+        GradedLieConformalAlgebra.__init__(self, R, nsdict, names=('L', 'G'),
+                    central_elements=('C',), weights=weights, parity=parity)
+
+    def _repr_(self):
+        """
+        The name of this Lie Conformal algebra.
+
+        EXAMPLES::
+
+            sage: R = lie_conformal_algebras.NeveuSchwarz(GF(5)); R
+            The Neveu-Schwarz super Lie conformal algebra over Finite Field of size 5
+        """
+        return "The Neveu-Schwarz super Lie conformal algebra over {}".\
+                format(self.base_ring())

sage/algebras/lie_conformal_algebras/virasoro_lie_conformal_algebra.py

@@ -0,0 +1,82 @@
+# sage_setup: distribution = sagemath-combinat
+# sage.doctest: needs sage.combinat sage.modules
+r"""
+Virasoro Lie Conformal Algebra
+
+The Virasoro Lie conformal algebra is generated by `L` and a central
+element `C`. The `\lambda`-brackets are given by:
+
+.. MATH::
+
+    [L_\lambda L] = T L + 2 \lambda L + \frac{\lambda^3}{12} C.
+
+It is an H-graded Lie conformal algebra with `L` of degree `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 .graded_lie_conformal_algebra import GradedLieConformalAlgebra
+
+
+class VirasoroLieConformalAlgebra(GradedLieConformalAlgebra):
+    """
+    The Virasoro Lie Conformal algebra over `R`.
+
+    INPUT:
+
+    - ``R`` -- a commutative ring; behaviour is undefined if `R` is
+      not a Field of characteristic zero
+
+    EXAMPLES::
+
+        sage: Vir = lie_conformal_algebras.Virasoro(QQ)
+        sage: Vir.category()
+        Category of H-graded finitely generated Lie conformal algebras with basis over Rational Field
+        sage: Vir.inject_variables()
+        Defining L, C
+        sage: L.bracket(L)
+        {0: TL, 1: 2*L, 3: 1/2*C}
+
+    TESTS::
+
+        sage: Vir.gens()
+        (L, C)
+    """
+    def __init__(self, R):
+        """
+        Initialize ``self``.
+
+        TESTS::
+
+            sage: V = lie_conformal_algebras.Virasoro(QQ)
+            sage: TestSuite(V).run()
+        """
+        virdict = {('L', 'L'): {0: {('L', 1): 1},
+                                1: {('L', 0): 2},
+                                3: {('C', 0): R(2).inverse_of_unit()}}}
+        GradedLieConformalAlgebra.__init__(self, R, virdict,
+            names=('L',), central_elements=('C',), weights=(2,))
+
+    def _repr_(self):
+        """
+        The name of this Lie conformal algebra.
+
+        EXAMPLES::
+
+            sage: lie_conformal_algebras.Virasoro(QQbar)
+            The Virasoro Lie conformal algebra over Algebraic Field
+        """
+        return "The Virasoro Lie conformal algebra over {}".format(
+                                                            self.base_ring())

sage/algebras/lie_conformal_algebras/weyl_lie_conformal_algebra.py

@@ -0,0 +1,205 @@
+# sage_setup: distribution = sagemath-combinat
+# sage.doctest: needs sage.combinat sage.modules
+r"""
+Weyl Lie Conformal Algebra
+
+Given a commutative ring `R`, a free `R`-module `M` and a
+non-degenerate, skew-symmetric, bilinear pairing
+`\langle \cdot,\cdot\rangle: M \otimes_R M \rightarrow R`. The *Weyl*
+Lie conformal algebra associated to this datum is the free
+`R[T]`-module generated by `M` plus a central vector `K`. The
+non-vanishing `\lambda`-brackets are given by:
+
+.. MATH::
+
+    [v_\lambda w] = \langle v, w\rangle K.
+
+This is not an H-graded Lie conformal algebra. The choice of a
+Lagrangian decomposition `M = L \oplus L^*` determines an H-graded
+structure. For this H-graded Lie conformal algebra see the
+:mod:`Bosonic Ghosts Lie conformal algebra<sage.algebras.\
+lie_conformal_algebras.bosonic_ghosts_lie_conformal_algebra>`
+
+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 .lie_conformal_algebra_with_structure_coefs import \
+    LieConformalAlgebraWithStructureCoefficients
+from sage.matrix.special import identity_matrix
+from sage.structure.indexed_generators import standardize_names_index_set
+
+
+class WeylLieConformalAlgebra(LieConformalAlgebraWithStructureCoefficients):
+    r"""
+    The Weyl 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
+    - ``gram_matrix`` -- a matrix (default: ``None``); a non-singular
+      skew-symmetric square matrix with coefficients in `R`
+    - ``names`` -- list or tuple of strings; alternative names
+      for the generators
+    - ``index_set`` -- an enumerated set; alternative indexing set
+      for the generators
+
+    OUTPUT:
+
+    The Weyl Lie conformal algebra with generators
+     `\alpha_i`, `i=1,...,ngens` and `\lambda`-brackets
+
+     .. MATH::
+
+        [{\alpha_i}_{\lambda} \alpha_j] = M_{ij} K,
+
+    where `M` is the ``gram_matrix`` above.
+
+    .. NOTE::
+
+        The returned Lie conformal algebra is not `H`-graded. For
+        a related `H`-graded Lie conformal algebra see
+        :class:`BosonicGhostsLieConformalAlgebra<sage.algebras.\
+        lie_conformal_algebras.bosonic_ghosts_lie_conformal_algebra\
+        .BosonicGhostsLieConformalAlgebra>`.
+
+    EXAMPLES::
+
+        sage: lie_conformal_algebras.Weyl(QQ)
+        The Weyl Lie conformal algebra with generators (alpha0, alpha1, K) over Rational Field
+        sage: R = lie_conformal_algebras.Weyl(QQbar, gram_matrix=Matrix(QQ,[[0,1],[-1,0]]), names = ('a','b'))
+        sage: R.inject_variables()
+        Defining a, b, K
+        sage: a.bracket(b)
+        {0: K}
+        sage: b.bracket(a)
+        {0: -K}
+
+        sage: R = lie_conformal_algebras.Weyl(QQbar, ngens=4)
+        sage: R.gram_matrix()
+        [ 0  0| 1  0]
+        [ 0  0| 0  1]
+        [-----+-----]
+        [-1  0| 0  0]
+        [ 0 -1| 0  0]
+        sage: R.inject_variables()
+        Defining alpha0, alpha1, alpha2, alpha3, K
+        sage: alpha0.bracket(alpha2)
+        {0: K}
+
+        sage: R = lie_conformal_algebras.Weyl(QQ); R.category()
+        Category of finitely generated Lie conformal algebras with basis over Rational Field
+        sage: R in LieConformalAlgebras(QQ).Graded()
+        False
+        sage: R.inject_variables()
+        Defining alpha0, alpha1, K
+        sage: alpha0.degree()
+        Traceback (most recent call last):
+        ...
+        AttributeError: 'WeylLieConformalAlgebra_with_category.element_class' object has no attribute 'degree'...
+
+    TESTS::
+
+        sage: lie_conformal_algebras.Weyl(ZZ, gram_matrix=identity_matrix(ZZ,3))
+        Traceback (most recent call last):
+        ...
+        ValueError: the Gram_matrix should be a non degenerate skew-symmetric 3 x 3 matrix, got [1 0 0]
+        [0 1 0]
+        [0 0 1]
+    """
+    def __init__(self, R, ngens=None, gram_matrix=None, names=None,
+                 index_set=None):
+        """
+        Initialize ``self``.
+
+        TESTS::
+
+            sage: V = lie_conformal_algebras.Weyl(QQ)
+            sage: TestSuite(V).run()
+        """
+        from sage.matrix.matrix_space import MatrixSpace
+        if ngens:
+            from sage.rings.integer_ring import ZZ
+            if not (ngens in ZZ and not ngens % 2):
+                raise ValueError("ngens needs to be an even positive Integer, "
+                                 f"got {ngens}")
+        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 skew-symmetric "
+                    "{0} x {0} matrix, got {1}".format(ngens, gram_matrix))
+            if (not gram_matrix.is_skew_symmetric() or
+                    gram_matrix.is_singular()):
+                raise ValueError("the Gram_matrix should be a non degenerate "
+                                 "skew-symmetric {0} x {0} matrix, got {1}"
+                                 .format(ngens, gram_matrix))
+        elif gram_matrix is None:
+            if ngens is None:
+                ngens = 2
+            A = identity_matrix(R, ngens // 2)
+            from sage.matrix.special import block_matrix
+            gram_matrix = block_matrix([[R.zero(), A], [-A, R.zero()]])
+
+        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)
+        weyldict = {(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}
+
+        super().__init__(R, weyldict, names=names,
+                         latex_names=latex_names,
+                         index_set=index_set,
+                         central_elements=('K',))
+        self._gram_matrix = gram_matrix
+
+    def _repr_(self):
+        """
+        The name of this Lie conformal algebra.
+
+        EXAMPLES::
+
+            sage: R = lie_conformal_algebras.Weyl(ZZ); R
+            The Weyl Lie conformal algebra with generators (alpha0, alpha1, K) over Integer Ring
+        """
+        return "The Weyl 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.Weyl(QQbar, ngens=4)
+            sage: R.gram_matrix()
+            [ 0  0| 1  0]
+            [ 0  0| 0  1]
+            [-----+-----]
+            [-1  0| 0  0]
+            [ 0 -1| 0  0]
+        """
+        return self._gram_matrix

sage/algebras/nil_coxeter_algebra.py

@@ -0,0 +1,191 @@
+# sage_setup: distribution = sagemath-combinat
+# sage.doctest: needs sage.combinat sage.modules
+"""
+Nil-Coxeter Algebra
+"""
+#*****************************************************************************
+#  Copyright (C) 2011 Chris Berg <cberg at fields.utoronto.ca>
+#                     Anne Schilling <anne at math.ucdavis.edu>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#                  http://www.gnu.org/licenses/
+#*****************************************************************************
+from sage.algebras.iwahori_hecke_algebra import IwahoriHeckeAlgebra
+from sage.combinat.sf.sf import SymmetricFunctions
+from sage.misc.misc_c import prod
+from sage.rings.rational_field import QQ
+from sage.combinat.partition import Partitions
+
+
+class NilCoxeterAlgebra(IwahoriHeckeAlgebra.T):
+    r"""
+    Construct the Nil-Coxeter algebra of given type.
+
+    This is the algebra
+    with generators `u_i` for every node `i` of the corresponding Dynkin
+    diagram. It has the usual braid relations (from the Weyl group) as well
+    as the quadratic relation `u_i^2 = 0`.
+
+    INPUT:
+
+    - ``W`` -- a Weyl group
+    - ``base_ring`` -- a ring (default: rational numbers)
+    - ``prefix`` -- a label for the generators (default: ``'u'``)
+
+    EXAMPLES::
+
+        sage: U = NilCoxeterAlgebra(WeylGroup(['A',3,1]))
+        sage: u0, u1, u2, u3 = U.algebra_generators()
+        sage: u1*u1
+        0
+        sage: u2*u1*u2 == u1*u2*u1
+        True
+        sage: U.an_element()
+        u[0,1,2,3] + 2*u[0] + 3*u[1] + 1
+    """
+
+    def __init__(self, W, base_ring=QQ, prefix='u'):
+        r"""
+        Initiate the affine nil-Coxeter algebra corresponding to the Weyl
+        group `W` over the base ring.
+
+        EXAMPLES::
+
+            sage: U = NilCoxeterAlgebra(WeylGroup(['A',3,1])); U
+            The Nil-Coxeter Algebra of Type A3~ over Rational Field
+            sage: TestSuite(U).run()
+
+            sage: U = NilCoxeterAlgebra(WeylGroup(['C',3]), ZZ); U
+            The Nil-Coxeter Algebra of Type C3 over Integer Ring
+            sage: TestSuite(U).run()
+        """
+
+        self._W = W
+        self._n = W.n
+        self._base_ring = base_ring
+        self._cartan_type = W.cartan_type()
+        H = IwahoriHeckeAlgebra(W, 0, 0, base_ring=base_ring)
+        super(IwahoriHeckeAlgebra.T, self).__init__(H, prefix=prefix)
+
+    def _repr_(self):
+        r"""
+        EXAMPLES::
+
+            sage: NilCoxeterAlgebra(WeylGroup(['A',3,1])) # indirect doctest
+            The Nil-Coxeter Algebra of Type A3~ over Rational Field
+        """
+        return "The Nil-Coxeter Algebra of Type %s over %s" % (self._cartan_type._repr_(compact=True), self.base_ring())
+
+    def homogeneous_generator_noncommutative_variables(self, r):
+        r"""
+        Give the `r`-th homogeneous function inside the Nil-Coxeter algebra.
+        In finite type `A` this is the sum of all decreasing elements of length `r`.
+        In affine type `A` this is the sum of all cyclically decreasing elements of length `r`.
+        This is only defined in finite type `A`, `B` and affine types `A^{(1)}`, `B^{(1)}`, `C^{(1)}`, `D^{(1)}`.
+
+        INPUT:
+
+        - ``r`` -- positive integer at most the rank of the Weyl group
+
+        EXAMPLES::
+
+            sage: U = NilCoxeterAlgebra(WeylGroup(['A',3,1]))
+            sage: U.homogeneous_generator_noncommutative_variables(2)
+            u[1,0] + u[2,0] + u[0,3] + u[3,2] + u[3,1] + u[2,1]
+
+            sage: U = NilCoxeterAlgebra(WeylGroup(['B',4]))
+            sage: U.homogeneous_generator_noncommutative_variables(2)
+            u[1,2] + u[2,1] + u[3,1] + u[4,1] + u[2,3] + u[3,2] + u[4,2] + u[3,4] + u[4,3]
+
+            sage: U = NilCoxeterAlgebra(WeylGroup(['C',3]))
+            sage: U.homogeneous_generator_noncommutative_variables(2)
+            Traceback (most recent call last):
+            ...
+            AssertionError: Analogue of symmetric functions in noncommutative variables is not defined in type ['C', 3]
+
+        TESTS::
+
+            sage: U = NilCoxeterAlgebra(WeylGroup(['B',3,1]))
+            sage: U.homogeneous_generator_noncommutative_variables(-1)
+            0
+            sage: U.homogeneous_generator_noncommutative_variables(0)
+            1
+        """
+        ct = self._cartan_type
+        msg = f"Analogue of symmetric functions in noncommutative variables is not defined in type {ct}"
+        assert (len(ct) == 2 and ct[0] in ['A', 'B']) or (len(ct) == 3 and ct[2] == 1), msg
+        if r >= self._n:
+            return self.zero()
+        return self.sum_of_monomials(w for w in self._W.pieri_factors() if w.length() == r)
+
+    def homogeneous_noncommutative_variables(self, la):
+        r"""
+        Give the homogeneous function indexed by `la`, viewed inside the Nil-Coxeter algebra.
+
+        This is only defined in finite type `A`, `B` and affine types `A^{(1)}`, `B^{(1)}`, `C^{(1)}`, `D^{(1)}`.
+
+        INPUT:
+
+        - ``la`` -- a partition with first part bounded by the rank of the Weyl group
+
+        EXAMPLES::
+
+            sage: U = NilCoxeterAlgebra(WeylGroup(['B',2,1]))
+            sage: U.homogeneous_noncommutative_variables([2,1])
+            u[1,2,0] + 2*u[2,1,0] + u[0,2,0] + u[0,2,1] + u[1,2,1] + u[2,1,2] + u[2,0,2] + u[1,0,2]
+
+        TESTS::
+
+            sage: U = NilCoxeterAlgebra(WeylGroup(['B',2,1]))
+            sage: U.homogeneous_noncommutative_variables([])
+            1
+        """
+        return prod(self.homogeneous_generator_noncommutative_variables(p) for p in la)
+
+    def k_schur_noncommutative_variables(self, la):
+        r"""
+        In type `A^{(1)}` this is the `k`-Schur function in noncommutative variables
+        defined by Thomas Lam [Lam2005]_.
+
+        This function is currently only defined in type `A^{(1)}`.
+
+        INPUT:
+
+        - ``la`` -- a partition with first part bounded by the rank of the Weyl group
+
+        EXAMPLES::
+
+            sage: A = NilCoxeterAlgebra(WeylGroup(['A',3,1]))
+            sage: A.k_schur_noncommutative_variables([2,2])                             # needs lrcalc_python
+            u[0,3,1,0] + u[3,1,2,0] + u[1,2,0,1] + u[3,2,0,3] + u[2,0,3,1] + u[2,3,1,2]
+
+        TESTS::
+
+            sage: A = NilCoxeterAlgebra(WeylGroup(['A',3,1]))
+            sage: A.k_schur_noncommutative_variables([])
+            1
+
+            sage: A.k_schur_noncommutative_variables([1,2])
+            Traceback (most recent call last):
+            ...
+            AssertionError: [1, 2] is not a partition.
+
+            sage: A.k_schur_noncommutative_variables([4,2])
+            Traceback (most recent call last):
+            ...
+            AssertionError: [4, 2] is not a 3-bounded partition.
+
+            sage: C = NilCoxeterAlgebra(WeylGroup(['C',3,1]))
+            sage: C.k_schur_noncommutative_variables([2,2])
+            Traceback (most recent call last):
+            ...
+            AssertionError: Weyl Group of type ['C', 3, 1] (as a matrix group acting on the root space) is not affine type A.
+        """
+        assert self._cartan_type[0] == 'A' and len(self._cartan_type) == 3 and self._cartan_type[2] == 1, "%s is not affine type A." % (self._W)
+        assert la in Partitions(), "%s is not a partition." % (la)
+        assert (len(la) == 0 or la[0] < self._W.n), "%s is not a %s-bounded partition." % (la, self._W.n-1)
+        Sym = SymmetricFunctions(self._base_ring)
+        h = Sym.homogeneous()
+        ks = Sym.kschur(self._n-1,1)
+        f = h(ks[la])
+        return sum(f.coefficient(x)*self.homogeneous_noncommutative_variables(x) for x in f.support())