def __init__(self, R, p):
"""
Initialize ``self``.
EXAMPLES::
sage: L = lie_algebras.pwitt(GF(5), 5); L
The 5-Witt Lie algebra over Finite Field of size 5
sage: TestSuite(L).run()
sage: L = lie_algebras.pwitt(Zmod(6), 6)
sage: TestSuite(L).run() # not tested -- universal envelope doesn't work
sage: L._test_jacobi_identity()
"""
if R(p) != 0:
raise ValueError("{} is not 0 in {}".format(p, R))
cat = LieAlgebras(R).FiniteDimensional().WithBasis()
FinitelyGeneratedLieAlgebra.__init__(self,
R,
index_set=list(range(p)),
category=cat)
IndexedGenerators.__init__(self,
list(range(p)),
prefix='d',
bracket='[')
self._p = p
def __init__(self, R, p):
"""
Initialize ``self``.
EXAMPLES::
sage: L = lie_algebras.pwitt(GF(5), 5); L
The 5-Witt Lie algebra over Finite Field of size 5
sage: TestSuite(L).run()
We skip the grading test as we need to be able to echelonize a
matrix over the base ring as part of the test::
sage: L = lie_algebras.pwitt(Zmod(6), 6)
sage: TestSuite(L).run(skip="_test_grading")
"""
if R(p) != 0:
raise ValueError("{} is not 0 in {}".format(p, R))
cat = LieAlgebras(R).FiniteDimensional().WithBasis().Graded()
FinitelyGeneratedLieAlgebra.__init__(self,
R,
index_set=list(range(p)),
category=cat)
IndexedGenerators.__init__(self,
list(range(p)),
prefix='d',
bracket='[')
self._p = p
def __init__(self, indices, prefix, category=None, names=None, **kwds):
"""
Initialize ``self``.
EXAMPLES::
sage: F = FreeMonoid(index_set=ZZ)
sage: TestSuite(F).run()
sage: F = FreeMonoid(index_set=tuple('abcde'))
sage: TestSuite(F).run()
sage: F = FreeAbelianMonoid(index_set=ZZ)
sage: TestSuite(F).run()
sage: F = FreeAbelianMonoid(index_set=tuple('abcde'))
sage: TestSuite(F).run()
"""
self._indices = indices
category = Monoids().or_subcategory(category)
if indices.cardinality() == 0:
category = category.Finite()
else:
category = category.Infinite()
Parent.__init__(self, names=names, category=category)
# ignore the optional 'key' since it only affects CachedRepresentation
kwds.pop("key", None)
IndexedGenerators.__init__(self, indices, prefix, **kwds)
def __init__(self, indices, prefix, category=None, names=None, **kwds):
"""
Initialize ``self``.
EXAMPLES::
sage: F = FreeMonoid(index_set=ZZ)
sage: TestSuite(F).run()
sage: F = FreeMonoid(index_set=tuple('abcde'))
sage: TestSuite(F).run()
sage: F = FreeAbelianMonoid(index_set=ZZ)
sage: TestSuite(F).run()
sage: F = FreeAbelianMonoid(index_set=tuple('abcde'))
sage: TestSuite(F).run()
"""
self._indices = indices
category = Monoids().or_subcategory(category)
if indices.cardinality() == 0:
category = category.Finite()
else:
category = category.Infinite()
if indices in Sets().Finite():
category = category.FinitelyGeneratedAsMagma()
Parent.__init__(self, names=names, category=category)
# ignore the optional 'key' since it only affects CachedRepresentation
kwds.pop('key', None)
IndexedGenerators.__init__(self, indices, prefix, **kwds)
def __init__(self, I):
"""
Initialize ``self``.
EXAMPLES::
sage: L = lie_algebras.Heisenberg(QQ, oo) # indirect doctest
"""
IndexedGenerators.__init__(self, I, prefix='', bracket=False,
latex_bracket=False, string_quotes=False)
def __init__(self, I):
"""
Initialize ``self``.
EXAMPLES::
sage: L = lie_algebras.Heisenberg(QQ, oo) # indirect doctest
"""
IndexedGenerators.__init__(self, I, prefix='', bracket=False,
latex_bracket=False, string_quotes=False)
def __init__(self, R):
"""
Initialize ``self``.
EXAMPLES::
sage: L = lie_algebras.regular_vector_fields(QQ)
sage: TestSuite(L).run()
"""
cat = LieAlgebras(R).WithBasis()
InfinitelyGeneratedLieAlgebra.__init__(self, R, index_set=ZZ, category=cat)
IndexedGenerators.__init__(self, ZZ, prefix='d', bracket='[')
def __init__(self, R, index_set, prefix='L', **kwds):
"""
Initialize ``self``.
EXAMPLES::
sage: L = LieAlgebra(QQ, index_set=ZZ, abelian=True)
sage: TestSuite(L).run()
"""
cat = LieAlgebras(R).WithBasis()
InfinitelyGeneratedLieAlgebra.__init__(self, R, category=cat)
IndexedGenerators.__init__(self, index_set, prefix=prefix, **kwds)
def __init__(self, R):
"""
Initialize ``self``.
EXAMPLES::
sage: L = lie_algebras.regular_vector_fields(QQ)
sage: TestSuite(L).run()
"""
cat = LieAlgebras(R).WithBasis()
InfinitelyGeneratedLieAlgebra.__init__(self, R, index_set=ZZ, category=cat)
IndexedGenerators.__init__(self, ZZ, prefix='d', bracket='[')
def __init__(self, R):
"""
Initialize ``self``.
EXAMPLES::
sage: d = lie_algebras.VirasoroAlgebra(QQ)
sage: TestSuite(d).run()
"""
cat = LieAlgebras(R).WithBasis()
InfinitelyGeneratedLieAlgebra.__init__(self, R, index_set=ZZ, category=cat)
IndexedGenerators.__init__(self, ZZ, prefix='d', bracket='[',
sorting_key=_basis_key)
def __init__(self, R):
"""
Initialize ``self``.
EXAMPLES::
sage: d = lie_algebras.VirasoroAlgebra(QQ)
sage: TestSuite(d).run()
"""
cat = LieAlgebras(R).WithBasis()
InfinitelyGeneratedLieAlgebra.__init__(self, R, index_set=ZZ, category=cat)
IndexedGenerators.__init__(self, ZZ, prefix='d', bracket='[',
sorting_key=_basis_key)
def __init__(self, R):
"""
Initialize ``self``.
EXAMPLES::
sage: O = lie_algebras.OnsagerAlgebra(QQ)
sage: TestSuite(O).run()
"""
cat = LieAlgebras(R).WithBasis()
from sage.sets.finite_enumerated_set import FiniteEnumeratedSet
IndexedGenerators.__init__(self, FiniteEnumeratedSet([0,1]))
LieAlgebraWithGenerators.__init__(self, R, index_set=self._indices,
names=('A0', 'A1'), category=cat)
def __init__(self, R):
"""
Initialize ``self``.
EXAMPLES::
sage: O = lie_algebras.OnsagerAlgebra(QQ)
sage: TestSuite(O).run()
"""
cat = LieAlgebras(R).WithBasis()
from sage.sets.finite_enumerated_set import FiniteEnumeratedSet
IndexedGenerators.__init__(self, FiniteEnumeratedSet([0,1]))
LieAlgebraWithGenerators.__init__(self, R, index_set=self._indices,
names=('A0', 'A1'), category=cat)
def __init__(self, R, s_coeff, names, index_set, category=None, prefix=None,
bracket=None, latex_bracket=None, string_quotes=None, **kwds):
"""
Initialize ``self``.
EXAMPLES::
sage: L = LieAlgebra(QQ, 'x,y', {('x','y'): {'x':1}})
sage: TestSuite(L).run()
"""
default = (names != tuple(index_set))
if prefix is None:
if default:
prefix = 'L'
else:
prefix = ''
if bracket is None:
bracket = default
if latex_bracket is None:
latex_bracket = default
if string_quotes is None:
string_quotes = default
#self._pos_to_index = dict(enumerate(index_set))
self._index_to_pos = {k: i for i,k in enumerate(index_set)}
if "sorting_key" not in kwds:
kwds["sorting_key"] = self._index_to_pos.__getitem__
cat = LieAlgebras(R).WithBasis().FiniteDimensional().or_subcategory(category)
FinitelyGeneratedLieAlgebra.__init__(self, R, names, index_set, cat)
IndexedGenerators.__init__(self, self._indices, prefix=prefix,
bracket=bracket, latex_bracket=latex_bracket,
string_quotes=string_quotes, **kwds)
self._M = FreeModule(R, len(index_set))
# Transform the values in the structure coefficients to elements
def to_vector(tuples):
vec = [R.zero()]*len(index_set)
for k,c in tuples:
vec[self._index_to_pos[k]] = c
vec = self._M(vec)
vec.set_immutable()
return vec
self._s_coeff = {(self._index_to_pos[k[0]], self._index_to_pos[k[1]]):
to_vector(s_coeff[k])
for k in s_coeff.keys()}
def __init__(self, R, g):
r"""
Initialize ``self``.
EXAMPLES::
sage: L = lie_algebras.SymplecticDerivation(QQ, 5)
sage: TestSuite(L).run()
"""
if g < 4:
raise ValueError("g must be at least 4")
cat = LieAlgebras(R).WithBasis().Graded()
self._g = g
d = Family(NonNegativeIntegers(), lambda n: Partitions(n, min_length=2, max_part=2*g))
indices = DisjointUnionEnumeratedSets(d)
InfinitelyGeneratedLieAlgebra.__init__(self, R, index_set=indices, category=cat)
IndexedGenerators.__init__(self, indices, sorting_key=self._basis_key)
def __init__(self, lie, basis_name):
"""
Initialize ``self``.
EXAMPLES::
sage: L.<x, y> = LieAlgebra(QQ)
sage: L.Hall()
doctest:warning
...
FutureWarning: The Hall basis has not been fully proven correct, but currently no bugs are known
See http://trac.sagemath.org/16823 for details.
Free Lie algebra generated by (x, y) over Rational Field in the Hall basis
"""
self._basis_name = basis_name
IndexedGenerators.__init__(self, lie._indices, prefix='', bracket=False)
FinitelyGeneratedLieAlgebra.__init__(self, lie.base_ring(),
names=lie._names, index_set=lie._indices,
category=FreeLieAlgebraBases(lie))
def __init__(self, R):
r"""
Initialize ``self``.
EXAMPLES::
sage: L = lie_algebras.RankTwoHeisenbergVirasoro(QQ)
sage: TestSuite(L).run()
"""
cat = LieAlgebras(R).WithBasis()
self._KI = FiniteEnumeratedSet([1, 2, 3, 4])
self._V = ZZ**2
d = {'K': self._KI, 'E': self._V, 't': self._V}
indices = DisjointUnionEnumeratedSets(d, keepkey=True, facade=True)
InfinitelyGeneratedLieAlgebra.__init__(self,
R,
index_set=indices,
category=cat)
IndexedGenerators.__init__(self, indices, sorting_key=self._basis_key)
def __init__(self, R):
r"""
Initialize ``self``.
EXAMPLES::
sage: ACE = lie_algebras.AlternatingCentralExtensionOnsagerAlgebra(QQ)
sage: TestSuite(ACE).run()
sage: B = ACE.basis()
sage: A1, A2, Am2 = B[0,1], B[0,2], B[0,-2]
sage: B1, B2, Bm2 = B[1,1], B[1,2], B[1,-2]
sage: TestSuite(ACE).run(elements=[A1,A2,Am2,B1,B2,Bm2,ACE.an_element()])
"""
cat = LieAlgebras(R).WithBasis()
from sage.rings.integer_ring import ZZ
from sage.sets.disjoint_union_enumerated_sets import DisjointUnionEnumeratedSets
I = DisjointUnionEnumeratedSets([ZZ, ZZ], keepkey=True, facade=True)
IndexedGenerators.__init__(self, I)
InfinitelyGeneratedLieAlgebra.__init__(self,
R,
index_set=I,
category=cat)
def _repr_term(self, m):
"""
Return a string representation of the term indexed by ``m``.
EXAMPLES::
sage: d = lie_algebras.VirasoroAlgebra(QQ)
sage: d._repr_term('c')
'c'
sage: d._repr_term(2)
'd[2]'
"""
if isinstance(m, str):
return m
return IndexedGenerators._repr_generator(self, m)
def _latex_generator(self, m):
r"""
Return a latex representation of the basis element indexed by ``m``.
EXAMPLES::
sage: L = LieAlgebra(QQ, cartan_type=['A', 2])
sage: K = L.basis().keys()
sage: L._latex_generator(K[0])
'E_{\\alpha_{2}}'
sage: L._latex_generator(K[4])
'h_{2}'
"""
if m in self._cartan_type.root_system().root_lattice().simple_coroots():
return "h_{{{}}}".format(m.support()[0])
return IndexedGenerators._latex_generator(self, m)
def _repr_generator(self, m):
"""
Return a string representation of the basis element indexed by ``m``.
EXAMPLES::
sage: L = LieAlgebra(QQ, cartan_type=['A', 2])
sage: K = L.basis().keys()
sage: L._repr_generator(K[0])
'E[alpha[2]]'
sage: L._repr_generator(K[4])
'h2'
"""
if m in self._cartan_type.root_system().root_lattice().simple_coroots():
return "h{}".format(m.support()[0])
return IndexedGenerators._repr_generator(self, m)
def _latex_term(self, m):
r"""
Return a `\LaTeX` representation of the term indexed by ``m``.
EXAMPLES::
sage: d = lie_algebras.VirasoroAlgebra(QQ)
sage: d._latex_term('c')
'c'
sage: d._latex_term(2)
'd_{2}'
sage: d._latex_term(-13)
'd_{-13}'
"""
if isinstance(m, str):
return m
return IndexedGenerators._latex_generator(self, m)
def _repr_generator(self, x):
"""
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)