Virasoro Algebra and Related Lie Algebras#

AUTHORS:

Travis Scrimshaw (2013-05-03): Initial version

class sage.algebras.lie_algebras.virasoro.ChargelessRepresentation(V, a, b)#

Bases: sage.combinat.free_module.CombinatorialFreeModule

A chargeless representation of the Virasoro algebra.

Let \(L\) be the Virasoro algebra over the field \(F\) of characteristic \(0\). For \(\alpha, \beta \in R\), we denote \(V_{a,b}\) as the \((a, b)\)-chargeless representation of \(L\), which is the \(F\)-span of \(\{v_k \mid k \in \ZZ\}\) with \(L\) action

\[\begin{split}\begin{aligned} d_n \cdot v_k & = (a n + b - k) v_{n+k}, \\ c \cdot v_k & = 0, \end{aligned}\end{split}\]

This comes from the action of \(d_n = -t^{n+1} \frac{d}{dt}\) on \(F[t, t^{-1}]\) (recall that \(L\) is the central extension of the algebra of derivations of \(F[t, t^{-1}]\)), where

\[V_{a,b} = F[t, t^{-1}] t^{a-b} (dt)^{-a}\]

and \(v_k = t^{a-b+k} (dz)^{-a}\).

The chargeless representations are either irreducible or contains exactly two simple subquotients, one of which is the trivial representation and the other is \(F[t, t^{-1}] / F\). The non-trivial simple subquotients are called the intermediate series.

The module \(V_{a,b}\) is irreducible if and only if \(a \neq 0, -1\) or \(b \notin \ZZ\). When \(a = 0\) and \(b \in \ZZ\), then there exists a subrepresentation isomorphic to the trivial representation. If \(a = -1\) and \(b \in \ZZ\), then there exists a subrepresentation \(V\) such that \(V_{a,b} / V\) is isomorphic to \(K \frac{dt}{t}\) and \(V\) is irreducible.

In characteristic \(p\), the non-trivial simple subquotient is isomorphic to \(F[t, t^{-1}] / F[t^p, t^{-p}]\). For \(p \neq 2,3\), then the action is given as above.

EXAMPLES:

We first construct the irreducible \(V_{1/2, 3/4}\) and do some basic computations:

sage: L = lie_algebras.VirasoroAlgebra(QQ)
sage: M = L.chargeless_representation(1/2, 3/4)
sage: d = L.basis()
sage: v = M.basis()
sage: d[3] * v[2]
1/4*v[5]
sage: d[3] * v[-1]
13/4*v[2]
sage: (d[3] - d[-2]) * (v[-1] + 1/2*v[0] - v[4])
-3/4*v[-3] + 1/8*v[-2] - v[2] + 9/8*v[3] + 7/4*v[7]

We construct the reducible \(V_{0,2}\) and the trivial subrepresentation given by the span of \(v_2\). We verify this for \(\{d_i \mid -10 \leq i < 10\}\):

sage: M = L.chargeless_representation(0, 2)
sage: v = M.basis()
sage: all(d[i] * v[2] == M.zero() for i in range(-10, 10))
True

REFERENCES:

class Element#: Bases: sage.modules.with_basis.indexed_element.IndexedFreeModuleElement

degree_on_basis(i)#

Return the degree of the basis element indexed by i, which is \(i\).

EXAMPLES:

sage: L = lie_algebras.VirasoroAlgebra(QQ)
sage: M = L.chargeless_representation(1/2, 3/4)
sage: M.degree_on_basis(-3)
-3

parameters()#

Return the parameters \((a, b)\) of self.

EXAMPLES:

sage: L = lie_algebras.VirasoroAlgebra(QQ)
sage: M = L.chargeless_representation(1/2, 3/4)
sage: M.parameters()
(1/2, 3/4)

virasoro_algebra()#

Return the Virasoro algebra self is a representation of.

EXAMPLES:

sage: L = lie_algebras.VirasoroAlgebra(QQ)
sage: M = L.chargeless_representation(1/2, 3/4)
sage: M.virasoro_algebra() is L
True

