def _standard_bracket(self, lw):
"""
Return the standard bracketing (a :class:`LieObject`)
of a Lyndon word ``lw`` using the Lie bracket.
INPUT:
- ``lw`` -- tuple of positive integers that correspond to
the indices of the generators
EXAMPLES::
sage: L = LieAlgebra(QQ, 'x', 3)
sage: Lyn = L.Lyndon()
sage: Lyn._standard_bracket((0, 0, 1))
[x0, [x0, x1]]
sage: Lyn._standard_bracket((0, 1, 1))
[[x0, x1], x1]
"""
if len(lw) == 1:
i = lw[0]
return LieGenerator(self._indices[i], i)
for i in range(1, len(lw)):
if is_lyndon(lw[i:]):
return LyndonBracket(self._standard_bracket(lw[:i]),
self._standard_bracket(lw[i:]),
len(lw))
def graded_basis(self, k):
"""
Return the basis for the ``k``-th graded piece of ``self``.
EXAMPLES::
sage: L = LieAlgebra(QQ, 'x', 3)
sage: Lyn = L.Lyndon()
sage: Lyn.graded_basis(1)
(x0, x1, x2)
sage: Lyn.graded_basis(2)
([x0, x1], [x0, x2], [x1, x2])
sage: Lyn.graded_basis(4)
([x0, [x0, [x0, x1]]],
[x0, [x0, [x0, x2]]],
[x0, [[x0, x1], x1]],
[x0, [x0, [x1, x2]]],
[x0, [[x0, x2], x1]],
[x0, [[x0, x2], x2]],
[[x0, x1], [x0, x2]],
[[[x0, x1], x1], x1],
[x0, [x1, [x1, x2]]],
[[x0, [x1, x2]], x1],
[x0, [[x1, x2], x2]],
[[[x0, x2], x1], x1],
[[x0, x2], [x1, x2]],
[[[x0, x2], x2], x1],
[[[x0, x2], x2], x2],
[x1, [x1, [x1, x2]]],
[x1, [[x1, x2], x2]],
[[[x1, x2], x2], x2])
TESTS::
sage: L = LieAlgebra(QQ, 'x,y,z', 3)
sage: Lyn = L.Lyndon()
sage: [Lyn.graded_dimension(i) for i in range(1, 11)]
[3, 3, 8, 18, 48, 116, 312, 810, 2184, 5880]
sage: [len(Lyn.graded_basis(i)) for i in range(1, 11)]
[3, 3, 8, 18, 48, 116, 312, 810, 2184, 5880]
"""
if k <= 0 or not self._indices:
return []
names = self.variable_names()
one = self.base_ring().one()
if k == 1:
return tuple(
self.element_class(self, {LieGenerator(n, k): one})
for k, n in enumerate(names))
from sage.combinat.combinat_cython import lyndon_word_iterator
n = len(self._indices)
ret = []
for lw in lyndon_word_iterator(n, k):
b = self._standard_bracket(tuple(lw))
ret.append(self.element_class(self, {b: one}))
return tuple(ret)
def monomial(self, x):
"""
Return the monomial indexed by ``x``.
EXAMPLES::
sage: Lyn = LieAlgebra(QQ, 'x,y').Lyndon()
sage: x = Lyn.monomial('x'); x
x
sage: x.parent() is Lyn
True
"""
if not isinstance(x, (LieGenerator, GradedLieBracket)):
if isinstance(x, list):
return super(FreeLieBasis_abstract, self)._element_constructor_(x)
else:
x = LieGenerator(x)
return self.element_class(self, {x: self.base_ring().one()})
def _standard_bracket(self, lw):
"""
Return the standard bracketing (a :class:`LieObject`)
of a Lyndon word ``lw`` using the Lie bracket.
EXAMPLES::
sage: L = LieAlgebra(QQ, 'x', 3)
sage: Lyn = L.Lyndon()
sage: Lyn._standard_bracket(('x0', 'x0', 'x1'))
[x0, [x0, x1]]
sage: Lyn._standard_bracket(('x0', 'x1', 'x1'))
[[x0, x1], x1]
"""
if len(lw) == 1:
return LieGenerator(lw[0])
for i in range(1, len(lw)):
if is_lyndon(lw[i:]):
return LyndonBracket(self._standard_bracket(lw[:i]),
self._standard_bracket(lw[i:]),
len(lw))
def graded_basis(self, k):
"""
Return the basis for the ``k``-th graded piece of ``self``.
EXAMPLES::
sage: L = LieAlgebra(QQ, 'x', 3)
sage: Lyn = L.Lyndon()
sage: Lyn.graded_basis(1)
(x0, x1, x2)
sage: Lyn.graded_basis(2)
([x0, x1], [x0, x2], [x1, x2])
sage: Lyn.graded_basis(4)
([x0, [x0, [x0, x1]]],
[x0, [x0, [x0, x2]]],
[x0, [[x0, x1], x1]],
[x0, [x0, [x1, x2]]],
[x0, [[x0, x2], x1]],
[[x0, x1], [x0, x2]],
[x0, [[x0, x2], x2]],
[[[x0, x1], x1], x1],
[x0, [x1, [x1, x2]]],
[[x0, [x1, x2]], x1],
[[[x0, x2], x1], x1],
[x0, [[x1, x2], x2]],
[[x0, x2], [x1, x2]],
[[[x0, x2], x2], x1],
[[[x0, x2], x2], x2],
[x1, [x1, [x1, x2]]],
[x1, [[x1, x2], x2]],
[[[x1, x2], x2], x2])
TESTS::
sage: L = LieAlgebra(QQ, 'x,y,z', 3)
sage: Lyn = L.Lyndon()
sage: [Lyn.graded_dimension(i) for i in range(1, 11)]
[3, 3, 8, 18, 48, 116, 312, 810, 2184, 5880]
sage: [len(Lyn.graded_basis(i)) for i in range(1, 11)]
[3, 3, 8, 18, 48, 116, 312, 810, 2184, 5880]
"""
if k <= 0 or not self._indices:
return []
names = self.variable_names()
one = self.base_ring().one()
if k == 1:
return tuple(self.element_class(self, {LieGenerator(n): one}) for n in names)
# Slightly modified form of LyndonWords_nk which is 0 indexed,
# does not create any temporary objects and simplifies the
# combined logic
from sage.combinat.integer_vector import IntegerVectors
from sage.combinat.necklace import _sfc
n = len(self._indices)
ret = []
for c in IntegerVectors(k, n):
nonzero_indices = [i for i,val in enumerate(c) if val != 0]
cf = [c[i] for i in nonzero_indices]
for z in _sfc(cf, equality=True):
b = self._standard_bracket(tuple([names[nonzero_indices[i]] for i in z]))
ret.append(self.element_class(self, {b: one}))
return tuple(ret)