Down-Up Algebras - Algebras

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

# Down-Up Algebras

AUTHORS:

- Travis Scrimshaw (2023-4): initial version

class sage.algebras.down_up_algebra.DownUpAlgebra(alpha, beta, gamma, base_ring)

  Bases: `CombinatorialFreeModule`

  The down-up algebra.

  Let \(R\) be a commutative ring, and let \(\alpha, \beta, \gamma \in R\). The down-up algebra is the associative unital algebra \(DU(\alpha, \beta, \gamma)\) generated by \(d, u\) with relations

  \[\begin{split}\begin{aligned} d^2u & = \alpha dud + \beta ud^2 + \gamma d, \\ du^2 & = \alpha udu + \beta u^2d + \gamma u. \end{aligned}\end{split}\]

  The down-up algebra has a PBW-type basis given by

  \[\{ u^i (du)^j d^k \mid i,j,k \in \ZZ_{\geq 0} \}.\]

  This algebra originates in the study of posets. For a poset \(P\), we define operators acting on \(R[P]\) by

  \[d(y) = \sum_x x \qquad\qquad u(y) = \sum_z z,\]

  where \(y\) covers \(x\) and \(z\) covers \(y\). For \(r\)-differential posets we have \(du - ud = r 1\), and thus it affords a representation of a `Weyl algebra`. This Weyl algebra is obtained as the quotient of \(DU(0, 1, 2r)\) by the ideal generated by \(du - ud - r\). For a \((q, r)\)-differential poset, we have the \(d\) and \(u\) operators satisfying

  \[\begin{split}\begin{aligned} d^2u & = q(q+1) dud - q^3 ud^2 + r d, \\ du^2 & = q(q+1) udu - q^3 u^2d + r u, \end{aligned}\end{split}\]

  or \(\alpha = q(q+1)\), \(\beta = -q^3\), and \(\gamma = r\). Specializing \(q = -1\) recovers the \(r\)-differential poset relation.

  Two other noteworthy quotients are:

  - the \(q\)-Weyl algebra from \(DU(0, q^2, q+1)\) by the ideal generated by \(du - qud - 1\), and

  - the quantum plane \(R_q[d, u]\), where \(du = qud\), from \(DU(2q, -q^2, 0)\) by the ideal generated by \(du - qud\).

  EXAMPLES:

  We begin by constructing the down-up algebra and perform some basic computations:

  Sage

      sage: R.<a,b,g> = QQ[]
      sage: DU = algebras.DownUp(a, b, g)
      sage: d, u = DU.gens()
      sage: d * u
      (d*u)
      sage: u * d
      u*d
      sage: d^2 * u
      b*u*d^2 + a*(d*u)*d + g*d
      sage: d * u^2
      b*u^2*d + a*u*(d*u) + g*u

  Python

      >>> from sage.all import *
      >>> R = QQ['a, b, g']; (a, b, g,) = R._first_ngens(3)
      >>> DU = algebras.DownUp(a, b, g)
      >>> d, u = DU.gens()
      >>> d * u
      (d*u)
      >>> u * d
      u*d
      >>> d**Integer(2) * u
      b*u*d^2 + a*(d*u)*d + g*d
      >>> d * u**Integer(2)
      b*u^2*d + a*u*(d*u) + g*u

  We verify some examples of Proposition 3.5 in [BR1998], which states that the \(0\)-th degree part is commutative:

  Sage

      sage: DU0 = [u^i * (d*u)^j * d^i for i,j in
      ....:        cartesian_product([range(3), range(3)])]
      sage: all(x.degree() == 0 for x in DU0)
      True
      sage: all(x * y == y * x for x, y in cartesian_product([DU0, DU0]))
      True

  [Python]

      >>> from sage.all import *
      >>> DU0 = [u**i * (d*u)**j * d**i for i,j in
      ...        cartesian_product([range(Integer(3)), range(Integer(3))])]
      >>> all(x.degree() == Integer(0) for x in DU0)
      True
      >>> all(x * y == y * x for x, y in cartesian_product([DU0, DU0]))
      True

  We verify that \(DU(2, -1, \gamma)\) can be described as the universal enveloping algebra of the 3-dimensional Lie algebra spanned by \(x,y,z\) satisfying \(z = [x, y]\), \([x, z] = \gamma x\), and \([z, y] = \gamma y\):

  Sage

      sage: R.<g> = QQ[]
      sage: L = LieAlgebra(R, {('x','y'): {'z': 1}, ('x','z'): {'x': g}, ('z','y'): {'y': g}},
      ....:                names='x,y,z')
      sage: x, y, z = L.basis()
      sage: (L[x, y], L[x, z], L[z, y])
      (z, g*x, g*y)
      sage: x, y, z = L.pbw_basis().gens()
      sage: x^2*y - 2*x*y*x + y*x^2 == g*x
      True
      sage: x*y^2 - 2*y*x*y + y^2*x == g*y
      True
      sage: DU = algebras.DownUp(2, -1, g)
      sage: d, u = DU.gens()
      sage: d^2*u - 2*d*u*d + u*d^2 == g*d
      True
      sage: d*u^2 - 2*u*d*u + u^2*d == g*u
      True

  Python

      >>> from sage.all import *
      >>> R = QQ['g']; (g,) = R._first_ngens(1)
      >>> L = LieAlgebra(R, {('x','y'): {'z': Integer(1)}, ('x','z'): {'x': g}, ('z','y'): {'y': g}},
      ...                names='x,y,z')
      >>> x, y, z = L.basis()
      >>> (L[x, y], L[x, z], L[z, y])
      (z, g*x, g*y)
      >>> x, y, z = L.pbw_basis().gens()
      >>> x**Integer(2)*y - Integer(2)*x*y*x + y*x**Integer(2) == g*x
      True
      >>> x*y**Integer(2) - Integer(2)*y*x*y + y**Integer(2)*x == g*y
      True
      >>> DU = algebras.DownUp(Integer(2), -Integer(1), g)
      >>> d, u = DU.gens()
      >>> d**Integer(2)*u - Integer(2)*d*u*d + u*d**Integer(2) == g*d
      True
      >>> d*u**Integer(2) - Integer(2)*u*d*u + u**Integer(2)*d == g*u
      True

  Young’s lattice is known to be a differential poset. Thus we can construct a representation of \(DU(0, 1, 2)\) on this poset (which gives a proof that Fomin’s `growth diagrams` are equivalent to edge local rules or shadow lines construction for `RSK()`):

  Sage

      sage: DU = algebras.DownUp(0, 1, 2)
      sage: d, u = DU.gens()
      sage: d^2*u == 0*d*u*d + 1*u*d*d + 2*d
      True
      sage: d*u^2 == 0*u*d*u + 1*u*u*d + 2*u
      True

      sage: YL = CombinatorialFreeModule(DU.base_ring(), Partitions())
      sage: def d_action(la):
      ....:     return YL.sum_of_monomials(la.remove_cell(*c) for c in la.removable_cells())
      sage: def u_action(la):
      ....:     return YL.sum_of_monomials(la.add_cell(*c) for c in la.addable_cells())
      sage: D = YL.module_morphism(on_basis=d_action, codomain=YL)
      sage: U = YL.module_morphism(on_basis=u_action, codomain=YL)
      sage: for la in PartitionsInBox(5, 5):
      ....:     b = YL.basis()[la]
      ....:     assert (D*D*U)(b) == 0*(D*U*D)(b) + 1*(U*D*D)(b) + 2*D(b)
      ....:     assert (D*U*U)(b) == 0*(U*D*U)(la) + 1*(U*U*D)(b) + 2*U(b)
      ....:     assert (D*U)(b) == (U*D)(b) + b  # the Weyl algebra relation

  [Python]

      >>> from sage.all import *
      >>> DU = algebras.DownUp(Integer(0), Integer(1), Integer(2))
      >>> d, u = DU.gens()
      >>> d**Integer(2)*u == Integer(0)*d*u*d + Integer(1)*u*d*d + Integer(2)*d
      True
      >>> d*u**Integer(2) == Integer(0)*u*d*u + Integer(1)*u*u*d + Integer(2)*u
      True

      >>> YL = CombinatorialFreeModule(DU.base_ring(), Partitions())
      >>> def d_action(la):
      ...     return YL.sum_of_monomials(la.remove_cell(*c) for c in la.removable_cells())
      >>> def u_action(la):
      ...     return YL.sum_of_monomials(la.add_cell(*c) for c in la.addable_cells())
      >>> D = YL.module_morphism(on_basis=d_action, codomain=YL)
      >>> U = YL.module_morphism(on_basis=u_action, codomain=YL)
      >>> for la in PartitionsInBox(Integer(5), Integer(5)):
      ...     b = YL.basis()[la]
      ...     assert (D*D*U)(b) == Integer(0)*(D*U*D)(b) + Integer(1)*(U*D*D)(b) + Integer(2)*D(b)
      ...     assert (D*U*U)(b) == Integer(0)*(U*D*U)(la) + Integer(1)*(U*U*D)(b) + Integer(2)*U(b)
      ...     assert (D*U)(b) == (U*D)(b) + b  # the Weyl algebra relation

  Todo

  Implement the homogenized version.

  REFERENCES:

  - [BR1998]

  - [CM2000]

  algebra_generators()

    Return the algebra generators of `self`.

    EXAMPLES:

    Sage

        sage: DU = algebras.DownUp(2, 3, 4)
        sage: dict(DU.algebra_generators())
        {'d': d, 'u': u}

    Python

        >>> from sage.all import *
        >>> DU = algebras.DownUp(Integer(2), Integer(3), Integer(4))
        >>> dict(DU.algebra_generators())
        {'d': d, 'u': u}

  degree_on_basis(m)

    Return the degree of the basis element indexed by `m`.

    EXAMPLES:

    Sage

        sage: R.<a,b,g> = QQ[]
        sage: DU = algebras.DownUp(a, b, g)
        sage: I = DU.indices()
        sage: DU.degree_on_basis(I([0, 3, 2]))
        -2
        sage: DU.degree_on_basis(I([2, 3, 0]))
        2
        sage: DU.degree_on_basis(I([2, 0, 3]))
        -1
        sage: DU.degree_on_basis(I([3, 10, 3]))
        0

    Python

        >>> from sage.all import *
        >>> R = QQ['a, b, g']; (a, b, g,) = R._first_ngens(3)
        >>> DU = algebras.DownUp(a, b, g)
        >>> I = DU.indices()
        >>> DU.degree_on_basis(I([Integer(0), Integer(3), Integer(2)]))
        -2
        >>> DU.degree_on_basis(I([Integer(2), Integer(3), Integer(0)]))
        2
        >>> DU.degree_on_basis(I([Integer(2), Integer(0), Integer(3)]))
        -1
        >>> DU.degree_on_basis(I([Integer(3), Integer(10), Integer(3)]))
        0

  gens()

    Return the generators of `self`.

    EXAMPLES:

    Sage

        sage: DU = algebras.DownUp(2, 3, 4)
        sage: DU.gens()
        (d, u)

    Python

        >>> from sage.all import *
        >>> DU = algebras.DownUp(Integer(2), Integer(3), Integer(4))
        >>> DU.gens()
        (d, u)

  one_basis()

    Return the index of the basis element of \(1\).

    EXAMPLES:

    Sage

        sage: DU = algebras.DownUp(2, 3, 4)
        sage: DU.one_basis()
        (0, 0, 0)

    Python

        >>> from sage.all import *
        >>> DU = algebras.DownUp(Integer(2), Integer(3), Integer(4))
        >>> DU.one_basis()
        (0, 0, 0)

  product_on_basis(m1, m2)

    Return the product of the basis elements indexed by `m1` and `m2`.

    EXAMPLES:

    Sage

        sage: R.<a,b,g> = QQ[]
        sage: DU = algebras.DownUp(a, b, g)
        sage: I = DU.indices()
        sage: DU.product_on_basis(I([2,0,0]), I([4,0,0]))
        u^6
        sage: DU.product_on_basis(I([2,0,0]), I([0,4,0]))
        u^2*(d*u)^4
        sage: DU.product_on_basis(I([2,0,0]), I([0,0,4]))
        u^2*d^4
        sage: DU.product_on_basis(I([0,2,0]), I([0,4,0]))
        (d*u)^6
        sage: DU.product_on_basis(I([0,2,0]), I([0,0,4]))
        (d*u)^2*d^4
        sage: DU.product_on_basis(I([0,0,2]), I([0,0,4]))
        d^6
        sage: DU.product_on_basis(I([5,3,1]), I([1,0,4]))
        u^5*(d*u)^4*d^4

        sage: DU.product_on_basis(I([0,1,0]), I([1,0,0]))
        b*u^2*d + a*u*(d*u) + g*u
        sage: DU.product_on_basis(I([0,0,2]), I([1,0,0]))
        b*u*d^2 + a*(d*u)*d + g*d
        sage: DU.product_on_basis(I([0,0,1]), I([2,0,0]))
        b*u^2*d + a*u*(d*u) + g*u
        sage: DU.product_on_basis(I([0,0,1]), I([0,1,0]))
        b*u*d^2 + a*(d*u)*d + g*d

        sage: DU.product_on_basis(I([0,1,0]), I([3,0,0]))
        (a^2*b+b^2)*u^4*d + (a^3+2*a*b)*u^3*(d*u) + (a^2*g+a*g+b*g+g)*u^3
        sage: DU.product_on_basis(I([1,1,3]), I([0,1,1]))
        (a^2*b^2+b^3)*u^3*d^6 + (a^3*b+a*b^2)*u^2*(d*u)*d^5 + (a^2*b*g+b^2*g)*u^2*d^5
         + (a^3+2*a*b)*u*(d*u)^2*d^4 + (a^2*g+a*g+b*g+g)*u*(d*u)*d^4

    Python

        >>> from sage.all import *
        >>> R = QQ['a, b, g']; (a, b, g,) = R._first_ngens(3)
        >>> DU = algebras.DownUp(a, b, g)
        >>> I = DU.indices()
        >>> DU.product_on_basis(I([Integer(2),Integer(0),Integer(0)]), I([Integer(4),Integer(0),Integer(0)]))
        u^6
        >>> DU.product_on_basis(I([Integer(2),Integer(0),Integer(0)]), I([Integer(0),Integer(4),Integer(0)]))
        u^2*(d*u)^4
        >>> DU.product_on_basis(I([Integer(2),Integer(0),Integer(0)]), I([Integer(0),Integer(0),Integer(4)]))
        u^2*d^4
        >>> DU.product_on_basis(I([Integer(0),Integer(2),Integer(0)]), I([Integer(0),Integer(4),Integer(0)]))
        (d*u)^6
        >>> DU.product_on_basis(I([Integer(0),Integer(2),Integer(0)]), I([Integer(0),Integer(0),Integer(4)]))
        (d*u)^2*d^4
        >>> DU.product_on_basis(I([Integer(0),Integer(0),Integer(2)]), I([Integer(0),Integer(0),Integer(4)]))
        d^6
        >>> DU.product_on_basis(I([Integer(5),Integer(3),Integer(1)]), I([Integer(1),Integer(0),Integer(4)]))
        u^5*(d*u)^4*d^4

        >>> DU.product_on_basis(I([Integer(0),Integer(1),Integer(0)]), I([Integer(1),Integer(0),Integer(0)]))
        b*u^2*d + a*u*(d*u) + g*u
        >>> DU.product_on_basis(I([Integer(0),Integer(0),Integer(2)]), I([Integer(1),Integer(0),Integer(0)]))
        b*u*d^2 + a*(d*u)*d + g*d
        >>> DU.product_on_basis(I([Integer(0),Integer(0),Integer(1)]), I([Integer(2),Integer(0),Integer(0)]))
        b*u^2*d + a*u*(d*u) + g*u
        >>> DU.product_on_basis(I([Integer(0),Integer(0),Integer(1)]), I([Integer(0),Integer(1),Integer(0)]))
        b*u*d^2 + a*(d*u)*d + g*d

        >>> DU.product_on_basis(I([Integer(0),Integer(1),Integer(0)]), I([Integer(3),Integer(0),Integer(0)]))
        (a^2*b+b^2)*u^4*d + (a^3+2*a*b)*u^3*(d*u) + (a^2*g+a*g+b*g+g)*u^3
        >>> DU.product_on_basis(I([Integer(1),Integer(1),Integer(3)]), I([Integer(0),Integer(1),Integer(1)]))
        (a^2*b^2+b^3)*u^3*d^6 + (a^3*b+a*b^2)*u^2*(d*u)*d^5 + (a^2*b*g+b^2*g)*u^2*d^5
         + (a^3+2*a*b)*u*(d*u)^2*d^4 + (a^2*g+a*g+b*g+g)*u*(d*u)*d^4

  verma_module(la)

    Return the `Verma module` \(V(\lambda)\) of `self`.

    EXAMPLES:

    Sage

        sage: R.<a,b,g> = QQ[]
        sage: DU = algebras.DownUp(a, b, g)
        sage: DU.verma_module(5)
        Verma module of weight 5 of Down-Up algebra with parameters (a, b, g)
         over Multivariate Polynomial Ring in a, b, g over Rational Field

    Python

        >>> from sage.all import *
        >>> R = QQ['a, b, g']; (a, b, g,) = R._first_ngens(3)
        >>> DU = algebras.DownUp(a, b, g)
        >>> DU.verma_module(Integer(5))
        Verma module of weight 5 of Down-Up algebra with parameters (a, b, g)
         over Multivariate Polynomial Ring in a, b, g over Rational Field

