def strictly_upper_triangular_matrices(R, n): r""" Return the Lie algebra `\mathfrak{n}_k` of strictly `k \times k` upper triangular matrices. .. TODO:: This implementation does not know it is finite-dimensional and does not know its basis. EXAMPLES:: sage: L = lie_algebras.strictly_upper_triangular_matrices(QQ, 4); L Lie algebra of 4-dimensional strictly upper triangular matrices over Rational Field sage: TestSuite(L).run() sage: n0, n1, n2 = L.lie_algebra_generators() sage: L[n2, n1] [ 0 0 0 0] [ 0 0 0 -1] [ 0 0 0 0] [ 0 0 0 0] TESTS:: sage: L = lie_algebras.strictly_upper_triangular_matrices(QQ, 1); L Lie algebra of 1-dimensional strictly upper triangular matrices over Rational Field sage: TestSuite(L).run() sage: L = lie_algebras.strictly_upper_triangular_matrices(QQ, 0); L Lie algebra of 0-dimensional strictly upper triangular matrices over Rational Field sage: TestSuite(L).run() """ from sage.matrix.matrix_space import MatrixSpace from sage.algebras.lie_algebras.lie_algebra import LieAlgebraFromAssociative MS = MatrixSpace(R, n, sparse=True) one = R.one() names = tuple('n{}'.format(i) for i in range(n - 1)) gens = tuple(MS({(i, i + 1): one}) for i in range(n - 1)) L = LieAlgebraFromAssociative(MS, gens, names=names) L.rename( "Lie algebra of {}-dimensional strictly upper triangular matrices over {}" .format(n, L.base_ring())) return L
def __init__(self, R, n): """ Initialize ``self``. EXAMPLES:: sage: L = lie_algebras.Heisenberg(QQ, 2, representation="matrix") sage: TestSuite(L).run() """ HeisenbergAlgebra_fd.__init__(self, n) MS = MatrixSpace(R, n+2, sparse=True) one = R.one() p = tuple(MS({(0,i): one}) for i in range(1, n+1)) q = tuple(MS({(i,n+1): one}) for i in range(1, n+1)) z = (MS({(0,n+1): one}),) names = tuple('p%s'%i for i in range(1,n+1)) names = names + tuple('q%s'%i for i in range(1,n+1)) + ('z',) cat = LieAlgebras(R).Nilpotent().FiniteDimensional().WithBasis() LieAlgebraFromAssociative.__init__(self, MS, p + q + z, names=names, index_set=names, category=cat)
def __init__(self, R, n): """ Initialize ``self``. EXAMPLES:: sage: L = lie_algebras.Heisenberg(QQ, 2, representation="matrix") sage: TestSuite(L).run() """ HeisenbergAlgebra_fd.__init__(self, n) MS = MatrixSpace(R, n+2, sparse=True) one = R.one() p = tuple(MS({(0,i): one}) for i in range(1, n+1)) q = tuple(MS({(i,n+1): one}) for i in range(1, n+1)) z = (MS({(0,n+1): one}),) names = tuple('p%s'%i for i in range(1,n+1)) names = names + tuple('q%s'%i for i in range(1,n+1)) + ('z',) cat = LieAlgebras(R).FiniteDimensional().WithBasis() LieAlgebraFromAssociative.__init__(self, MS, p + q + z, names=names, index_set=names, category=cat)
def strictly_upper_triangular_matrices(R, n): r""" Return the Lie algebra `\mathfrak{n}_k` of strictly `k \times k` upper triangular matrices. .. TODO:: This implementation does not know it is finite-dimensional and does not know its basis. EXAMPLES:: sage: L = lie_algebras.strictly_upper_triangular_matrices(QQ, 4); L Lie algebra of 4-dimensional strictly upper triangular matrices over Rational Field sage: TestSuite(L).run() sage: n0, n1, n2 = L.lie_algebra_generators() sage: L[n2, n1] [ 0 0 0 0] [ 0 0 0 -1] [ 0 0 0 0] [ 0 0 0 0] TESTS:: sage: L = lie_algebras.strictly_upper_triangular_matrices(QQ, 1); L Lie algebra of 1-dimensional strictly upper triangular matrices over Rational Field sage: TestSuite(L).run() sage: L = lie_algebras.strictly_upper_triangular_matrices(QQ, 0); L Lie algebra of 0-dimensional strictly upper triangular matrices over Rational Field sage: TestSuite(L).run() """ from sage.matrix.matrix_space import MatrixSpace from sage.algebras.lie_algebras.lie_algebra import LieAlgebraFromAssociative MS = MatrixSpace(R, n, sparse=True) one = R.one() names = tuple('n{}'.format(i) for i in range(n-1)) gens = tuple(MS({(i,i+1):one}) for i in range(n-1)) L = LieAlgebraFromAssociative(MS, gens, names=names) L.rename("Lie algebra of {}-dimensional strictly upper triangular matrices over {}".format(n, L.base_ring())) return L
def __init__(self, R, n): """ Initialize ``self``. EXAMPLES:: sage: g = lie_algebras.gl(QQ, 4) sage: TestSuite(g).run() TESTS: Check that :trac:`23266` is fixed:: sage: gl2 = lie_algebras.gl(QQ, 2) sage: isinstance(gl2.basis().keys(), FiniteEnumeratedSet) True sage: Ugl2 = gl2.pbw_basis() sage: prod(Ugl2.gens()) PBW['E_0_0']*PBW['E_0_1']*PBW['E_1_0']*PBW['E_1_1'] """ MS = MatrixSpace(R, n, sparse=True) one = R.one() names = [] gens = [] for i in range(n): for j in range(n): names.append('E_{0}_{1}'.format(i,j)) mat = MS({(i,j):one}) mat.set_immutable() gens.append(mat) self._n = n category = LieAlgebras(R).FiniteDimensional().WithBasis() from sage.sets.finite_enumerated_set import FiniteEnumeratedSet index_set = FiniteEnumeratedSet(names) LieAlgebraFromAssociative.__init__(self, MS, tuple(gens), names=tuple(names), index_set=index_set, category=category)
def __init__(self, R, ct, e, f, h): """ Initialize ``self``. EXAMPLES:: sage: g = lie_algebras.sl(QQ, 3, representation='matrix') sage: TestSuite(g).run() TESTS: Check that :trac:`23266` is fixed:: sage: sl2 = lie_algebras.sl(QQ, 2, 'matrix') sage: isinstance(sl2.indices(), FiniteEnumeratedSet) True """ n = len(e) names = ['e%s'%i for i in range(1, n+1)] names += ['f%s'%i for i in range(1, n+1)] names += ['h%s'%i for i in range(1, n+1)] category = LieAlgebras(R).FiniteDimensional().WithBasis() from sage.sets.finite_enumerated_set import FiniteEnumeratedSet index_set = FiniteEnumeratedSet(names) LieAlgebraFromAssociative.__init__(self, e[0].parent(), gens=tuple(e + f + h), names=tuple(names), index_set=index_set, category=category) self._cartan_type = ct gens = tuple(self.gens()) i_set = ct.index_set() self._e = Family(dict( (i, gens[c]) for c,i in enumerate(i_set) )) self._f = Family(dict( (i, gens[n+c]) for c,i in enumerate(i_set) )) self._h = Family(dict( (i, gens[2*n+c]) for c,i in enumerate(i_set) ))
def affine_transformations_line(R, names=['X', 'Y'], representation='bracket'): """ The Lie algebra of affine transformations of the line. EXAMPLES:: sage: L = lie_algebras.affine_transformations_line(QQ) sage: L.structure_coefficients() Finite family {('X', 'Y'): Y} sage: X, Y = L.lie_algebra_generators() sage: L[X, Y] == Y True sage: TestSuite(L).run() sage: L = lie_algebras.affine_transformations_line(QQ, representation="matrix") sage: X, Y = L.lie_algebra_generators() sage: L[X, Y] == Y True sage: TestSuite(L).run() """ if isinstance(names, str): names = names.split(',') names = tuple(names) if representation == 'matrix': from sage.matrix.matrix_space import MatrixSpace MS = MatrixSpace(R, 2, sparse=True) one = R.one() gens = tuple(MS({(0, i): one}) for i in range(2)) from sage.algebras.lie_algebras.lie_algebra import LieAlgebraFromAssociative return LieAlgebraFromAssociative(MS, gens, names=names) X = names[0] Y = names[1] from sage.algebras.lie_algebras.structure_coefficients import LieAlgebraWithStructureCoefficients s_coeff = {(X, Y): {Y: R.one()}} L = LieAlgebraWithStructureCoefficients(R, s_coeff, names=names) L.rename( "Lie algebra of affine transformations of a line over {}".format(R)) return L