class sage.algebras.lie_algebras.virasoro.LieAlgebraRegularVectorFields(R)#

Bases: sage.algebras.lie_algebras.lie_algebra.InfinitelyGeneratedLieAlgebra, sage.structure.indexed_generators.IndexedGenerators

The Lie algebra of regular vector fields on \(\CC^{\times}\).

This is the Lie algebra with basis \(\{d_i\}_{i \in \ZZ}\) and subject to the relations

\[[d_i, d_j] = (i - j) d_{i+j}.\]

This is also known as the Witt (Lie) algebra.

Note

This differs from some conventions (e.g., [Ka1990]), where we have \(d'_i \mapsto -d_i\).

REFERENCES:

Wikipedia article Witt_algebra

See also

WittLieAlgebra_charp

class Element#: Bases: sage.algebras.lie_algebras.lie_algebra_element.LieAlgebraElement

bracket_on_basis(i, j)#

Return the bracket of basis elements indexed by x and y where x < y.

(This particular implementation actually does not require x < y.)

EXAMPLES:

sage: L = lie_algebras.regular_vector_fields(QQ)
sage: L.bracket_on_basis(2, -2)
4*d[0]
sage: L.bracket_on_basis(2, 4)
-2*d[6]
sage: L.bracket_on_basis(4, 4)
0

degree_on_basis(i)#

Return the degree of the basis element indexed by i, which is i.

EXAMPLES:

sage: L = lie_algebras.regular_vector_fields(QQ)
sage: L.degree_on_basis(2)
2

lie_algebra_generators()#

Return the generators of self as a Lie algebra.

EXAMPLES:

sage: L = lie_algebras.regular_vector_fields(QQ)
sage: L.lie_algebra_generators()
Lazy family (generator map(i))_{i in Integer Ring}

some_elements()#

Return some elements of self.

EXAMPLES:

sage: L = lie_algebras.regular_vector_fields(QQ)
sage: L.some_elements()
[d[0], d[2], d[-2], d[-1] + d[0] - 3*d[1]]

class sage.algebras.lie_algebras.virasoro.VermaModule(V, c, h)#

Bases: sage.combinat.free_module.CombinatorialFreeModule

A Verma module of the Virasoro algebra.

The Virasoro algebra admits a triangular decomposition

\[V_- \oplus R d_0 \oplus R \hat{c} \oplus V_+,\]

where \(V_-\) (resp. \(V_+\)) is the span of \(\{d_i \mid i < 0\}\) (resp. \(\{d_i \mid i > 0\}\)). We can construct the Verma module \(M_{c,h}\) as the induced representation of the \(R d_0 \oplus R \hat{c} \oplus V_+\) representation \(R_{c,H} = Rv\), where

\[V_+ v = 0, \qquad \hat{c} v = c v, \qquad d_0 v = h v.\]

Therefore, we have a basis of \(M_{c,h}\)

\[\{ L_{i_1} \cdots L_{i_k} v \mid i_1 \leq \cdots \leq i_k < 0 \}.\]

Moreover, the Verma modules are the free objects in the category of highest weight representations of \(V\) and are indecomposable. The Verma module \(M_{c,h}\) is irreducible for generic values of \(c\) and \(h\) and when it is reducible, the quotient by the maximal submodule is the unique irreducible highest weight representation \(V_{c,h}\).

EXAMPLES:

We construct a Verma module and do some basic computations:

sage: L = lie_algebras.VirasoroAlgebra(QQ)
sage: M = L.verma_module(3, 0)
sage: d = L.basis()
sage: v = M.highest_weight_vector()
sage: d[3] * v
0
sage: d[-3] * v
d[-3]*v
sage: d[-1] * (d[-3] * v)
2*d[-4]*v + d[-3]*d[-1]*v
sage: d[2] * (d[-1] * (d[-3] * v))
12*d[-2]*v + 5*d[-1]*d[-1]*v

We verify that \(d_{-1} v\) is a singular vector for \(\{d_i \mid 1 \leq i < 20\}\):

sage: w = M.basis()[-1]; w
d[-1]*v
sage: all(d[i] * w == M.zero() for i in range(1,20))
True

We also verify a singular vector for \(V_{-2,1}\):

sage: M = L.verma_module(-2, 1)
sage: B = M.basis()
sage: w = B[-1,-1] - 2 * B[-2]
sage: d = L.basis()
sage: all(d[i] * w == M.zero() for i in range(1,20))
True

REFERENCES:

Wikipedia article Virasoro_algebra#Representation_theory

class Element#: Bases: sage.modules.with_basis.indexed_element.IndexedFreeModuleElement

central_charge()#

Return the central charge of self.

EXAMPLES:

sage: L = lie_algebras.VirasoroAlgebra(QQ)
sage: M = L.verma_module(3, 0)
sage: M.central_charge()
3

conformal_weight()#

Return the conformal weight of self.

EXAMPLES:

sage: L = lie_algebras.VirasoroAlgebra(QQ)
sage: M = L.verma_module(3, 0)
sage: M.conformal_weight()
3

degree_on_basis(d)#

Return the degree of the basis element indexed by d, which is the sum of the entries of d.

EXAMPLES:

sage: L = lie_algebras.VirasoroAlgebra(QQ)
sage: M = L.verma_module(-2/7, 3)
sage: M.degree_on_basis((-3,-3,-1))
-7

highest_weight_vector()#

Return the highest weight vector of self.

EXAMPLES:

sage: L = lie_algebras.VirasoroAlgebra(QQ)
sage: M = L.verma_module(-2/7, 3)
sage: M.highest_weight_vector()
v

virasoro_algebra()#

Return the Virasoro algebra self is a representation of.

EXAMPLES:

sage: L = lie_algebras.VirasoroAlgebra(QQ)
sage: M = L.verma_module(1/2, 3/4)
sage: M.virasoro_algebra() is L
True

class sage.algebras.lie_algebras.virasoro.VirasoroAlgebra(R)#

Bases: sage.algebras.lie_algebras.lie_algebra.InfinitelyGeneratedLieAlgebra, sage.structure.indexed_generators.IndexedGenerators

The Virasoro algebra.

This is the Lie algebra with basis \(\{d_i\}_{i \in \ZZ} \cup \{c\}\) and subject to the relations

\[[d_i, d_j] = (i - j) d_{i+j} + \frac{1}{12}(i^3 - i) \delta_{i,-j} c\]

and

\[[d_i, c] = 0.\]

(Here, it is assumed that the base ring \(R\) has \(2\) invertible.)

This is the universal central extension \(\widetilde{\mathfrak{d}}\) of the Lie algebra \(\mathfrak{d}\) of regular vector fields on \(\CC^{\times}\).

EXAMPLES:

sage: d = lie_algebras.VirasoroAlgebra(QQ)

REFERENCES:

Wikipedia article Virasoro_algebra

class Element#: Bases: sage.algebras.lie_algebras.lie_algebra_element.LieAlgebraElement

basis()#

Return a basis of self.

EXAMPLES:

sage: d = lie_algebras.VirasoroAlgebra(QQ)
sage: B = d.basis(); B
Lazy family (basis map(i))_{i in Disjoint union of
                            Family ({'c'}, Integer Ring)}
sage: B['c']
c
sage: B[3]
d[3]
sage: B[-15]
d[-15]

bracket_on_basis(i, j)#

Return the bracket of basis elements indexed by x and y where x < y.

(This particular implementation actually does not require x < y.)

EXAMPLES:

sage: d = lie_algebras.VirasoroAlgebra(QQ)
sage: d.bracket_on_basis('c', 2)
0
sage: d.bracket_on_basis(2, -2)
4*d[0] + 1/2*c

c()#

The central element \(c\) in self.

EXAMPLES:

sage: d = lie_algebras.VirasoroAlgebra(QQ)
sage: d.c()
c

chargeless_representation(a, b)#

Return the chargeless representation of self with parameters a and b.

See also

ChargelessRepresentation

EXAMPLES:

sage: L = lie_algebras.VirasoroAlgebra(QQ)
sage: L.chargeless_representation(3, 2)
Chargeless representation (3, 2) of
 The Virasoro algebra over Rational Field

d(i)#

Return the element \(d_i\) in self.

EXAMPLES:

sage: L = lie_algebras.VirasoroAlgebra(QQ)
sage: L.d(2)
d[2]

degree_on_basis(i)#

Return the degree of the basis element indexed by i, which is i and \(0\) for 'c'.

EXAMPLES:

sage: d = lie_algebras.VirasoroAlgebra(QQ)
sage: d.degree_on_basis(2)
2
sage: d.c().degree()
0
sage: (d.c() + d.basis()[0]).is_homogeneous()
True

lie_algebra_generators()#

Return the generators of self as a Lie algebra.

EXAMPLES:

sage: d = lie_algebras.VirasoroAlgebra(QQ)
sage: d.lie_algebra_generators()
Lazy family (generator map(i))_{i in Integer Ring}

some_elements()#

Return some elements of self.

EXAMPLES:

sage: d = lie_algebras.VirasoroAlgebra(QQ)
sage: d.some_elements()
[d[0], d[2], d[-2], c, d[-1] + d[0] - 1/2*d[1] + c]

verma_module(c, h)#

Return the Verma module with central charge c and conformal (or highest) weight h.

See also

VermaModule

EXAMPLES:

sage: L = lie_algebras.VirasoroAlgebra(QQ)
sage: L.verma_module(3, 2)
Verma module with charge 3 and conformal weight 2 of
 The Virasoro algebra over Rational Field

class sage.algebras.lie_algebras.virasoro.WittLieAlgebra_charp(R, p)#

Bases: sage.algebras.lie_algebras.lie_algebra.FinitelyGeneratedLieAlgebra, sage.structure.indexed_generators.IndexedGenerators

The \(p\)-Witt Lie algebra over a ring \(R\) in which \(p \cdot 1_R = 0\).

Let \(R\) be a ring and \(p\) be a positive integer such that \(p \cdot 1_R = 0\). The \(p\)-Witt Lie algebra over \(R\) is the Lie algebra with basis \(\{d_0, d_1, \ldots, d_{p-1}\}\) and subject to the relations

\[[d_i, d_j] = (i - j) d_{i+j},\]

where the \(i+j\) on the right hand side is identified with its remainder modulo \(p\).

See also

LieAlgebraRegularVectorFields

class Element#: Bases: sage.algebras.lie_algebras.lie_algebra_element.LieAlgebraElement

bracket_on_basis(i, j)#

Return the bracket of basis elements indexed by x and y where x < y.

(This particular implementation actually does not require x < y.)

EXAMPLES:

sage: L = lie_algebras.pwitt(Zmod(5), 5)
sage: L.bracket_on_basis(2, 3)
4*d[0]
sage: L.bracket_on_basis(3, 2)
d[0]
sage: L.bracket_on_basis(2, 2)
0
sage: L.bracket_on_basis(1, 3)
3*d[4]

degree_on_basis(i)#

Return the degree of the basis element indexed by i, which is i mod \(p\).

EXAMPLES:

sage: L = lie_algebras.pwitt(Zmod(5), 5)
sage: L.degree_on_basis(7)
2
sage: L.degree_on_basis(2).parent()
Ring of integers modulo 5

lie_algebra_generators()#

Return the generators of self as a Lie algebra.

EXAMPLES:

sage: L = lie_algebras.pwitt(Zmod(5), 5)
sage: L.lie_algebra_generators()
Finite family {0: d[0], 1: d[1], 2: d[2], 3: d[3], 4: d[4]}

some_elements()#

Return some elements of self.

EXAMPLES:

sage: L = lie_algebras.pwitt(Zmod(5), 5)
sage: L.some_elements()
[d[0], d[2], d[3], d[0] + 2*d[1] + d[4]]