def reduce_basis(self, long_etas):
r"""
Produce a more manageable basis via LLL-reduction.
INPUT:
- ``long_etas`` - a list of EtaGroupElement objects (which
should all be of the same level)
OUTPUT:
- a new list of EtaGroupElement objects having
hopefully smaller norm
ALGORITHM: We define the norm of an eta-product to be the
`L^2` norm of its divisor (as an element of the free
`\ZZ`-module with the cusps as basis and the
standard inner product). Applying LLL-reduction to this gives a
basis of hopefully more tractable elements. Of course we'd like to
use the `L^1` norm as this is just twice the degree, which
is a much more natural invariant, but `L^2` norm is easier
to work with!
EXAMPLES::
sage: EtaGroup(4).reduce_basis([ EtaProduct(4, {1:8,2:24,4:-32}), EtaProduct(4, {1:8, 4:-8})])
[Eta product of level 4 : (eta_1)^8 (eta_4)^-8,
Eta product of level 4 : (eta_1)^-8 (eta_2)^24 (eta_4)^-16]
"""
from six.moves import range
N = self.level()
cusps = AllCusps(N)
r = matrix(ZZ,
[[et.order_at_cusp(c) for c in cusps] for et in long_etas])
V = FreeModule(ZZ, r.ncols())
A = V.submodule_with_basis([V(rw) for rw in r.rows()])
rred = r.LLL()
short_etas = []
for shortvect in rred.rows():
bv = A.coordinates(shortvect)
dict = {
d: sum(bv[i] * long_etas[i].r(d) for i in range(r.nrows()))
for d in divisors(N)
}
short_etas.append(self(dict))
return short_etas
def reduce_basis(self, long_etas):
r"""
Produce a more manageable basis via LLL-reduction.
INPUT:
- ``long_etas`` - a list of EtaGroupElement objects (which
should all be of the same level)
OUTPUT:
- a new list of EtaGroupElement objects having
hopefully smaller norm
ALGORITHM: We define the norm of an eta-product to be the
`L^2` norm of its divisor (as an element of the free
`\ZZ`-module with the cusps as basis and the
standard inner product). Applying LLL-reduction to this gives a
basis of hopefully more tractable elements. Of course we'd like to
use the `L^1` norm as this is just twice the degree, which
is a much more natural invariant, but `L^2` norm is easier
to work with!
EXAMPLES::
sage: EtaGroup(4).reduce_basis([ EtaProduct(4, {1:8,2:24,4:-32}), EtaProduct(4, {1:8, 4:-8})])
[Eta product of level 4 : (eta_1)^8 (eta_4)^-8,
Eta product of level 4 : (eta_1)^-8 (eta_2)^24 (eta_4)^-16]
"""
from six.moves import range
N = self.level()
cusps = AllCusps(N)
r = matrix(ZZ, [[et.order_at_cusp(c) for c in cusps] for et in long_etas])
V = FreeModule(ZZ, r.ncols())
A = V.submodule_with_basis([V(rw) for rw in r.rows()])
rred = r.LLL()
short_etas = []
for shortvect in rred.rows():
bv = A.coordinates(shortvect)
dict = {d: sum(bv[i] * long_etas[i].r(d)
for i in range(r.nrows()))
for d in divisors(N)}
short_etas.append(self(dict))
return short_etas
def stratification(L):
r"""
Return a stratification of the Lie algebra if one exists.
INPUT:
- ``L`` -- a Lie algebra
OUTPUT:
A grading of the Lie algebra `\mathfrak{g}` over the integers such
that the layer `\mathfrak{g}_1` generates the full Lie algebra.
EXAMPLES::
A stratification for a free nilpotent Lie algebra is the
one based on the length of the defining bracket::
sage: from lie_gradings.gradings.grading import stratification
sage: from lie_gradings.gradings.utilities import in_new_basis
sage: L = LieAlgebra(QQ, 3, step=3)
sage: strat = stratification(L)
sage: strat
Grading over Additive abelian group isomorphic to Z of Free Nilpotent
Lie algebra on 14 generators (X_1, X_2, X_3, X_12, X_13, X_23, X_112,
X_113, X_122, X_123, X_132, X_133, X_223, X_233) over Rational Field
with nonzero layers
(1) : (X_1, X_2, X_3)
(2) : (X_12, X_13, X_23)
(3) : (X_112, X_113, X_122, X_123, X_132, X_133, X_223, X_233)
The main use case is when the original basis of the stratifiable Lie
algebra is not adapted to a stratification. Consider the following
quotient Lie algebra::
sage: X_1, X_2, X_3 = L.basis().list()[:3]
sage: Q = L.quotient(L[X_2, X_3])
sage: Q
Lie algebra quotient L/I of dimension 10 over Rational Field where
L: Free Nilpotent Lie algebra on 14 generators (X_1, X_2, X_3, X_12, X_13, X_23, X_112, X_113, X_122, X_123, X_132, X_133, X_223, X_233) over Rational Field
I: Ideal (X_23)
We switch to a basis which does not define a stratification::
sage: Y_1 = Q(X_1)
sage: Y_2 = Q(X_2) + Q[X_1, X_2]
sage: Y_3 = Q(X_3)
sage: basis = [Y_1, Y_2, Y_3] + Q.basis().list()[3:]
sage: Y_labels = ["Y_%d"%(k+1) for k in range(len(basis))]
sage: K = in_new_basis(Q, basis,Y_labels)
sage: K.inject_variables()
Defining Y_1, Y_2, Y_3, Y_4, Y_5, Y_6, Y_7, Y_8, Y_9, Y_10
sage: K[Y_2, Y_3]
Y_9
sage: K[[Y_1, Y_3], Y_2]
Y_9
We may reconstruct a stratification in the new basis without
any knowledge of the original stratification::
sage: stratification(K)
Grading over Additive abelian group isomorphic to Z of Nilpotent Lie
algebra on 10 generators (Y_1, Y_2, Y_3, Y_4, Y_5, Y_6, Y_7, Y_8, Y_9,
Y_10) over Rational Field with nonzero layers
(1) : (Y_1, Y_2 - Y_4, Y_3)
(2) : (Y_4, Y_5)
(3) : (Y_10, Y_6, Y_7, Y_8, Y_9)
sage: K[Y_1, Y_2 - Y_4]
Y_4
sage: K[Y_1, Y_3]
Y_5
sage: K[Y_2 - Y_4, Y_3]
0
A non-stratifiable Lie algebra raises an error::
sage: L = LieAlgebra(QQ, {('X_1','X_3'): {'X_4': 1},
....: ('X_1','X_4'): {'X_5': 1},
....: ('X_2','X_3'): {'X_5': 1}},
....: names='X_1,X_2,X_3,X_4,X_5')
sage: stratification(L)
Traceback (most recent call last):
...
ValueError: Lie algebra on 5 generators (X_1, X_2, X_3, X_4,
X_5) over Rational Field is not a stratifiable Lie algebra
"""
lcs = L.lower_central_series(submodule=True)
quots = [V.quotient(W) for V, W in zip(lcs, lcs[1:])]
# find a basis adapted to the filtration by the lower central series
adapted_basis = []
weights = []
for k, q in enumerate(quots):
weights += [k + 1] * q.dimension()
for v in q.basis():
b = q.lift(v)
adapted_basis.append(b)
# define a submodule to compute structural
# coefficients in the filtration adapted basis
try:
m = L.module()
except AttributeError:
m = FreeModule(L.base_ring(), L.dimension())
sm = m.submodule_with_basis(adapted_basis)
# form the linear system Ax=b of constraints from the Leibniz rule
paramspace = [(k, h) for k in range(L.dimension())
for h in range(L.dimension()) if weights[h] > weights[k]]
Arows = []
bvec = []
zerovec = m.zero()
for i in range(L.dimension()):
Y_i = adapted_basis[i]
w_i = weights[i]
for j in range(i + 1, L.dimension()):
Y_j = adapted_basis[j]
w_j = weights[j]
Y_ij = L.bracket(Y_i, Y_j)
c_ij = sm.coordinate_vector(Y_ij.to_vector())
bcomp = L.zero()
for k in range(L.dimension()):
w_k = weights[k]
Y_k = adapted_basis[k]
bcomp += (w_k - w_i - w_j) * c_ij[k] * Y_k
bv = bcomp.to_vector()
Acomp = {}
for k, h in paramspace:
w_k = weights[k]
Y_h = adapted_basis[h]
if k == i:
Acomp[(k, h)] = L.bracket(Y_h, Y_j).to_vector()
elif k == j:
Acomp[(k, h)] = L.bracket(Y_i, Y_h).to_vector()
elif w_k >= w_i + w_j:
Acomp[(k, h)] = -c_ij[k] * Y_h
for r in range(L.dimension()):
Arows.append(
[Acomp.get((k, h), zerovec)[r] for k, h in paramspace])
bvec.append(bv[r])
A = matrix(L.base_ring(), Arows)
b = vector(L.base_ring(), bvec)
# solve the linear system Ax=b if possible
try:
coeffs_flat = A.solve_right(b)
except ValueError:
raise ValueError("%s is not a stratifiable Lie algebra" % L)
coeffs = {(k, h): ckh for (k, h), ckh in zip(paramspace, coeffs_flat)}
# define the matrix of the derivation determined by the solution
# in the adapted basis
cols = []
for k in range(L.dimension()):
w_k = weights[k]
Y_k = adapted_basis[k]
hspace = [h for (l, h) in paramspace if l == k]
Yk_im = w_k * Y_k + sum(
(coeffs[(k, h)] * adapted_basis[h] for h in hspace), L.zero())
cols.append(sm.coordinate_vector(Yk_im.to_vector()))
der = matrix(L.base_ring(), cols).transpose()
# the layers of the stratification are V_k = ker(der - kI)
layers = {}
for k in range(len(quots)):
degree = k + 1
B = der - degree * matrix.identity(L.dimension())
adapted_kernel = B.right_kernel()
# convert back to the original basis
Vk_basis = [sm.from_vector(X) for X in adapted_kernel.basis()]
layers[(degree, )] = [
L.from_vector(v) for v in m.submodule(Vk_basis).basis()
]
return grading(L,
layers,
magma=AdditiveAbelianGroup([0]),
projections=True)
def in_new_basis(L, basis, names, check=True, category=None):
r"""
Return an isomorphic copy of the Lie algebra in a different basis.
INPUT:
- ``L`` -- the Lie algebra
- ``basis`` -- a list of elements of the Lie algebra
- ``names`` -- a list of strings to use as names for the new basis
- ``check`` -- (default:``True``) a boolean; if ``True``, verify
that the list ``basis`` is indeed a basis of the Lie algebra
- ``category`` -- (default:``None``) a subcategory of
:class:`FiniteDimensionalLieAlgebrasWithBasis` to apply to the
new Lie algebra.
EXAMPLES:
The method may be used to relabel the elements::
sage: import sys, pathlib
sage: sys.path.append(str(pathlib.Path().absolute()))
sage: from lie_gradings.gradings.utilities import in_new_basis
sage: L.<X,Y> = LieAlgebra(QQ, {('X','Y'): {'Y': 1}})
sage: K.<A,B> = in_new_basis(L, [X, Y])
sage: K[A,B]
B
The new Lie algebra inherits nilpotency::
sage: L = lie_algebras.Heisenberg(QQ, 1)
sage: X,Y,Z = L.basis()
sage: L.category()
Category of finite dimensional nilpotent lie algebras with basis over Rational Field
sage: K.<A,B,C> = in_new_basis(L, [X + Y, Y - X, Z])
sage: K[A,B]
2*C
sage: K[[A,B],A]
0
sage: K.is_nilpotent()
True
sage: K.category()
Category of finite dimensional nilpotent lie algebras with basis over Rational Field
Some properties such as being stratified may in general be lost when
changing the basis, and are therefore not preserved::
sage: L.<X,Y,Z> = LieAlgebra(QQ, 2, step=2)
sage: L.category()
Category of finite dimensional stratified lie algebras with basis over Rational Field
sage: K.<A,B,C> = in_new_basis(L, [Z, X, Y])
sage: K.category()
Category of finite dimensional nilpotent lie algebras with basis over Rational Field
If the property is known to be preserved, an extra category may
be passed to the method::
sage: C = L.category()
sage: K.<A,B,C> = in_new_basis(L, [Z, X, Y], category=C)
sage: K.category()
Category of finite dimensional stratified lie algebras with basis over Rational Field
"""
try:
m = L.module()
except AttributeError:
m = FreeModule(L.base_ring(), L.dimension())
sm = m.submodule_with_basis([X.to_vector() for X in basis])
if check:
# check that new basis is a basis
A = matrix([X.to_vector() for X in basis])
if not A.is_invertible():
raise ValueError("%s is not a basis of the Lie algebra" % basis)
# form dictionary of structure coefficients in the new basis
sc = {}
for (X, nX), (Y, nY) in combinations(zip(basis, names), 2):
Z = X.bracket(Y)
zvec = sm.coordinate_vector(Z.to_vector())
sc[(nX, nY)] = {nW: c for nW, c in zip(names, zvec)}
C = LieAlgebras(L.base_ring()).FiniteDimensional().WithBasis()
C = C.or_subcategory(category)
if L.is_nilpotent():
C = C.Nilpotent()
return LieAlgebra(L.base_ring(), sc, names=names, category=C)
