BGG Resolutions

AUTHORS:

• Travis Scrimshaw (2024-01-07): Initial version

class sage.algebras.lie_algebras.bgg_resolution.BGGResolution(L)

Bases: UniqueRepresentation, ChainComplex_class

The BGG resolution of a simple module.

We realize the BGG resolution as a chain complex, where the \((-1)\)-th factor corresponds to the finite dimensional simple module \(L_{\lambda}\) and the \(i\)-th factor (\(i \geq 0\)) corresponds to

\[\begin{split}M_i := \bigoplus_{\substack{w \in W \\ \ell(w) = i}} M_{w\lambda}.\end{split}\]

Since the morphisms can be defined in terms of the image of the highest weight vectors, we only encode this information as a (finite) chain complex. We do not include the final natural projection map \(p: M_{\lambda} \to L_{\lambda}\) since the highest weight vector of weight \(\lambda\) only occurs in \(M_{\lambda}\) and \(L_{\lambda}\).

INPUT:

• L – a simple module

EXAMPLES:

Sage

sage: g = LieAlgebra(QQ, cartan_type=['A', 2])
sage: La = g.cartan_type().root_system().weight_lattice().fundamental_weights()
sage: L = g.simple_module(La[1] + 4*La[2])
sage: res = L.bgg_resolution()
sage: ascii_art(res)
                        [ 1 -1]       [1]
            [1 1]       [-1  1]       [1]
 0 <-- C_0 <------ C_1 <-------- C_2 <---- C_3 <-- 0

sage: g = LieAlgebra(QQ, cartan_type=['D', 4])
sage: La = g.cartan_type().root_system().weight_lattice().fundamental_weights()
sage: L = g.simple_module(La[1] + La[2] + 3*La[3])
sage: res = L.bgg_resolution()
sage: w0 = WeylGroup(g.cartan_type(), prefix='s').long_element()
sage: all(res.differential(i) * res.differential(i+1) == 0
....:     for i in range(w0.length()))
True

Python

>>> from sage.all import *
>>> g = LieAlgebra(QQ, cartan_type=['A', Integer(2)])
>>> La = g.cartan_type().root_system().weight_lattice().fundamental_weights()
>>> L = g.simple_module(La[Integer(1)] + Integer(4)*La[Integer(2)])
>>> res = L.bgg_resolution()
>>> ascii_art(res)
                        [ 1 -1]       [1]
            [1 1]       [-1  1]       [1]
 0 <-- C_0 <------ C_1 <-------- C_2 <---- C_3 <-- 0

>>> g = LieAlgebra(QQ, cartan_type=['D', Integer(4)])
>>> La = g.cartan_type().root_system().weight_lattice().fundamental_weights()
>>> L = g.simple_module(La[Integer(1)] + La[Integer(2)] + Integer(3)*La[Integer(3)])
>>> res = L.bgg_resolution()
>>> w0 = WeylGroup(g.cartan_type(), prefix='s').long_element()
>>> all(res.differential(i) * res.differential(i+Integer(1)) == Integer(0)
...     for i in range(w0.length()))
True

module_order(i)

Return a tuple of Weyl group elements of length i determining the ordering of the direct sum defining the differential matrix.

EXAMPLES:

Sage

sage: g = LieAlgebra(QQ, cartan_type=['G', 2])
sage: La = g.cartan_type().root_system().weight_lattice().fundamental_weights()
sage: L = g.simple_module(La[1])
sage: res = L.bgg_resolution()
sage: [res.module_order(i) for i in range(7)]
[[1],
 [s2, s1],
 [s2*s1, s1*s2],
 [s1*s2*s1, s2*s1*s2],
 [s1*s2*s1*s2, s2*s1*s2*s1],
 [s1*s2*s1*s2*s1, s2*s1*s2*s1*s2],
 [s2*s1*s2*s1*s2*s1]]

Python

>>> from sage.all import *
>>> g = LieAlgebra(QQ, cartan_type=['G', Integer(2)])
>>> La = g.cartan_type().root_system().weight_lattice().fundamental_weights()
>>> L = g.simple_module(La[Integer(1)])
>>> res = L.bgg_resolution()
>>> [res.module_order(i) for i in range(Integer(7))]
[[1],
 [s2, s1],
 [s2*s1, s1*s2],
 [s1*s2*s1, s2*s1*s2],
 [s1*s2*s1*s2, s2*s1*s2*s1],
 [s1*s2*s1*s2*s1, s2*s1*s2*s1*s2],
 [s2*s1*s2*s1*s2*s1]]

simple_module()

Return the simple module \(L_{\lambda}\) defining self.

EXAMPLES:

Sage

sage: g = LieAlgebra(QQ, cartan_type=['C', 2])
sage: La = g.cartan_type().root_system().weight_lattice().fundamental_weights()
sage: L = g.simple_module(La[1] + La[2])
sage: res = L.bgg_resolution()
sage: res.simple_module() is L
True

Python

>>> from sage.all import *
>>> g = LieAlgebra(QQ, cartan_type=['C', Integer(2)])
>>> La = g.cartan_type().root_system().weight_lattice().fundamental_weights()
>>> L = g.simple_module(La[Integer(1)] + La[Integer(2)])
>>> res = L.bgg_resolution()
>>> res.simple_module() is L
True

sage.algebras.lie_algebras.bgg_resolution.build_differentials()

Construct the differentials for the BGG resolution corresponding to the Weyl group \(W\).

ALGORITHM:

We use the fact that (parabolic) Bruhat order is built locally from squares, all values defining the differential are \(+1\) or \(-1\), and the product over the two different paths must sum to \(0\). This is outlined in Ch. 6 of [Humphreys08].

This only depends on the Coxeter group \(W\). There is no stabilizer for any dominant integral weight \(\lambda\) undert the dot action (i.e., the stabilizer of \(\lambda + \rho\) is empty).

EXAMPLES:

Sage

sage: from sage.algebras.lie_algebras.bgg_resolution import build_differentials
sage: W = WeylGroup(['B', 2], prefix='s')
sage: D, O = build_differentials(W)
sage: D
{0: [],
 1: [-1  1],
 2: [1 1]
    [1 1],
 3: [ 1 -1]
    [-1  1],
 4: [1]
    [1],
 5: []}
sage: O
{0: [1],
 1: [s2, s1],
 2: [s2*s1, s1*s2],
 3: [s2*s1*s2, s1*s2*s1],
 4: [s2*s1*s2*s1]}

Python

>>> from sage.all import *
>>> from sage.algebras.lie_algebras.bgg_resolution import build_differentials
>>> W = WeylGroup(['B', Integer(2)], prefix='s')
>>> D, O = build_differentials(W)
>>> D
{0: [],
 1: [-1  1],
 2: [1 1]
    [1 1],
 3: [ 1 -1]
    [-1  1],
 4: [1]
    [1],
 5: []}
>>> O
{0: [1],
 1: [s2, s1],
 2: [s2*s1, s1*s2],
 3: [s2*s1*s2, s1*s2*s1],
 4: [s2*s1*s2*s1]}