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)