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{array}{r}\begin{array}{rl}{d}^{2}u& =\alpha dud+\beta u{d}^2+\gamma d,\\ d{u}^2& =\alpha udu+\beta u^{2}d+\gamma u.\end{array}\end{array}$$

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

$$\{u^i(du{)}^j{d}^k\mid i,j,k\in {\mathbf{Z}}_{\ge 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}xu(y)=\sum _{z}z,$$

where $y$ covers $x$ and $z$ covers $y$. For $r$-differential posets we have $du-ud=r1$, 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{array}{r}\begin{array}{rl}{d}^{2}u& =q(q+1)dud-q^{3}u{d}^2+rd,\\ d{u}^2& =q(q+1)udu-q^3{u}^{2}d+ru,\end{array}\end{array}$$

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

Sage Live

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

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

Sage Live

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

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

Sage Live

R.<g> = QQ[]
L = LieAlgebra(R, {('x','y'): {'z': 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])
x, y, z = L.pbw_basis().gens()
x^2*y - 2*x*y*x + y*x^2 == g*x
x*y^2 - 2*y*x*y + y^2*x == g*y
DU = algebras.DownUp(2, -1, g)
d, u = DU.gens()
d^2*u - 2*d*u*d + u*d^2 == g*d
d*u^2 - 2*u*d*u + u^2*d == g*u

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

Sage Live

DU = algebras.DownUp(0, 1, 2)
d, u = DU.gens()
d^2*u == 0*d*u*d + 1*u*d*d + 2*d
d*u^2 == 0*u*d*u + 1*u*u*d + 2*u
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(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

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}

Sage Live

DU = algebras.DownUp(2, 3, 4)
dict(DU.algebra_generators())

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

Sage Live

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

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)

Sage Live

DU = algebras.DownUp(2, 3, 4)
DU.gens()

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)

Sage Live

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

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

Sage Live

R.<a,b,g> = QQ[]
DU = algebras.DownUp(a, b, g)
I = DU.indices()
DU.product_on_basis(I([2,0,0]), I([4,0,0]))
DU.product_on_basis(I([2,0,0]), I([0,4,0]))
DU.product_on_basis(I([2,0,0]), I([0,0,4]))
DU.product_on_basis(I([0,2,0]), I([0,4,0]))
DU.product_on_basis(I([0,2,0]), I([0,0,4]))
DU.product_on_basis(I([0,0,2]), I([0,0,4]))
DU.product_on_basis(I([5,3,1]), I([1,0,4]))
DU.product_on_basis(I([0,1,0]), I([1,0,0]))
DU.product_on_basis(I([0,0,2]), I([1,0,0]))
DU.product_on_basis(I([0,0,1]), I([2,0,0]))
DU.product_on_basis(I([0,0,1]), I([0,1,0]))
DU.product_on_basis(I([0,1,0]), I([3,0,0]))
DU.product_on_basis(I([1,1,3]), I([0,1,1]))

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

Sage Live

R.<a,b,g> = QQ[]
DU = algebras.DownUp(a, b, g)
DU.verma_module(5)

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 {\mathbf{Z}}_{\ge 0}\}$ satisfying the relations

$$d\cdot v_n={\lambda }_{n-1}{v}_{n-1},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\ne 0$ for all $n\ge 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]

Sage Live

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

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)

Sage Live

d*u * v[3]
u*d * v[3]
v[3].weight()

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

Sage Live

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

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])                                 # needs sage.graphs
sage: [b.weight() for b in B]                                                   # needs sage.graphs
[(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)])                                 # needs sage.graphs
>>> [b.weight() for b in B]                                                   # needs sage.graphs
[(5, 0), (4, 1), (3, 2), (2, 3), (1, 4), (0, 5)]

Sage Live

B = crystals.Tableaux(['A',1], shape=[5])                                 # needs sage.graphs
[b.weight() for b in B]                                                   # needs sage.graphs

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

Sage

sage: # needs sage.rings.number_field
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 *
>>> # needs sage.rings.number_field
>>> 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]

Sage Live

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

class Element

Bases: IndexedFreeModuleElement

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

is_weight_vector()

Return if 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

Sage Live

DU = algebras.DownUp(2, -1, -2)
V = DU.verma_module(5)
V.zero().is_weight_vector()
B = V.basis()
[B[i].weight() for i in range(6)]
B[5].is_weight_vector()
v = B[0] + B[1]
v.is_weight_vector()
DU = algebras.DownUp(2, -1, 0)
V = DU.verma_module(0)
B = V.basis()
v = sum(i*B[i] for i in range(1,5))
v.is_weight_vector()

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

Sage Live

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

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]

Sage Live

DU = algebras.DownUp(1, 2, 3)
V = DU.verma_module(5)
V.highest_weight_vector()

weights()

Return the sequence of weights $({\lambda }_n{)}_{n=0}^{\mathrm{\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, ...]

Sage Live

R.<a,b,g> = QQ[]
DU = algebras.DownUp(a, b, g)
V = DU.verma_module(5)
V.weights()
V = DU.verma_module(0)
DU = algebras.DownUp(a, 1-a, 0)
V = DU.verma_module(0)
V.weights()

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]

Sage Live

R.<la> = QQ[]
DU = algebras.DownUp(1, 1, 0, R)
V = DU.verma_module(la)
list(V.weights()[:11])

Make live