Verma Modules

AUTHORS:

• Travis Scrimshaw (2017-06-30): Initial version

Todo

Implement a sage.categories.pushout.ConstructionFunctor and return as the construction().

class sage.algebras.lie_algebras.verma_module.ModulePrinting(vector_name='v')

Bases: object

Helper mixin class for printing the module vectors.

class sage.algebras.lie_algebras.verma_module.VermaModule(g, weight, basis_key=None, prefix='f', **kwds)

Bases: ModulePrinting, CombinatorialFreeModule

A Verma module.

Let $\lambda$ be a weight and $\mathfrak{g}$ be a Kac–Moody Lie algebra with a fixed Borel subalgebra $\mathfrak{b}=\mathfrak{h}\oplus {\mathfrak{g}}^{+}$. The Verma module $M_{\lambda }$ is a $U(\mathfrak{g})$-module given by

$$M_{\lambda }:=U(\mathfrak{g}){\otimes }_{U(\mathfrak{b})}{F}_{\lambda },$$

where $F_{\lambda }$ is the $U(\mathfrak{b})$ module such that $h\in U(\mathfrak{h})$ acts as multiplication by $⟨\lambda ,h⟩$ and $U({\mathfrak{g}}^{+})F_{\lambda }=0$.

INPUT:

• g – a Lie algebra

• weight – a weight

EXAMPLES:

Sage

sage: L = lie_algebras.sl(QQ, 3)
sage: La = L.cartan_type().root_system().weight_lattice().fundamental_weights()
sage: M = L.verma_module(2*La[1] + 3*La[2])
sage: pbw = M.pbw_basis()
sage: E1,E2,F1,F2,H1,H2 = [pbw(g) for g in L.gens()]
sage: v = M.highest_weight_vector()
sage: x = F2^3 * F1 * v
sage: x
f[-alpha[2]]^3*f[-alpha[1]]*v[2*Lambda[1] + 3*Lambda[2]]
sage: F1 * x
f[-alpha[2]]^3*f[-alpha[1]]^2*v[2*Lambda[1] + 3*Lambda[2]]
 + 3*f[-alpha[2]]^2*f[-alpha[1]]*f[-alpha[1] - alpha[2]]*v[2*Lambda[1] + 3*Lambda[2]]
sage: E1 * x
2*f[-alpha[2]]^3*v[2*Lambda[1] + 3*Lambda[2]]
sage: H1 * x
3*f[-alpha[2]]^3*f[-alpha[1]]*v[2*Lambda[1] + 3*Lambda[2]]
sage: H2 * x
-2*f[-alpha[2]]^3*f[-alpha[1]]*v[2*Lambda[1] + 3*Lambda[2]]

Python

>>> from sage.all import *
>>> L = lie_algebras.sl(QQ, Integer(3))
>>> La = L.cartan_type().root_system().weight_lattice().fundamental_weights()
>>> M = L.verma_module(Integer(2)*La[Integer(1)] + Integer(3)*La[Integer(2)])
>>> pbw = M.pbw_basis()
>>> E1,E2,F1,F2,H1,H2 = [pbw(g) for g in L.gens()]
>>> v = M.highest_weight_vector()
>>> x = F2**Integer(3) * F1 * v
>>> x
f[-alpha[2]]^3*f[-alpha[1]]*v[2*Lambda[1] + 3*Lambda[2]]
>>> F1 * x
f[-alpha[2]]^3*f[-alpha[1]]^2*v[2*Lambda[1] + 3*Lambda[2]]
 + 3*f[-alpha[2]]^2*f[-alpha[1]]*f[-alpha[1] - alpha[2]]*v[2*Lambda[1] + 3*Lambda[2]]
>>> E1 * x
2*f[-alpha[2]]^3*v[2*Lambda[1] + 3*Lambda[2]]
>>> H1 * x
3*f[-alpha[2]]^3*f[-alpha[1]]*v[2*Lambda[1] + 3*Lambda[2]]
>>> H2 * x
-2*f[-alpha[2]]^3*f[-alpha[1]]*v[2*Lambda[1] + 3*Lambda[2]]

Sage Live

L = lie_algebras.sl(QQ, 3)
La = L.cartan_type().root_system().weight_lattice().fundamental_weights()
M = L.verma_module(2*La[1] + 3*La[2])
pbw = M.pbw_basis()
E1,E2,F1,F2,H1,H2 = [pbw(g) for g in L.gens()]
v = M.highest_weight_vector()
x = F2^3 * F1 * v
x
F1 * x
E1 * x
H1 * x
H2 * x

REFERENCES:

• Wikipedia article Verma_module

class Element

Bases: IndexedFreeModuleElement

contravariant_form(x, y)

Return the contravariant form of x and y.

Let $C(x,y)$ denote the (universal) contravariant form on $U(\mathfrak{g})$. Then the contravariant form on $M(\lambda )$ is given by evaluating $C(x,y)\in U(\mathfrak{h})$ at $\lambda$.

EXAMPLES:

Sage

sage: g = LieAlgebra(QQ, cartan_type=['A', 1])
sage: La = g.cartan_type().root_system().weight_lattice().fundamental_weights()
sage: M = g.verma_module(2*La[1])
sage: U = M.pbw_basis()
sage: v = M.highest_weight_vector()
sage: e, h, f = U.algebra_generators()
sage: elts = [f^k * v for k in range(8)]; elts
[v[2*Lambda[1]], f[-alpha[1]]*v[2*Lambda[1]],
 f[-alpha[1]]^2*v[2*Lambda[1]], f[-alpha[1]]^3*v[2*Lambda[1]],
 f[-alpha[1]]^4*v[2*Lambda[1]], f[-alpha[1]]^5*v[2*Lambda[1]],
 f[-alpha[1]]^6*v[2*Lambda[1]], f[-alpha[1]]^7*v[2*Lambda[1]]]
sage: matrix([[M.contravariant_form(x, y) for x in elts] for y in elts])
[1 0 0 0 0 0 0 0]
[0 2 0 0 0 0 0 0]
[0 0 4 0 0 0 0 0]
[0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0]

Python

>>> from sage.all import *
>>> g = LieAlgebra(QQ, cartan_type=['A', Integer(1)])
>>> La = g.cartan_type().root_system().weight_lattice().fundamental_weights()
>>> M = g.verma_module(Integer(2)*La[Integer(1)])
>>> U = M.pbw_basis()
>>> v = M.highest_weight_vector()
>>> e, h, f = U.algebra_generators()
>>> elts = [f**k * v for k in range(Integer(8))]; elts
[v[2*Lambda[1]], f[-alpha[1]]*v[2*Lambda[1]],
 f[-alpha[1]]^2*v[2*Lambda[1]], f[-alpha[1]]^3*v[2*Lambda[1]],
 f[-alpha[1]]^4*v[2*Lambda[1]], f[-alpha[1]]^5*v[2*Lambda[1]],
 f[-alpha[1]]^6*v[2*Lambda[1]], f[-alpha[1]]^7*v[2*Lambda[1]]]