class sage.algebras.down_up_algebra.VermaModule(DU, la)

  Bases: `CombinatorialFreeModule`

  The Verma module \(V(\lambda)\) of a down-up algebra.

  The Verma module \(V(\lambda)\) for the down-up algebra generated by \(d, u\) is the span of \(\{v_n \mid n \in \ZZ_{\geq 0} \}\) satisfying the relations

  \[d \cdot v_n = \lambda_{n-1} v_{n-1}, \qquad\qquad u \cdot v_n = v_{n+1},\]

  where \(\lambda_n = \alpha \lambda_{n-1} + \beta \lambda_{n-2} + \gamma\) and we set \(\lambda_0 = \lambda\) and \(\lambda_{-1} = 0\).

  By Proposition 2.4 in [BR1998], \(V(\lambda)\) is simple if and only if \(\lambda_n \neq 0\) for all \(n \geq 0\). Moreover, a maximal submodule is spanned by \(\{ v_n \mid n > m \}\), where \(m\) is the minimal index such that \(\lambda_m = 0\). Moreover, this is unique unless \(\gamma = \lambda = 0\).

  EXAMPLES:

  Sage

      sage: R.<a,b> = QQ[]
      sage: DU = algebras.DownUp(0, b, 1)
      sage: d, u = DU.gens()
      sage: V = DU.verma_module(a)
      sage: list(V.weights()[:6])
      [a, 1, a*b + 1, b + 1, a*b^2 + b + 1, b^2 + b + 1]
      sage: v = V.basis()
      sage: d^2 * v[2]
      a*v[0]
      sage: d * (d * v[2])
      a*v[0]

  Python

      >>> from sage.all import *
      >>> R = QQ['a, b']; (a, b,) = R._first_ngens(2)
      >>> DU = algebras.DownUp(Integer(0), b, Integer(1))
      >>> d, u = DU.gens()
      >>> V = DU.verma_module(a)
      >>> list(V.weights()[:Integer(6)])
      [a, 1, a*b + 1, b + 1, a*b^2 + b + 1, b^2 + b + 1]
      >>> v = V.basis()
      >>> d**Integer(2) * v[Integer(2)]
      a*v[0]
      >>> d * (d * v[Integer(2)])
      a*v[0]

  The weight is computed by looking at the scalars associated to the action of \(du\) and \(ud\):

  Sage

      sage: d*u * v[3]
      (b+1)*v[3]
      sage: u*d * v[3]
      (a*b+1)*v[3]
      sage: v[3].weight()
      (b + 1, a*b + 1)

  [Python]

      >>> from sage.all import *
      >>> d*u * v[Integer(3)]
      (b+1)*v[3]
      >>> u*d * v[Integer(3)]
      (a*b+1)*v[3]
      >>> v[Integer(3)].weight()
      (b + 1, a*b + 1)

  An \(U(\mathfrak{sl}_2)\) example:

  Sage

      sage: DU = algebras.DownUp(2, -1, -2)
      sage: d, u = DU.gens()
      sage: V = DU.verma_module(5)
      sage: list(V.weights()[:10])
      [5, 8, 9, 8, 5, 0, -7, -16, -27, -40]
      sage: v6 = V.basis()[6]
      sage: d * v6
      0
      sage: [V.basis()[i].weight() for i in range(6)]
      [(5, 0), (8, 5), (9, 8), (8, 9), (5, 8), (0, 5)]

  Python

      >>> from sage.all import *
      >>> DU = algebras.DownUp(Integer(2), -Integer(1), -Integer(2))
      >>> d, u = DU.gens()
      >>> V = DU.verma_module(Integer(5))
      >>> list(V.weights()[:Integer(10)])
      [5, 8, 9, 8, 5, 0, -7, -16, -27, -40]
      >>> v6 = V.basis()[Integer(6)]
      >>> d * v6
      0
      >>> [V.basis()[i].weight() for i in range(Integer(6))]
      [(5, 0), (8, 5), (9, 8), (8, 9), (5, 8), (0, 5)]

  Note that these are the same \(\mathfrak{sl}_2\) weights from the usual construction of the irreducible representation \(V(5)\) (but they are different as \(\mathfrak{gl}_2\) weights):

  Sage

      sage: B = crystals.Tableaux(['A',1], shape=[5])
      sage: [b.weight() for b in B]
      [(5, 0), (4, 1), (3, 2), (2, 3), (1, 4), (0, 5)]

  [Python]

      >>> from sage.all import *
      >>> B = crystals.Tableaux(['A',Integer(1)], shape=[Integer(5)])
      >>> [b.weight() for b in B]
      [(5, 0), (4, 1), (3, 2), (2, 3), (1, 4), (0, 5)]

  An example with periodic weights (see Theorem 2.13 of [BR1998]):

  Sage

      sage: k.<z6> = CyclotomicField(6)
      sage: al = z6 + 1
      sage: (al - 1)^6 == 1
      True
      sage: DU = algebras.DownUp(al, 1-al, 0)
      sage: V = DU.verma_module(5)
      sage: list(V.weights()[:8])
      [5, 5*z6 + 5, 10*z6, 10*z6 - 5, 5*z6 - 5, 0, 5, 5*z6 + 5]

  Python

      >>> from sage.all import *
      >>> k = CyclotomicField(Integer(6), names=('z6',)); (z6,) = k._first_ngens(1)
      >>> al = z6 + Integer(1)
      >>> (al - Integer(1))**Integer(6) == Integer(1)
      True
      >>> DU = algebras.DownUp(al, Integer(1)-al, Integer(0))
      >>> V = DU.verma_module(Integer(5))
      >>> list(V.weights()[:Integer(8)])
      [5, 5*z6 + 5, 10*z6, 10*z6 - 5, 5*z6 - 5, 0, 5, 5*z6 + 5]

  class Element

    Bases: `IndexedFreeModuleElement`

    An element of a Verma module of a down-up algebra.

    is_weight_vector()

      Return whether `self` is a weight vector.

      EXAMPLES:

      Sage

          sage: DU = algebras.DownUp(2, -1, -2)
          sage: V = DU.verma_module(5)
          sage: V.zero().is_weight_vector()
          False
          sage: B = V.basis()
          sage: [B[i].weight() for i in range(6)]
          [(5, 0), (8, 5), (9, 8), (8, 9), (5, 8), (0, 5)]
          sage: B[5].is_weight_vector()
          True
          sage: v = B[0] + B[1]
          sage: v.is_weight_vector()
          False

          sage: DU = algebras.DownUp(2, -1, 0)
          sage: V = DU.verma_module(0)
          sage: B = V.basis()
          sage: v = sum(i*B[i] for i in range(1,5))
          sage: v.is_weight_vector()
          True

      Python

          >>> from sage.all import *
          >>> DU = algebras.DownUp(Integer(2), -Integer(1), -Integer(2))
          >>> V = DU.verma_module(Integer(5))
          >>> V.zero().is_weight_vector()
          False
          >>> B = V.basis()
          >>> [B[i].weight() for i in range(Integer(6))]
          [(5, 0), (8, 5), (9, 8), (8, 9), (5, 8), (0, 5)]
          >>> B[Integer(5)].is_weight_vector()
          True
          >>> v = B[Integer(0)] + B[Integer(1)]
          >>> v.is_weight_vector()
          False

          >>> DU = algebras.DownUp(Integer(2), -Integer(1), Integer(0))
          >>> V = DU.verma_module(Integer(0))
          >>> B = V.basis()
          >>> v = sum(i*B[i] for i in range(Integer(1),Integer(5)))
          >>> v.is_weight_vector()
          True

    weight()

      Return the weight of `self`.

      For \(v_n\), this is the vector with the pair \((\lambda_n, \lambda_{n-1})\).

      EXAMPLES:

      Sage

          sage: R.<a,b,g> = QQ[]
          sage: DU = algebras.DownUp(a, b, g)
          sage: V = DU.verma_module(5)
          sage: B = V.basis()
          sage: B[0].weight()
          (5, 0)
          sage: B[1].weight()
          (5*a + g, 5)
          sage: B[2].weight()
          (5*a^2 + a*g + 5*b + g, 5*a + g)

          sage: V.zero().weight()
          Traceback (most recent call last):
          ...
          ValueError: the zero element does not have well-defined weight
          sage: (B[0] + B[1]).weight()
          Traceback (most recent call last):
          ...
          ValueError: not a weight vector

      Python

          >>> from sage.all import *
          >>> R = QQ['a, b, g']; (a, b, g,) = R._first_ngens(3)
          >>> DU = algebras.DownUp(a, b, g)
          >>> V = DU.verma_module(Integer(5))
          >>> B = V.basis()
          >>> B[Integer(0)].weight()
          (5, 0)
          >>> B[Integer(1)].weight()
          (5*a + g, 5)
          >>> B[Integer(2)].weight()
          (5*a^2 + a*g + 5*b + g, 5*a + g)

          >>> V.zero().weight()
          Traceback (most recent call last):
          ...
          ValueError: the zero element does not have well-defined weight
          >>> (B[Integer(0)] + B[Integer(1)]).weight()
          Traceback (most recent call last):
          ...
          ValueError: not a weight vector

  highest_weight_vector()

    Return the highest weight vector of `self` that generates `self` as a down-up module.

    EXAMPLES:

    Sage

        sage: DU = algebras.DownUp(1, 2, 3)
        sage: V = DU.verma_module(5)
        sage: V.highest_weight_vector()
        v[0]

    Python

        >>> from sage.all import *
        >>> DU = algebras.DownUp(Integer(1), Integer(2), Integer(3))
        >>> V = DU.verma_module(Integer(5))
        >>> V.highest_weight_vector()
        v[0]

  weights()

    Return the sequence of weights \((\lambda_n)_{n=0}^{\infty}\).

    EXAMPLES:

    Sage

        sage: R.<a,b,g> = QQ[]
        sage: DU = algebras.DownUp(a, b, g)
        sage: V = DU.verma_module(5)
        sage: V.weights()
        lazy list [5, 5*a + g, 5*a^2 + a*g + 5*b + g, ...]

        sage: V = DU.verma_module(0)
        sage: DU = algebras.DownUp(a, 1-a, 0)
        sage: V = DU.verma_module(0)
        sage: V.weights()
        lazy list [0, 0, 0, ...]

    Python

        >>> from sage.all import *
        >>> R = QQ['a, b, g']; (a, b, g,) = R._first_ngens(3)
        >>> DU = algebras.DownUp(a, b, g)
        >>> V = DU.verma_module(Integer(5))
        >>> V.weights()
        lazy list [5, 5*a + g, 5*a^2 + a*g + 5*b + g, ...]

        >>> V = DU.verma_module(Integer(0))
        >>> DU = algebras.DownUp(a, Integer(1)-a, Integer(0))
        >>> V = DU.verma_module(Integer(0))
        >>> V.weights()
        lazy list [0, 0, 0, ...]

    We reproduce the Fibonacci numbers example from [BR1998]:

    Sage

        sage: R.<la> = QQ[]
        sage: DU = algebras.DownUp(1, 1, 0, R)
        sage: V = DU.verma_module(la)
        sage: list(V.weights()[:11])
        [la, la, 2*la, 3*la, 5*la, 8*la, 13*la, 21*la, 34*la, 55*la, 89*la]

    [Python]

        >>> from sage.all import *
        >>> R = QQ['la']; (la,) = R._first_ngens(1)
        >>> DU = algebras.DownUp(Integer(1), Integer(1), Integer(0), R)
        >>> V = DU.verma_module(la)
        >>> list(V.weights()[:Integer(11)])
        [la, la, 2*la, 3*la, 5*la, 8*la, 13*la, 21*la, 34*la, 55*la, 89*la]