Virasoro Algebra and Related Lie Algebras - Algebras

Skip to content
Back to top
View this page
Edit this page

# 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: `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

      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]

  Python

      >>> from sage.all import *
      >>> L = lie_algebras.VirasoroAlgebra(QQ)
      >>> M = L.chargeless_representation(Integer(1)/Integer(2), Integer(3)/Integer(4))
      >>> d = L.basis()
      >>> v = M.basis()
      >>> d[Integer(3)] * v[Integer(2)]
      1/4*v[5]
      >>> d[Integer(3)] * v[-Integer(1)]
      13/4*v[2]
      >>> (d[Integer(3)] - d[-Integer(2)]) * (v[-Integer(1)] + Integer(1)/Integer(2)*v[Integer(0)] - v[Integer(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

      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

  [Python]

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

  REFERENCES:

  - [Mat1992]

  - [IK2010]

  class Element

    Bases: `IndexedFreeModuleElement`

  degree_on_basis(i)

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

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> L = lie_algebras.VirasoroAlgebra(QQ)
        >>> M = L.chargeless_representation(Integer(1)/Integer(2), Integer(3)/Integer(4))
        >>> M.degree_on_basis(-Integer(3))
        -3

  parameters()

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

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> L = lie_algebras.VirasoroAlgebra(QQ)
        >>> M = L.chargeless_representation(Integer(1)/Integer(2), Integer(3)/Integer(4))
        >>> M.parameters()
        (1/2, 3/4)

  virasoro_algebra()

    Return the Virasoro algebra `self` is a representation of.

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> L = lie_algebras.VirasoroAlgebra(QQ)
        >>> M = L.chargeless_representation(Integer(1)/Integer(2), Integer(3)/Integer(4))
        >>> M.virasoro_algebra() is L
        True

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

  Bases: `InfinitelyGeneratedLieAlgebra`, `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: `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

        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

    Python

        >>> from sage.all import *
        >>> L = lie_algebras.regular_vector_fields(QQ)
        >>> L.bracket_on_basis(Integer(2), -Integer(2))
        4*d[0]
        >>> L.bracket_on_basis(Integer(2), Integer(4))
        -2*d[6]
        >>> L.bracket_on_basis(Integer(4), Integer(4))
        0

  degree_on_basis(i)

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

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> L = lie_algebras.regular_vector_fields(QQ)
        >>> L.degree_on_basis(Integer(2))
        2

  lie_algebra_generators()

    Return the generators of `self` as a Lie algebra.

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> L = lie_algebras.regular_vector_fields(QQ)
        >>> L.lie_algebra_generators()
        Lazy family (generator map(i))_{i in Integer Ring}

  some_elements()

    Return some elements of `self`.

    EXAMPLES:

    Sage

        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]]

    Python

        >>> from sage.all import *
        >>> L = lie_algebras.regular_vector_fields(QQ)
        >>> 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: `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

      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

  Python

      >>> from sage.all import *
      >>> L = lie_algebras.VirasoroAlgebra(QQ)
      >>> M = L.verma_module(Integer(3), Integer(0))
      >>> d = L.basis()
      >>> v = M.highest_weight_vector()
      >>> d[Integer(3)] * v
      0
      >>> d[-Integer(3)] * v
      d[-3]*v
      >>> d[-Integer(1)] * (d[-Integer(3)] * v)
      2*d[-4]*v + d[-3]*d[-1]*v
      >>> d[Integer(2)] * (d[-Integer(1)] * (d[-Integer(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

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

  [Python]

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

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

  Sage

      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

  Python

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

  REFERENCES:

  - Wikipedia article Virasoro_algebra#Representation_theory

  class Element

    Bases: `IndexedFreeModuleElement`

  central_charge()

    Return the central charge of `self`.

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> L = lie_algebras.VirasoroAlgebra(QQ)
        >>> M = L.verma_module(Integer(3), Integer(0))
        >>> M.central_charge()
        3

  conformal_weight()

    Return the conformal weight of `self`.

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> L = lie_algebras.VirasoroAlgebra(QQ)
        >>> M = L.verma_module(Integer(3), Integer(0))
        >>> 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

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

    Python

        >>> from sage.all import *
        >>> L = lie_algebras.VirasoroAlgebra(QQ)
        >>> M = L.verma_module(-Integer(2)/Integer(7), Integer(3))
        >>> M.degree_on_basis((-Integer(3),-Integer(3),-Integer(1)))
        -7

  highest_weight_vector()

    Return the highest weight vector of `self`.

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> L = lie_algebras.VirasoroAlgebra(QQ)
        >>> M = L.verma_module(-Integer(2)/Integer(7), Integer(3))
        >>> M.highest_weight_vector()
        v

  virasoro_algebra()

    Return the Virasoro algebra `self` is a representation of.

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> L = lie_algebras.VirasoroAlgebra(QQ)
        >>> M = L.verma_module(Integer(1)/Integer(2), Integer(3)/Integer(4))
        >>> M.virasoro_algebra() is L
        True

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

  Bases: `InfinitelyGeneratedLieAlgebra`, `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

      sage: d = lie_algebras.VirasoroAlgebra(QQ)

  Python

      >>> from sage.all import *
      >>> d = lie_algebras.VirasoroAlgebra(QQ)

  REFERENCES:

  - Wikipedia article Virasoro_algebra

  class Element

    Bases: `LieAlgebraElement`

  basis()

    Return a basis of `self`.

    EXAMPLES:

    Sage

        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]

    Python

        >>> from sage.all import *
        >>> d = lie_algebras.VirasoroAlgebra(QQ)
        >>> B = d.basis(); B
        Lazy family (basis map(i))_{i in Disjoint union of
                                    Family ({'c'}, Integer Ring)}
        >>> B['c']
        c
        >>> B[Integer(3)]
        d[3]
        >>> B[-Integer(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

        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

    Python

        >>> from sage.all import *
        >>> d = lie_algebras.VirasoroAlgebra(QQ)
        >>> d.bracket_on_basis('c', Integer(2))
        0
        >>> d.bracket_on_basis(Integer(2), -Integer(2))
        4*d[0] + 1/2*c

  c()

    The central element \(c\) in `self`.

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> d = lie_algebras.VirasoroAlgebra(QQ)
        >>> d.c()
        c

  chargeless_representation(a, b)

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

    See also

    `ChargelessRepresentation`

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> L = lie_algebras.VirasoroAlgebra(QQ)
        >>> L.chargeless_representation(Integer(3), Integer(2))
        Chargeless representation (3, 2) of
         The Virasoro algebra over Rational Field

  d(i)

    Return the element \(d_i\) in `self`.

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> L = lie_algebras.VirasoroAlgebra(QQ)
        >>> L.d(Integer(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

        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

    Python

        >>> from sage.all import *
        >>> d = lie_algebras.VirasoroAlgebra(QQ)
        >>> d.degree_on_basis(Integer(2))
        2
        >>> d.c().degree()
        0
        >>> (d.c() + d.basis()[Integer(0)]).is_homogeneous()
        True

  lie_algebra_generators()

    Return the generators of `self` as a Lie algebra.

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> d = lie_algebras.VirasoroAlgebra(QQ)
        >>> d.lie_algebra_generators()
        Lazy family (generator map(i))_{i in Integer Ring}

  some_elements()

    Return some elements of `self`.

    EXAMPLES:

    Sage

        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]

    Python

        >>> from sage.all import *
        >>> d = lie_algebras.VirasoroAlgebra(QQ)
        >>> 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

        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

    Python

        >>> from sage.all import *
        >>> L = lie_algebras.VirasoroAlgebra(QQ)
        >>> L.verma_module(Integer(3), Integer(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: `FinitelyGeneratedLieAlgebra`, `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: `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

        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]

    Python

        >>> from sage.all import *
        >>> L = lie_algebras.pwitt(Zmod(Integer(5)), Integer(5))
        >>> L.bracket_on_basis(Integer(2), Integer(3))
        4*d[0]
        >>> L.bracket_on_basis(Integer(3), Integer(2))
        d[0]
        >>> L.bracket_on_basis(Integer(2), Integer(2))
        0
        >>> L.bracket_on_basis(Integer(1), Integer(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

        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

    Python

        >>> from sage.all import *
        >>> L = lie_algebras.pwitt(Zmod(Integer(5)), Integer(5))
        >>> L.degree_on_basis(Integer(7))
        2
        >>> L.degree_on_basis(Integer(2)).parent()
        Ring of integers modulo 5

  lie_algebra_generators()

    Return the generators of `self` as a Lie algebra.

    EXAMPLES:

    Sage

        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]}

    Python

        >>> from sage.all import *
        >>> L = lie_algebras.pwitt(Zmod(Integer(5)), Integer(5))
        >>> 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

        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]]

    Python

        >>> from sage.all import *
        >>> L = lie_algebras.pwitt(Zmod(Integer(5)), Integer(5))
        >>> L.some_elements()
        [d[0], d[2], d[3], d[0] + 2*d[1] + d[4]]