>>> matrix([[M.contravariant_form(x, y) for x in elts] for y in elts])
[1 0 0 0 0 0 0 0]
[0 2 0 0 0 0 0 0]
[0 0 4 0 0 0 0 0]
[0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0]

Sage Live

g = LieAlgebra(QQ, cartan_type=['A', 1])
La = g.cartan_type().root_system().weight_lattice().fundamental_weights()
M = g.verma_module(2*La[1])
U = M.pbw_basis()
v = M.highest_weight_vector()
e, h, f = U.algebra_generators()
elts = [f^k * v for k in range(8)]; elts
matrix([[M.contravariant_form(x, y) for x in elts] for y in elts])

degree_on_basis(m)

Return the degree (or weight) of the basis element indexed by m.

EXAMPLES:

Sage

sage: L = lie_algebras.sl(QQ, 3)
sage: La = L.cartan_type().root_system().weight_lattice().fundamental_weights()
sage: M = L.verma_module(2*La[1] + 3*La[2])
sage: v = M.highest_weight_vector()
sage: M.degree_on_basis(v.leading_support())
2*Lambda[1] + 3*Lambda[2]

sage: pbw = M.pbw_basis()
sage: G = list(pbw.gens())
sage: f1, f2 = L.f()
sage: x = pbw(f1.bracket(f2)) * pbw(f1) * v
sage: x.degree()
-Lambda[1] + 3*Lambda[2]

Python

>>> from sage.all import *
>>> L = lie_algebras.sl(QQ, Integer(3))
>>> La = L.cartan_type().root_system().weight_lattice().fundamental_weights()
>>> M = L.verma_module(Integer(2)*La[Integer(1)] + Integer(3)*La[Integer(2)])
>>> v = M.highest_weight_vector()
>>> M.degree_on_basis(v.leading_support())
2*Lambda[1] + 3*Lambda[2]

>>> pbw = M.pbw_basis()
>>> G = list(pbw.gens())
>>> f1, f2 = L.f()
>>> x = pbw(f1.bracket(f2)) * pbw(f1) * v
>>> x.degree()
-Lambda[1] + 3*Lambda[2]

Sage Live

L = lie_algebras.sl(QQ, 3)
La = L.cartan_type().root_system().weight_lattice().fundamental_weights()
M = L.verma_module(2*La[1] + 3*La[2])
v = M.highest_weight_vector()
M.degree_on_basis(v.leading_support())
pbw = M.pbw_basis()
G = list(pbw.gens())
f1, f2 = L.f()
x = pbw(f1.bracket(f2)) * pbw(f1) * v
x.degree()

dual()

Return the dual module $M(\lambda {)}^{\vee }$ in Category $\mathcal{O}$.

EXAMPLES:

Sage

sage: L = lie_algebras.sl(QQ, 2)
sage: La = L.cartan_type().root_system().weight_space().fundamental_weights()
sage: M = L.verma_module(2*La[1])
sage: Mc = M.dual()

sage: Mp = L.verma_module(-2*La[1])
sage: Mp.dual() is Mp
True

Python

>>> from sage.all import *
>>> L = lie_algebras.sl(QQ, Integer(2))
>>> La = L.cartan_type().root_system().weight_space().fundamental_weights()
>>> M = L.verma_module(Integer(2)*La[Integer(1)])
>>> Mc = M.dual()

>>> Mp = L.verma_module(-Integer(2)*La[Integer(1)])
>>> Mp.dual() is Mp
True

Sage Live

L = lie_algebras.sl(QQ, 2)
La = L.cartan_type().root_system().weight_space().fundamental_weights()
M = L.verma_module(2*La[1])
Mc = M.dual()
Mp = L.verma_module(-2*La[1])
Mp.dual() is Mp

gens()

Return the generators of self as a $U(\mathfrak{g})$-module.

EXAMPLES:

Sage

sage: L = lie_algebras.sp(QQ, 6)
sage: La = L.cartan_type().root_system().weight_lattice().fundamental_weights()
sage: M = L.verma_module(La[1] - 3*La[2])
sage: M.gens()
(v[Lambda[1] - 3*Lambda[2]],)

Python

>>> from sage.all import *
>>> L = lie_algebras.sp(QQ, Integer(6))
>>> La = L.cartan_type().root_system().weight_lattice().fundamental_weights()
>>> M = L.verma_module(La[Integer(1)] - Integer(3)*La[Integer(2)])
>>> M.gens()
(v[Lambda[1] - 3*Lambda[2]],)

Sage Live

L = lie_algebras.sp(QQ, 6)
La = L.cartan_type().root_system().weight_lattice().fundamental_weights()
M = L.verma_module(La[1] - 3*La[2])
M.gens()

highest_weight()

Return the highest weight of self.

EXAMPLES:

Sage

sage: L = lie_algebras.so(QQ, 7)
sage: La = L.cartan_type().root_system().weight_space().fundamental_weights()
sage: M = L.verma_module(4*La[1] - 3/2*La[2])
sage: M.highest_weight()
4*Lambda[1] - 3/2*Lambda[2]

Python

>>> from sage.all import *
>>> L = lie_algebras.so(QQ, Integer(7))
>>> La = L.cartan_type().root_system().weight_space().fundamental_weights()
>>> M = L.verma_module(Integer(4)*La[Integer(1)] - Integer(3)/Integer(2)*La[Integer(2)])
>>> M.highest_weight()
4*Lambda[1] - 3/2*Lambda[2]

Sage Live

L = lie_algebras.so(QQ, 7)
La = L.cartan_type().root_system().weight_space().fundamental_weights()
M = L.verma_module(4*La[1] - 3/2*La[2])
M.highest_weight()

highest_weight_vector()

Return the highest weight vector of self.

EXAMPLES:

Sage

sage: L = lie_algebras.sp(QQ, 6)
sage: La = L.cartan_type().root_system().weight_lattice().fundamental_weights()
sage: M = L.verma_module(La[1] - 3*La[2])
sage: M.highest_weight_vector()
v[Lambda[1] - 3*Lambda[2]]

Python

>>> from sage.all import *
>>> L = lie_algebras.sp(QQ, Integer(6))
>>> La = L.cartan_type().root_system().weight_lattice().fundamental_weights()
>>> M = L.verma_module(La[Integer(1)] - Integer(3)*La[Integer(2)])
>>> M.highest_weight_vector()
v[Lambda[1] - 3*Lambda[2]]

Sage Live

L = lie_algebras.sp(QQ, 6)
La = L.cartan_type().root_system().weight_lattice().fundamental_weights()
M = L.verma_module(La[1] - 3*La[2])
M.highest_weight_vector()

homogeneous_component_basis(d)

Return a basis for the d-th homogeneous component of self.

EXAMPLES:

Sage

sage: L = lie_algebras.sl(QQ, 3)
sage: P = L.cartan_type().root_system().weight_lattice()
sage: La = P.fundamental_weights()
sage: al = P.simple_roots()
sage: mu = 2*La[1] + 3*La[2]
sage: M = L.verma_module(mu)
sage: M.homogeneous_component_basis(mu - al[2])
[f[-alpha[2]]*v[2*Lambda[1] + 3*Lambda[2]]]
sage: M.homogeneous_component_basis(mu - 3*al[2])
[f[-alpha[2]]^3*v[2*Lambda[1] + 3*Lambda[2]]]
sage: M.homogeneous_component_basis(mu - 3*al[2] - 2*al[1])
[f[-alpha[2]]*f[-alpha[1] - alpha[2]]^2*v[2*Lambda[1] + 3*Lambda[2]],
 f[-alpha[2]]^2*f[-alpha[1]]*f[-alpha[1] - alpha[2]]*v[2*Lambda[1] + 3*Lambda[2]],
 f[-alpha[2]]^3*f[-alpha[1]]^2*v[2*Lambda[1] + 3*Lambda[2]]]
sage: M.homogeneous_component_basis(mu - La[1])
Family ()

Python

>>> from sage.all import *
>>> L = lie_algebras.sl(QQ, Integer(3))
>>> P = L.cartan_type().root_system().weight_lattice()
>>> La = P.fundamental_weights()
>>> al = P.simple_roots()
>>> mu = Integer(2)*La[Integer(1)] + Integer(3)*La[Integer(2)]
>>> M = L.verma_module(mu)
>>> M.homogeneous_component_basis(mu - al[Integer(2)])
[f[-alpha[2]]*v[2*Lambda[1] + 3*Lambda[2]]]
>>> M.homogeneous_component_basis(mu - Integer(3)*al[Integer(2)])
[f[-alpha[2]]^3*v[2*Lambda[1] + 3*Lambda[2]]]
>>> M.homogeneous_component_basis(mu - Integer(3)*al[Integer(2)] - Integer(2)*al[Integer(1)])
[f[-alpha[2]]*f[-alpha[1] - alpha[2]]^2*v[2*Lambda[1] + 3*Lambda[2]],
 f[-alpha[2]]^2*f[-alpha[1]]*f[-alpha[1] - alpha[2]]*v[2*Lambda[1] + 3*Lambda[2]],
 f[-alpha[2]]^3*f[-alpha[1]]^2*v[2*Lambda[1] + 3*Lambda[2]]]
>>> M.homogeneous_component_basis(mu - La[Integer(1)])
Family ()

Sage Live

L = lie_algebras.sl(QQ, 3)
P = L.cartan_type().root_system().weight_lattice()
La = P.fundamental_weights()
al = P.simple_roots()
mu = 2*La[1] + 3*La[2]
M = L.verma_module(mu)
M.homogeneous_component_basis(mu - al[2])
M.homogeneous_component_basis(mu - 3*al[2])
M.homogeneous_component_basis(mu - 3*al[2] - 2*al[1])
M.homogeneous_component_basis(mu - La[1])

is_projective()

Return if self is a projective module in Category $\mathcal{O}$.

A Verma module $M_{\lambda }$ is projective (in Category $\mathcal{O}$ if and only if $\lambda$ is Verma dominant in the sense

$$⟨\lambda +\rho ,{\alpha }^{\vee }⟩\notin {\mathbf{Z}}_{<0}$$

for all positive roots $\alpha$.

EXAMPLES:

Sage

sage: L = lie_algebras.sl(QQ, 3)
sage: La = L.cartan_type().root_system().weight_space().fundamental_weights()
sage: L.verma_module(La[1] + La[2]).is_projective()
True
sage: L.verma_module(-La[1] - La[2]).is_projective()
True
sage: L.verma_module(3/2*La[1] + 1/2*La[2]).is_projective()
True
sage: L.verma_module(3/2*La[1] + 1/3*La[2]).is_projective()
True
sage: L.verma_module(-3*La[1] + 2/3*La[2]).is_projective()
False

Python

>>> from sage.all import *
>>> L = lie_algebras.sl(QQ, Integer(3))
>>> La = L.cartan_type().root_system().weight_space().fundamental_weights()
>>> L.verma_module(La[Integer(1)] + La[Integer(2)]).is_projective()
True
>>> L.verma_module(-La[Integer(1)] - La[Integer(2)]).is_projective()
True
>>> L.verma_module(Integer(3)/Integer(2)*La[Integer(1)] + Integer(1)/Integer(2)*La[Integer(2)]).is_projective()
True
>>> L.verma_module(Integer(3)/Integer(2)*La[Integer(1)] + Integer(1)/Integer(3)*La[Integer(2)]).is_projective()
True
>>> L.verma_module(-Integer(3)*La[Integer(1)] + Integer(2)/Integer(3)*La[Integer(2)]).is_projective()
False

Sage Live

L = lie_algebras.sl(QQ, 3)
La = L.cartan_type().root_system().weight_space().fundamental_weights()
L.verma_module(La[1] + La[2]).is_projective()
L.verma_module(-La[1] - La[2]).is_projective()
L.verma_module(3/2*La[1] + 1/2*La[2]).is_projective()
L.verma_module(3/2*La[1] + 1/3*La[2]).is_projective()
L.verma_module(-3*La[1] + 2/3*La[2]).is_projective()

is_simple()

Return if self is a simple module.

A Verma module $M_{\lambda }$ is simple if and only if $\lambda$ is Verma antidominant in the sense

$$⟨\lambda +\rho ,{\alpha }^{\vee }⟩\notin {\mathbf{Z}}_{>0}$$

for all positive roots $\alpha$.

EXAMPLES:

Sage

sage: L = lie_algebras.sl(QQ, 3)
sage: La = L.cartan_type().root_system().weight_space().fundamental_weights()
sage: L.verma_module(La[1] + La[2]).is_simple()
False
sage: L.verma_module(-La[1] - La[2]).is_simple()
True
sage: L.verma_module(3/2*La[1] + 1/2*La[2]).is_simple()
False
sage: L.verma_module(3/2*La[1] + 1/3*La[2]).is_simple()
True
sage: L.verma_module(-3*La[1] + 2/3*La[2]).is_simple()
True

Python

>>> from sage.all import *
>>> L = lie_algebras.sl(QQ, Integer(3))
>>> La = L.cartan_type().root_system().weight_space().fundamental_weights()
>>> L.verma_module(La[Integer(1)] + La[Integer(2)]).is_simple()
False
>>> L.verma_module(-La[Integer(1)] - La[Integer(2)]).is_simple()
True
>>> L.verma_module(Integer(3)/Integer(2)*La[Integer(1)] + Integer(1)/Integer(2)*La[Integer(2)]).is_simple()
False
>>> L.verma_module(Integer(3)/Integer(2)*La[Integer(1)] + Integer(1)/Integer(3)*La[Integer(2)]).is_simple()
True
>>> L.verma_module(-Integer(3)*La[Integer(1)] + Integer(2)/Integer(3)*La[Integer(2)]).is_simple()
True

Sage Live

L = lie_algebras.sl(QQ, 3)
La = L.cartan_type().root_system().weight_space().fundamental_weights()
L.verma_module(La[1] + La[2]).is_simple()
L.verma_module(-La[1] - La[2]).is_simple()
L.verma_module(3/2*La[1] + 1/2*La[2]).is_simple()
L.verma_module(3/2*La[1] + 1/3*La[2]).is_simple()
L.verma_module(-3*La[1] + 2/3*La[2]).is_simple()

is_singular()

Return if self is a singular Verma module.

A Verma module $M_{\lambda }$ is singular if there does not exist a dominant weight $\tilde{\lambda }$ that is in the dot orbit of $\lambda$. We call a Verma module regular otherwise.

EXAMPLES:

Sage

sage: L = lie_algebras.sl(QQ, 3)
sage: La = L.cartan_type().root_system().weight_lattice().fundamental_weights()
sage: M = L.verma_module(La[1] + La[2])
sage: M.is_singular()
False
sage: M = L.verma_module(La[1] - La[2])
sage: M.is_singular()
True
sage: M = L.verma_module(2*La[1] - 10*La[2])
sage: M.is_singular()
False
sage: M = L.verma_module(-2*La[1] - 2*La[2])
sage: M.is_singular()
False
sage: M = L.verma_module(-4*La[1] - La[2])
sage: M.is_singular()
True

Python

>>> from sage.all import *
>>> L = lie_algebras.sl(QQ, Integer(3))
>>> La = L.cartan_type().root_system().weight_lattice().fundamental_weights()
>>> M = L.verma_module(La[Integer(1)] + La[Integer(2)])
>>> M.is_singular()
False
>>> M = L.verma_module(La[Integer(1)] - La[Integer(2)])
>>> M.is_singular()
True
>>> M = L.verma_module(Integer(2)*La[Integer(1)] - Integer(10)*La[Integer(2)])
>>> M.is_singular()
False
>>> M = L.verma_module(-Integer(2)*La[Integer(1)] - Integer(2)*La[Integer(2)])
>>> M.is_singular()
False
>>> M = L.verma_module(-Integer(4)*La[Integer(1)] - La[Integer(2)])
>>> M.is_singular()
True

Sage Live

L = lie_algebras.sl(QQ, 3)
La = L.cartan_type().root_system().weight_lattice().fundamental_weights()
M = L.verma_module(La[1] + La[2])
M.is_singular()
M = L.verma_module(La[1] - La[2])
M.is_singular()
M = L.verma_module(2*La[1] - 10*La[2])
M.is_singular()
M = L.verma_module(-2*La[1] - 2*La[2])
M.is_singular()
M = L.verma_module(-4*La[1] - La[2])
M.is_singular()

lie_algebra()

Return the underlying Lie algebra of self.

EXAMPLES:

Sage

sage: L = lie_algebras.so(QQ, 9)
sage: La = L.cartan_type().root_system().weight_space().fundamental_weights()
sage: M = L.verma_module(La[3] - 1/2*La[1])
sage: M.lie_algebra()
Lie algebra of ['B', 4] in the Chevalley basis

Python

>>> from sage.all import *
>>> L = lie_algebras.so(QQ, Integer(9))
>>> La = L.cartan_type().root_system().weight_space().fundamental_weights()
>>> M = L.verma_module(La[Integer(3)] - Integer(1)/Integer(2)*La[Integer(1)])
>>> M.lie_algebra()
Lie algebra of ['B', 4] in the Chevalley basis

Sage Live

L = lie_algebras.so(QQ, 9)
La = L.cartan_type().root_system().weight_space().fundamental_weights()
M = L.verma_module(La[3] - 1/2*La[1])
M.lie_algebra()

pbw_basis()

Return the PBW basis of the underlying Lie algebra used to define self.

EXAMPLES:

Sage

sage: L = lie_algebras.so(QQ, 8)
sage: La = L.cartan_type().root_system().weight_lattice().fundamental_weights()
sage: M = L.verma_module(La[2] - 2*La[3])
sage: M.pbw_basis()
Universal enveloping algebra of Lie algebra of ['D', 4] in the Chevalley basis
 in the Poincare-Birkhoff-Witt basis

Python

>>> from sage.all import *
>>> L = lie_algebras.so(QQ, Integer(8))
>>> La = L.cartan_type().root_system().weight_lattice().fundamental_weights()
>>> M = L.verma_module(La[Integer(2)] - Integer(2)*La[Integer(3)])
>>> M.pbw_basis()
Universal enveloping algebra of Lie algebra of ['D', 4] in the Chevalley basis
 in the Poincare-Birkhoff-Witt basis

Sage Live

L = lie_algebras.so(QQ, 8)
La = L.cartan_type().root_system().weight_lattice().fundamental_weights()
M = L.verma_module(La[2] - 2*La[3])
M.pbw_basis()

poincare_birkhoff_witt_basis()

Return the PBW basis of the underlying Lie algebra used to define self.

EXAMPLES:

Sage

sage: L = lie_algebras.so(QQ, 8)
sage: La = L.cartan_type().root_system().weight_lattice().fundamental_weights()
sage: M = L.verma_module(La[2] - 2*La[3])
sage: M.pbw_basis()
Universal enveloping algebra of Lie algebra of ['D', 4] in the Chevalley basis
 in the Poincare-Birkhoff-Witt basis

Python

>>> from sage.all import *
>>> L = lie_algebras.so(QQ, Integer(8))
>>> La = L.cartan_type().root_system().weight_lattice().fundamental_weights()
>>> M = L.verma_module(La[Integer(2)] - Integer(2)*La[Integer(3)])
>>> M.pbw_basis()
Universal enveloping algebra of Lie algebra of ['D', 4] in the Chevalley basis
 in the Poincare-Birkhoff-Witt basis

Sage Live

L = lie_algebras.so(QQ, 8)
La = L.cartan_type().root_system().weight_lattice().fundamental_weights()
M = L.verma_module(La[2] - 2*La[3])
M.pbw_basis()

weight_space_basis(d)

Return a basis for the d-th homogeneous component of self.

EXAMPLES:

Sage

sage: L = lie_algebras.sl(QQ, 3)
sage: P = L.cartan_type().root_system().weight_lattice()
sage: La = P.fundamental_weights()
sage: al = P.simple_roots()
sage: mu = 2*La[1] + 3*La[2]
sage: M = L.verma_module(mu)
sage: M.homogeneous_component_basis(mu - al[2])
[f[-alpha[2]]*v[2*Lambda[1] + 3*Lambda[2]]]
sage: M.homogeneous_component_basis(mu - 3*al[2])
[f[-alpha[2]]^3*v[2*Lambda[1] + 3*Lambda[2]]]
sage: M.homogeneous_component_basis(mu - 3*al[2] - 2*al[1])
[f[-alpha[2]]*f[-alpha[1] - alpha[2]]^2*v[2*Lambda[1] + 3*Lambda[2]],
 f[-alpha[2]]^2*f[-alpha[1]]*f[-alpha[1] - alpha[2]]*v[2*Lambda[1] + 3*Lambda[2]],
 f[-alpha[2]]^3*f[-alpha[1]]^2*v[2*Lambda[1] + 3*Lambda[2]]]
sage: M.homogeneous_component_basis(mu - La[1])
Family ()

Python

>>> from sage.all import *
>>> L = lie_algebras.sl(QQ, Integer(3))
>>> P = L.cartan_type().root_system().weight_lattice()
>>> La = P.fundamental_weights()
>>> al = P.simple_roots()
>>> mu = Integer(2)*La[Integer(1)] + Integer(3)*La[Integer(2)]
>>> M = L.verma_module(mu)
>>> M.homogeneous_component_basis(mu - al[Integer(2)])
[f[-alpha[2]]*v[2*Lambda[1] + 3*Lambda[2]]]
>>> M.homogeneous_component_basis(mu - Integer(3)*al[Integer(2)])
[f[-alpha[2]]^3*v[2*Lambda[1] + 3*Lambda[2]]]
>>> M.homogeneous_component_basis(mu - Integer(3)*al[Integer(2)] - Integer(2)*al[Integer(1)])
[f[-alpha[2]]*f[-alpha[1] - alpha[2]]^2*v[2*Lambda[1] + 3*Lambda[2]],
 f[-alpha[2]]^2*f[-alpha[1]]*f[-alpha[1] - alpha[2]]*v[2*Lambda[1] + 3*Lambda[2]],
 f[-alpha[2]]^3*f[-alpha[1]]^2*v[2*Lambda[1] + 3*Lambda[2]]]
>>> M.homogeneous_component_basis(mu - La[Integer(1)])
Family ()

Sage Live

L = lie_algebras.sl(QQ, 3)
P = L.cartan_type().root_system().weight_lattice()
La = P.fundamental_weights()
al = P.simple_roots()
mu = 2*La[1] + 3*La[2]
M = L.verma_module(mu)
M.homogeneous_component_basis(mu - al[2])
M.homogeneous_component_basis(mu - 3*al[2])
M.homogeneous_component_basis(mu - 3*al[2] - 2*al[1])
M.homogeneous_component_basis(mu - La[1])

class sage.algebras.lie_algebras.verma_module.VermaModuleHomset(X, Y, category=None, base=None, check=True)

Bases: Homset

The set of morphisms from a Verma module to another module in Category $\mathcal{O}$ considered as $U(\mathfrak{g})$-representations.

This currently assumes the codomain is a Verma module, its dual, or a simple module.

Let $M_{w\cdot \lambda }$ and $M_{w^{\prime }\cdot {\lambda }^{\prime }}$ be Verma modules, $\cdot$ is the dot action, and $\lambda +\rho$, ${\lambda }^{\prime }+\rho$ are dominant weights. Then we have

$$\dim \mathrm{hom}(M_{w\cdot \lambda },M_{w^{\prime }\cdot {\lambda }^{\prime }})=1$$

if and only if $\lambda ={\lambda }^{\prime }$ and $w^{\prime }\le w$ in Bruhat order. Otherwise the homset is 0 dimensional.

If the codomain is a dual Verma module $M_{\mu }^{\vee }$, then the homset is ${\delta }_{\lambda \mu }$ dimensional. When $\mu =\lambda$, the image is the simple module $L_{\lambda }$.

Element

alias of VermaModuleMorphism

basis()

Return a basis of self.

EXAMPLES:

Sage

sage: L = lie_algebras.sl(QQ, 3)
sage: La = L.cartan_type().root_system().weight_lattice().fundamental_weights()
sage: M = L.verma_module(La[1] + La[2])
sage: Mp = L.verma_module(M.highest_weight().dot_action([2]))
sage: H = Hom(Mp, M)
sage: list(H.basis()) == [H.natural_map()]
True

sage: Mp = L.verma_module(La[1] + 2*La[2])
sage: H = Hom(Mp, M)
sage: H.basis()
Family ()

Python

>>> from sage.all import *
>>> L = lie_algebras.sl(QQ, Integer(3))
>>> La = L.cartan_type().root_system().weight_lattice().fundamental_weights()
>>> M = L.verma_module(La[Integer(1)] + La[Integer(2)])
>>> Mp = L.verma_module(M.highest_weight().dot_action([Integer(2)]))
>>> H = Hom(Mp, M)
>>> list(H.basis()) == [H.natural_map()]
True

>>> Mp = L.verma_module(La[Integer(1)] + Integer(2)*La[Integer(2)])
>>> H = Hom(Mp, M)
>>> H.basis()
Family ()

Sage Live

L = lie_algebras.sl(QQ, 3)
La = L.cartan_type().root_system().weight_lattice().fundamental_weights()
M = L.verma_module(La[1] + La[2])
Mp = L.verma_module(M.highest_weight().dot_action([2]))
H = Hom(Mp, M)
list(H.basis()) == [H.natural_map()]
Mp = L.verma_module(La[1] + 2*La[2])
H = Hom(Mp, M)
H.basis()

dimension()

Return the dimension of self (as a vector space over the base ring).

EXAMPLES:

Sage

sage: L = lie_algebras.sl(QQ, 3)
sage: La = L.cartan_type().root_system().weight_lattice().fundamental_weights()
sage: M = L.verma_module(La[1] + La[2])
sage: Mp = L.verma_module(M.highest_weight().dot_action([2]))
sage: H = Hom(Mp, M)
sage: H.dimension()
1

sage: Mp = L.verma_module(La[1] + 2*La[2])
sage: H = Hom(Mp, M)
sage: H.dimension()
0

Python

>>> from sage.all import *
>>> L = lie_algebras.sl(QQ, Integer(3))
>>> La = L.cartan_type().root_system().weight_lattice().fundamental_weights()
>>> M = L.verma_module(La[Integer(1)] + La[Integer(2)])
>>> Mp = L.verma_module(M.highest_weight().dot_action([Integer(2)]))
>>> H = Hom(Mp, M)
>>> H.dimension()
1

>>> Mp = L.verma_module(La[Integer(1)] + Integer(2)*La[Integer(2)])
>>> H = Hom(Mp, M)
>>> H.dimension()
0

Sage Live

L = lie_algebras.sl(QQ, 3)
La = L.cartan_type().root_system().weight_lattice().fundamental_weights()
M = L.verma_module(La[1] + La[2])
Mp = L.verma_module(M.highest_weight().dot_action([2]))
H = Hom(Mp, M)
H.dimension()
Mp = L.verma_module(La[1] + 2*La[2])
H = Hom(Mp, M)
H.dimension()

highest_weight_image()

Return the image of the highest weight vector of the domain in the codomain.

EXAMPLES:

Sage

sage: g = LieAlgebra(QQ, cartan_type=['C', 3])
sage: La = g.cartan_type().root_system().weight_lattice().fundamental_weights()
sage: M = g.verma_module(La[1] + 2*La[3])
sage: Mc = M.dual()
sage: H = Hom(M, Mc)
sage: H.highest_weight_image()
v[Lambda[1] + 2*Lambda[3]]^*
sage: L = H.natural_map().image()
sage: Hp = Hom(M, L)
sage: Hp.highest_weight_image()
u[Lambda[1] + 2*Lambda[3]]

Python

>>> from sage.all import *
>>> g = LieAlgebra(QQ, cartan_type=['C', Integer(3)])
>>> La = g.cartan_type().root_system().weight_lattice().fundamental_weights()
>>> M = g.verma_module(La[Integer(1)] + Integer(2)*La[Integer(3)])
>>> Mc = M.dual()
>>> H = Hom(M, Mc)
>>> H.highest_weight_image()
v[Lambda[1] + 2*Lambda[3]]^*
>>> L = H.natural_map().image()
>>> Hp = Hom(M, L)
>>> Hp.highest_weight_image()
u[Lambda[1] + 2*Lambda[3]]

Sage Live

g = LieAlgebra(QQ, cartan_type=['C', 3])
La = g.cartan_type().root_system().weight_lattice().fundamental_weights()
M = g.verma_module(La[1] + 2*La[3])
Mc = M.dual()
H = Hom(M, Mc)
H.highest_weight_image()
L = H.natural_map().image()
Hp = Hom(M, L)
Hp.highest_weight_image()

natural_map()

Return the “natural map” of self.

EXAMPLES:

Sage

sage: L = lie_algebras.sl(QQ, 3)
sage: La = L.cartan_type().root_system().weight_lattice().fundamental_weights()
sage: M = L.verma_module(La[1] + La[2])
sage: Mp = L.verma_module(M.highest_weight().dot_action([2]))
sage: H = Hom(Mp, M)
sage: H.natural_map()
Verma module morphism:
  From: Verma module with highest weight 3*Lambda[1] - 3*Lambda[2]
         of Lie algebra of ['A', 2] in the Chevalley basis
  To:   Verma module with highest weight Lambda[1] + Lambda[2]
         of Lie algebra of ['A', 2] in the Chevalley basis
  Defn: v[3*Lambda[1] - 3*Lambda[2]] |-->
         f[-alpha[2]]^2*v[Lambda[1] + Lambda[2]]

sage: Mp = L.verma_module(La[1] + 2*La[2])
sage: H = Hom(Mp, M)
sage: H.natural_map()
Verma module morphism:
  From: Verma module with highest weight Lambda[1] + 2*Lambda[2]
         of Lie algebra of ['A', 2] in the Chevalley basis
  To:   Verma module with highest weight Lambda[1] + Lambda[2]
         of Lie algebra of ['A', 2] in the Chevalley basis
  Defn: v[Lambda[1] + 2*Lambda[2]] |--> 0

Python

>>> from sage.all import *
>>> L = lie_algebras.sl(QQ, Integer(3))
>>> La = L.cartan_type().root_system().weight_lattice().fundamental_weights()
>>> M = L.verma_module(La[Integer(1)] + La[Integer(2)])
>>> Mp = L.verma_module(M.highest_weight().dot_action([Integer(2)]))
>>> H = Hom(Mp, M)
>>> H.natural_map()
Verma module morphism:
  From: Verma module with highest weight 3*Lambda[1] - 3*Lambda[2]
         of Lie algebra of ['A', 2] in the Chevalley basis
  To:   Verma module with highest weight Lambda[1] + Lambda[2]
         of Lie algebra of ['A', 2] in the Chevalley basis
  Defn: v[3*Lambda[1] - 3*Lambda[2]] |-->
         f[-alpha[2]]^2*v[Lambda[1] + Lambda[2]]

>>> Mp = L.verma_module(La[Integer(1)] + Integer(2)*La[Integer(2)])
>>> H = Hom(Mp, M)
>>> H.natural_map()
Verma module morphism:
  From: Verma module with highest weight Lambda[1] + 2*Lambda[2]
         of Lie algebra of ['A', 2] in the Chevalley basis
  To:   Verma module with highest weight Lambda[1] + Lambda[2]
         of Lie algebra of ['A', 2] in the Chevalley basis
  Defn: v[Lambda[1] + 2*Lambda[2]] |--> 0

Sage Live

L = lie_algebras.sl(QQ, 3)
La = L.cartan_type().root_system().weight_lattice().fundamental_weights()
M = L.verma_module(La[1] + La[2])
Mp = L.verma_module(M.highest_weight().dot_action([2]))
H = Hom(Mp, M)
H.natural_map()
Mp = L.verma_module(La[1] + 2*La[2])
H = Hom(Mp, M)
H.natural_map()

singular_vector()

Return the singular vector in the codomain corresponding to the domain’s highest weight element or None if no such element exists.

ALGORITHM:

We essentially follow the algorithm laid out in [deG2005]. We split the main computation into two cases. If there exists an $i$ such that $⟨\lambda +\rho ,{\alpha }_i^{\vee }⟩=m>0$ (i.e., the weight $\lambda$ is $i$-dominant with respect to the dot action), then we use the ${\mathfrak{sl}}_2$ relation on $M_{s_i\cdot \lambda }\to M_{\lambda }$ to construct the singular vector $f_i^m{v}_{\lambda }$. Otherwise we find the shortest root $\alpha$ such that $⟨\lambda +\rho ,{\alpha }^{\vee }⟩>0$ and explicitly compute the kernel with respect to the weight basis elements. We iterate this until we reach $\mu$.

EXAMPLES:

Sage

sage: L = lie_algebras.sp(QQ, 6)
sage: La = L.cartan_type().root_system().weight_space().fundamental_weights()
sage: la = La[1] - La[3]
sage: mu = la.dot_action([1,2])
sage: M = L.verma_module(la)
sage: Mp = L.verma_module(mu)
sage: H = Hom(Mp, M)
sage: v = H.singular_vector(); v
f[-alpha[2]]*f[-alpha[1]]^3*v[Lambda[1] - Lambda[3]]
 + 3*f[-alpha[1]]^2*f[-alpha[1] - alpha[2]]*v[Lambda[1] - Lambda[3]]
sage: v.degree() == Mp.highest_weight()
True

Python

>>> from sage.all import *
>>> L = lie_algebras.sp(QQ, Integer(6))
>>> La = L.cartan_type().root_system().weight_space().fundamental_weights()
>>> la = La[Integer(1)] - La[Integer(3)]
>>> mu = la.dot_action([Integer(1),Integer(2)])
>>> M = L.verma_module(la)
>>> Mp = L.verma_module(mu)
>>> H = Hom(Mp, M)
>>> v = H.singular_vector(); v
f[-alpha[2]]*f[-alpha[1]]^3*v[Lambda[1] - Lambda[3]]
 + 3*f[-alpha[1]]^2*f[-alpha[1] - alpha[2]]*v[Lambda[1] - Lambda[3]]
>>> v.degree() == Mp.highest_weight()
True

Sage Live

L = lie_algebras.sp(QQ, 6)
La = L.cartan_type().root_system().weight_space().fundamental_weights()
la = La[1] - La[3]
mu = la.dot_action([1,2])
M = L.verma_module(la)
Mp = L.verma_module(mu)
H = Hom(Mp, M)
v = H.singular_vector(); v
v.degree() == Mp.highest_weight()

Sage

sage: L = LieAlgebra(QQ, cartan_type=['F', 4])
sage: La = L.cartan_type().root_system().weight_space().fundamental_weights()
sage: la = La[1] + La[2] - La[3]
sage: mu = la.dot_action([1,2,3,2])
sage: M = L.verma_module(la)
sage: Mp = L.verma_module(mu)
sage: H = Hom(Mp, M)
sage: v = H.singular_vector()
sage: pbw = M.pbw_basis()
sage: E = [pbw(e) for e in L.e()]
sage: all(e * v == M.zero() for e in E)  # long time
True
sage: v.degree() == Mp.highest_weight()
True

Python

>>> from sage.all import *
>>> L = LieAlgebra(QQ, cartan_type=['F', Integer(4)])
>>> La = L.cartan_type().root_system().weight_space().fundamental_weights()
>>> la = La[Integer(1)] + La[Integer(2)] - La[Integer(3)]
>>> mu = la.dot_action([Integer(1),Integer(2),Integer(3),Integer(2)])
>>> M = L.verma_module(la)
>>> Mp = L.verma_module(mu)
>>> H = Hom(Mp, M)
>>> v = H.singular_vector()
>>> pbw = M.pbw_basis()
>>> E = [pbw(e) for e in L.e()]
>>> all(e * v == M.zero() for e in E)  # long time
True
>>> v.degree() == Mp.highest_weight()
True

Sage Live

L = LieAlgebra(QQ, cartan_type=['F', 4])
La = L.cartan_type().root_system().weight_space().fundamental_weights()
la = La[1] + La[2] - La[3]
mu = la.dot_action([1,2,3,2])
M = L.verma_module(la)
Mp = L.verma_module(mu)
H = Hom(Mp, M)
v = H.singular_vector()
pbw = M.pbw_basis()
E = [pbw(e) for e in L.e()]
all(e * v == M.zero() for e in E)  # long time
v.degree() == Mp.highest_weight()

When $w\cdot \lambda \notin \lambda +Q^{-}$, there does not exist a singular vector:

Sage

sage: L = lie_algebras.sl(QQ, 4)
sage: La = L.cartan_type().root_system().weight_space().fundamental_weights()
sage: la = 3/7*La[1] - 1/2*La[3]
sage: mu = la.dot_action([1,2])
sage: M = L.verma_module(la)
sage: Mp = L.verma_module(mu)
sage: H = Hom(Mp, M)
sage: H.singular_vector() is None
True

Python

>>> from sage.all import *
>>> L = lie_algebras.sl(QQ, Integer(4))
>>> La = L.cartan_type().root_system().weight_space().fundamental_weights()
>>> la = Integer(3)/Integer(7)*La[Integer(1)] - Integer(1)/Integer(2)*La[Integer(3)]
>>> mu = la.dot_action([Integer(1),Integer(2)])
>>> M = L.verma_module(la)
>>> Mp = L.verma_module(mu)
>>> H = Hom(Mp, M)
>>> H.singular_vector() is None
True

Sage Live

L = lie_algebras.sl(QQ, 4)
La = L.cartan_type().root_system().weight_space().fundamental_weights()
la = 3/7*La[1] - 1/2*La[3]
mu = la.dot_action([1,2])
M = L.verma_module(la)
Mp = L.verma_module(mu)
H = Hom(Mp, M)
H.singular_vector() is None

When we need to apply a non-simple reflection, we can compute the singular vector (see Issue #36793):

Sage

sage: g = LieAlgebra(QQ, cartan_type=['A', 2])
sage: La = g.cartan_type().root_system().weight_lattice().fundamental_weights()
sage: M = g.verma_module((0*La[1]).dot_action([1]))
sage: Mp = g.verma_module((0*La[1]).dot_action([1,2]))
sage: H = Hom(Mp, M)
sage: v = H.singular_vector(); v
1/2*f[-alpha[2]]*f[-alpha[1]]*v[-2*Lambda[1] + Lambda[2]]
 + f[-alpha[1] - alpha[2]]*v[-2*Lambda[1] + Lambda[2]]
sage: pbw = M.pbw_basis()
sage: E = [pbw(e) for e in g.e()]
sage: all(e * v == M.zero() for e in E)
True
sage: v.degree() == Mp.highest_weight()
True

Python

>>> from sage.all import *
>>> g = LieAlgebra(QQ, cartan_type=['A', Integer(2)])
>>> La = g.cartan_type().root_system().weight_lattice().fundamental_weights()
>>> M = g.verma_module((Integer(0)*La[Integer(1)]).dot_action([Integer(1)]))
>>> Mp = g.verma_module((Integer(0)*La[Integer(1)]).dot_action([Integer(1),Integer(2)]))
>>> H = Hom(Mp, M)
>>> v = H.singular_vector(); v
1/2*f[-alpha[2]]*f[-alpha[1]]*v[-2*Lambda[1] + Lambda[2]]
 + f[-alpha[1] - alpha[2]]*v[-2*Lambda[1] + Lambda[2]]
>>> pbw = M.pbw_basis()
>>> E = [pbw(e) for e in g.e()]
>>> all(e * v == M.zero() for e in E)
True
>>> v.degree() == Mp.highest_weight()
True

Sage Live

g = LieAlgebra(QQ, cartan_type=['A', 2])
La = g.cartan_type().root_system().weight_lattice().fundamental_weights()
M = g.verma_module((0*La[1]).dot_action([1]))
Mp = g.verma_module((0*La[1]).dot_action([1,2]))
H = Hom(Mp, M)
v = H.singular_vector(); v
pbw = M.pbw_basis()
E = [pbw(e) for e in g.e()]
all(e * v == M.zero() for e in E)
v.degree() == Mp.highest_weight()

zero()

Return the zero morphism of self.

EXAMPLES:

Sage

sage: L = lie_algebras.sp(QQ, 6)
sage: La = L.cartan_type().root_system().weight_space().fundamental_weights()
sage: M = L.verma_module(La[1] + 2/3*La[2])
sage: Mp = L.verma_module(La[2] - La[3])
sage: H = Hom(Mp, M)
sage: H.zero()
Verma module morphism:
  From: Verma module with highest weight Lambda[2] - Lambda[3]
         of Lie algebra of ['C', 3] in the Chevalley basis
  To:   Verma module with highest weight Lambda[1] + 2/3*Lambda[2]
         of Lie algebra of ['C', 3] in the Chevalley basis
  Defn: v[Lambda[2] - Lambda[3]] |--> 0

Python

>>> from sage.all import *
>>> L = lie_algebras.sp(QQ, Integer(6))
>>> La = L.cartan_type().root_system().weight_space().fundamental_weights()
>>> M = L.verma_module(La[Integer(1)] + Integer(2)/Integer(3)*La[Integer(2)])
>>> Mp = L.verma_module(La[Integer(2)] - La[Integer(3)])
>>> H = Hom(Mp, M)
>>> H.zero()
Verma module morphism:
  From: Verma module with highest weight Lambda[2] - Lambda[3]
         of Lie algebra of ['C', 3] in the Chevalley basis
  To:   Verma module with highest weight Lambda[1] + 2/3*Lambda[2]
         of Lie algebra of ['C', 3] in the Chevalley basis
  Defn: v[Lambda[2] - Lambda[3]] |--> 0

Sage Live

L = lie_algebras.sp(QQ, 6)
La = L.cartan_type().root_system().weight_space().fundamental_weights()
M = L.verma_module(La[1] + 2/3*La[2])
Mp = L.verma_module(La[2] - La[3])
H = Hom(Mp, M)
H.zero()

class sage.algebras.lie_algebras.verma_module.VermaModuleMorphism(parent, scalar)

Bases: Morphism

A morphism of a Verma module to another module in Category $\mathcal{O}$.

image()

Return the image of self.

EXAMPLES:

Sage

sage: g = LieAlgebra(QQ, cartan_type=['B', 2])
sage: La = g.cartan_type().root_system().weight_lattice().fundamental_weights()
sage: M = g.verma_module(La[1] + 2*La[2])
sage: Mp = g.verma_module(La[1] + 3*La[2])
sage: phi = Hom(M, Mp).natural_map()
sage: phi.image()
Free module generated by {} over Rational Field
sage: Mc = M.dual()
sage: phi = Hom(M, Mc).natural_map()
sage: L = phi.image(); L
Simple module with highest weight Lambda[1] + 2*Lambda[2] of
 Lie algebra of ['B', 2] in the Chevalley basis
sage: psi = Hom(M, L).natural_map()
sage: psi.image()
Simple module with highest weight Lambda[1] + 2*Lambda[2] of
 Lie algebra of ['B', 2] in the Chevalley basis

Python

>>> from sage.all import *
>>> g = LieAlgebra(QQ, cartan_type=['B', Integer(2)])
>>> La = g.cartan_type().root_system().weight_lattice().fundamental_weights()
>>> M = g.verma_module(La[Integer(1)] + Integer(2)*La[Integer(2)])
>>> Mp = g.verma_module(La[Integer(1)] + Integer(3)*La[Integer(2)])
>>> phi = Hom(M, Mp).natural_map()
>>> phi.image()
Free module generated by {} over Rational Field
>>> Mc = M.dual()
>>> phi = Hom(M, Mc).natural_map()
>>> L = phi.image(); L
Simple module with highest weight Lambda[1] + 2*Lambda[2] of
 Lie algebra of ['B', 2] in the Chevalley basis
>>> psi = Hom(M, L).natural_map()
>>> psi.image()
Simple module with highest weight Lambda[1] + 2*Lambda[2] of
 Lie algebra of ['B', 2] in the Chevalley basis

Sage Live

g = LieAlgebra(QQ, cartan_type=['B', 2])
La = g.cartan_type().root_system().weight_lattice().fundamental_weights()
M = g.verma_module(La[1] + 2*La[2])
Mp = g.verma_module(La[1] + 3*La[2])
phi = Hom(M, Mp).natural_map()
phi.image()
Mc = M.dual()
phi = Hom(M, Mc).natural_map()
L = phi.image(); L
psi = Hom(M, L).natural_map()
psi.image()

is_injective()

Return if self is injective or not.

A morphism $\varphi :M\to M^{\prime }$ from a Verma module $M$ to another Verma module $M^{\prime }$ is injective if and only if $\dim \mathrm{hom}(M,M^{\prime })=1$ and $\varphi \ne 0$. If $M^{\prime }$ is a dual Verma or simple module, then the result is not injective.

EXAMPLES:

Sage

sage: L = lie_algebras.sl(QQ, 3)
sage: La = L.cartan_type().root_system().weight_lattice().fundamental_weights()
sage: M = L.verma_module(La[1] + La[2])
sage: Mp = L.verma_module(M.highest_weight().dot_action([1,2]))
sage: Mpp = L.verma_module(M.highest_weight().dot_action([1,2]) + La[1])
sage: phi = Hom(Mp, M).natural_map()
sage: phi.is_injective()
True
sage: (0 * phi).is_injective()
False
sage: psi = Hom(Mpp, Mp).natural_map()
sage: psi.is_injective()
False

Python

>>> from sage.all import *
>>> L = lie_algebras.sl(QQ, Integer(3))
>>> La = L.cartan_type().root_system().weight_lattice().fundamental_weights()
>>> M = L.verma_module(La[Integer(1)] + La[Integer(2)])
>>> Mp = L.verma_module(M.highest_weight().dot_action([Integer(1),Integer(2)]))
>>> Mpp = L.verma_module(M.highest_weight().dot_action([Integer(1),Integer(2)]) + La[Integer(1)])
>>> phi = Hom(Mp, M).natural_map()
>>> phi.is_injective()
True
>>> (Integer(0) * phi).is_injective()
False
>>> psi = Hom(Mpp, Mp).natural_map()
>>> psi.is_injective()
False

Sage Live

L = lie_algebras.sl(QQ, 3)
La = L.cartan_type().root_system().weight_lattice().fundamental_weights()
M = L.verma_module(La[1] + La[2])
Mp = L.verma_module(M.highest_weight().dot_action([1,2]))
Mpp = L.verma_module(M.highest_weight().dot_action([1,2]) + La[1])
phi = Hom(Mp, M).natural_map()
phi.is_injective()
(0 * phi).is_injective()
psi = Hom(Mpp, Mp).natural_map()
psi.is_injective()

is_surjective()

Return if self is surjective or not.

A morphism $\varphi :M\to M^{\prime }$ from a Verma module $M$ to another Verma module $M^{\prime }$ is surjective if and only if the domain is equal to the codomain and it is not the zero morphism.

If $M^{\prime }$ is a simple module, then this surjective if and only if $\dim \mathrm{hom}(M,M^{\prime })=1$ and $\varphi \ne 0$.

EXAMPLES:

Sage

sage: L = lie_algebras.sl(QQ, 3)
sage: La = L.cartan_type().root_system().weight_lattice().fundamental_weights()
sage: M = L.verma_module(La[1] + La[2])
sage: Mp = L.verma_module(M.highest_weight().dot_action([1,2]))
sage: phi = Hom(M, M).natural_map()
sage: phi.is_surjective()
True
sage: (0 * phi).is_surjective()
False
sage: psi = Hom(Mp, M).natural_map()
sage: psi.is_surjective()
False

Python

>>> from sage.all import *
>>> L = lie_algebras.sl(QQ, Integer(3))
>>> La = L.cartan_type().root_system().weight_lattice().fundamental_weights()
>>> M = L.verma_module(La[Integer(1)] + La[Integer(2)])
>>> Mp = L.verma_module(M.highest_weight().dot_action([Integer(1),Integer(2)]))
>>> phi = Hom(M, M).natural_map()
>>> phi.is_surjective()
True
>>> (Integer(0) * phi).is_surjective()
False
>>> psi = Hom(Mp, M).natural_map()
>>> psi.is_surjective()
False

Sage Live

L = lie_algebras.sl(QQ, 3)
La = L.cartan_type().root_system().weight_lattice().fundamental_weights()
M = L.verma_module(La[1] + La[2])
Mp = L.verma_module(M.highest_weight().dot_action([1,2]))
phi = Hom(M, M).natural_map()
phi.is_surjective()
(0 * phi).is_surjective()
psi = Hom(Mp, M).natural_map()
psi.is_surjective()

Make live