def __classcall_private__(cls, R, s_coeff, names=None, index_set=None,
category=None, **kwds):
"""
Normalize input to ensure a unique representation.
EXAMPLES:
If the variable order is specified, the order of structural
coefficients does not matter::
sage: from sage.algebras.lie_algebras.nilpotent_lie_algebra import NilpotentLieAlgebra_dense
sage: L1.<x,y,z> = NilpotentLieAlgebra_dense(QQ, {('x','y'): {'z': 1}})
sage: L2.<x,y,z> = NilpotentLieAlgebra_dense(QQ, {('y','x'): {'z': -1}})
sage: L1 is L2
True
If the variables are implicitly defined by the structural coefficients,
the ordering may be different and the Lie algebras will be considered
different::
sage: from sage.algebras.lie_algebras.nilpotent_lie_algebra import NilpotentLieAlgebra_dense
sage: L1 = NilpotentLieAlgebra_dense(QQ, {('x','y'): {'z': 1}})
sage: L2 = NilpotentLieAlgebra_dense(QQ, {('y','x'): {'z': -1}})
sage: L1
Nilpotent Lie algebra on 3 generators (x, y, z) over Rational Field
sage: L2
Nilpotent Lie algebra on 3 generators (y, x, z) over Rational Field
sage: L1 is L2
False
Constructed using two different methods from :class:`LieAlgebra`
yields the same Lie algebra::
sage: sc = {('X','Y'): {'Z': 1}}
sage: C = LieAlgebras(QQ).Nilpotent().FiniteDimensional().WithBasis()
sage: L1.<X,Y,Z> = LieAlgebra(QQ, sc, category=C)
sage: L2 = LieAlgebra(QQ, sc, nilpotent=True, names=['X','Y','Z'])
sage: L1 is L2
True
"""
if not names:
# extract names from structural coefficients
names = []
for (X, Y), d in s_coeff.items():
if X not in names: names.append(X)
if Y not in names: names.append(Y)
for k in d:
if k not in names: names.append(k)
from sage.structure.indexed_generators import standardize_names_index_set
names, index_set = standardize_names_index_set(names, index_set)
s_coeff = LieAlgebraWithStructureCoefficients._standardize_s_coeff(
s_coeff, index_set)
cat = LieAlgebras(R).FiniteDimensional().WithBasis().Nilpotent()
category = cat.or_subcategory(category)
return super(NilpotentLieAlgebra_dense, cls).__classcall__(
cls, R, s_coeff, names, index_set, category=category, **kwds)
def __init__(self, R, names, index_set, category, **kwds):
"""
Initialize ``self``.
EXAMPLES::
sage: L = LieAlgebra(QQ, 3, 'x', abelian=True)
sage: TestSuite(L).run()
"""
cat = LieAlgebras(R).FiniteDimensional().WithBasis().Nilpotent()
category = cat.or_subcategory(category)
LieAlgebraWithStructureCoefficients.__init__(self, R, Family({}), names,
index_set, category, **kwds)
def __init__(self, R, n):
"""
Initialize ``self``.
EXAMPLES::
sage: g = lie_algebras.gl(QQ, 4)
sage: TestSuite(g).run()
TESTS:
Check that :trac:`23266` is fixed::
sage: gl2 = lie_algebras.gl(QQ, 2)
sage: isinstance(gl2.basis().keys(), FiniteEnumeratedSet)
True
sage: Ugl2 = gl2.pbw_basis()
sage: prod(Ugl2.gens())
PBW['E_0_0']*PBW['E_0_1']*PBW['E_1_0']*PBW['E_1_1']
"""
MS = MatrixSpace(R, n, sparse=True)
one = R.one()
names = []
gens = []
for i in range(n):
for j in range(n):
names.append('E_{0}_{1}'.format(i,j))
mat = MS({(i,j):one})
mat.set_immutable()
gens.append(mat)
self._n = n
category = LieAlgebras(R).FiniteDimensional().WithBasis()
from sage.sets.finite_enumerated_set import FiniteEnumeratedSet
index_set = FiniteEnumeratedSet(names)
LieAlgebraFromAssociative.__init__(self, MS, tuple(gens),
names=tuple(names),
index_set=index_set,
category=category)
def is_ideal(self, A):
"""
Return if ``self`` is an ideal of ``A``.
EXAMPLES::
sage: L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example()
sage: a, b, c = L.lie_algebra_generators()
sage: I = L.ideal([2*a - c, b + c])
sage: I.is_ideal(L)
True
sage: L.<x,y> = LieAlgebra(QQ, {('x','y'):{'x':1}})
sage: L.is_ideal(L)
True
sage: F = LieAlgebra(QQ, 'F', representation='polynomial')
sage: L.is_ideal(F)
Traceback (most recent call last):
...
NotImplementedError: A must be a finite dimensional Lie algebra
with basis
"""
if A == self:
return True
if A not in LieAlgebras(
self.base_ring()).FiniteDimensional().WithBasis():
raise NotImplementedError("A must be a finite dimensional"
" Lie algebra with basis")
B = self.basis()
AB = A.basis()
try:
b_mat = matrix(
A.base_ring(),
[A.bracket(b, ab).to_vector() for b in B for ab in AB])
except (ValueError, TypeError):
return False
return b_mat.row_space().is_submodule(self.module())
def __init__(self, R):
r"""
Initialize ``self``.
EXAMPLES::
sage: ACE = lie_algebras.AlternatingCentralExtensionOnsagerAlgebra(QQ)
sage: TestSuite(ACE).run()
sage: B = ACE.basis()
sage: A1, A2, Am2 = B[0,1], B[0,2], B[0,-2]
sage: B1, B2, Bm2 = B[1,1], B[1,2], B[1,-2]
sage: TestSuite(ACE).run(elements=[A1,A2,Am2,B1,B2,Bm2,ACE.an_element()])
"""
cat = LieAlgebras(R).WithBasis()
from sage.rings.integer_ring import ZZ
from sage.sets.disjoint_union_enumerated_sets import DisjointUnionEnumeratedSets
I = DisjointUnionEnumeratedSets([ZZ, ZZ], keepkey=True, facade=True)
IndexedGenerators.__init__(self, I)
InfinitelyGeneratedLieAlgebra.__init__(self,
R,
index_set=I,
category=cat)
def __init__(self, R, ct, e, f, h):
"""
Initialize ``self``.
EXAMPLES::
sage: g = lie_algebras.sl(QQ, 3, representation='matrix')
sage: TestSuite(g).run()
TESTS:
Check that :trac:`23266` is fixed::
sage: sl2 = lie_algebras.sl(QQ, 2, 'matrix')
sage: isinstance(sl2.indices(), FiniteEnumeratedSet)
True
"""
n = len(e)
names = ['e%s'%i for i in range(1, n+1)]
names += ['f%s'%i for i in range(1, n+1)]
names += ['h%s'%i for i in range(1, n+1)]
category = LieAlgebras(R).FiniteDimensional().WithBasis()
from sage.sets.finite_enumerated_set import FiniteEnumeratedSet
index_set = FiniteEnumeratedSet(names)
LieAlgebraFromAssociative.__init__(self, e[0].parent(),
gens=tuple(e + f + h),
names=tuple(names),
index_set=index_set,
category=category)
self._cartan_type = ct
gens = tuple(self.gens())
i_set = ct.index_set()
self._e = Family(dict( (i, gens[c]) for c,i in enumerate(i_set) ))
self._f = Family(dict( (i, gens[n+c]) for c,i in enumerate(i_set) ))
self._h = Family(dict( (i, gens[2*n+c]) for c,i in enumerate(i_set) ))
def __init__(self, R, n):
"""
Initialize ``self``.
EXAMPLES::
sage: L = lie_algebras.Heisenberg(QQ, 2, representation="matrix")
sage: TestSuite(L).run()
"""
HeisenbergAlgebra_fd.__init__(self, n)
MS = MatrixSpace(R, n + 2, sparse=True)
one = R.one()
p = tuple(MS({(0, i): one}) for i in range(1, n + 1))
q = tuple(MS({(i, n + 1): one}) for i in range(1, n + 1))
z = (MS({(0, n + 1): one}), )
names = tuple('p%s' % i for i in range(1, n + 1))
names = names + tuple('q%s' % i for i in range(1, n + 1)) + ('z', )
cat = LieAlgebras(R).Nilpotent().FiniteDimensional().WithBasis()
LieAlgebraFromAssociative.__init__(self,
MS,
p + q + z,
names=names,
index_set=names,
category=cat)
def __classcall_private__(cls,
R,
s_coeff,
names=None,
index_set=None,
category=None,
**kwds):
"""
Normalize input to ensure a unique representation.
EXAMPLES:
If the variable order is specified, the order of structural
coefficients does not matter::
sage: from sage.algebras.lie_algebras.nilpotent_lie_algebra import NilpotentLieAlgebra_dense
sage: L1.<x,y,z> = NilpotentLieAlgebra_dense(QQ, {('x','y'): {'z': 1}})
sage: L2.<x,y,z> = NilpotentLieAlgebra_dense(QQ, {('y','x'): {'z': -1}})
sage: L1 is L2
True
If the variables are implicitly defined by the structural coefficients,
the ordering may be different and the Lie algebras will be considered
different::
sage: from sage.algebras.lie_algebras.nilpotent_lie_algebra import NilpotentLieAlgebra_dense
sage: L1 = NilpotentLieAlgebra_dense(QQ, {('x','y'): {'z': 1}})
sage: L2 = NilpotentLieAlgebra_dense(QQ, {('y','x'): {'z': -1}})
sage: L1
Nilpotent Lie algebra on 3 generators (x, y, z) over Rational Field
sage: L2
Nilpotent Lie algebra on 3 generators (y, x, z) over Rational Field
sage: L1 is L2
False
Constructed using two different methods from :class:`LieAlgebra`
yields the same Lie algebra::
sage: sc = {('X','Y'): {'Z': 1}}
sage: C = LieAlgebras(QQ).Nilpotent().FiniteDimensional().WithBasis()
sage: L1.<X,Y,Z> = LieAlgebra(QQ, sc, category=C)
sage: L2 = LieAlgebra(QQ, sc, nilpotent=True, names=['X','Y','Z'])
sage: L1 is L2
True
"""
if not names:
# extract names from structural coefficients
names = []
for (X, Y), d in s_coeff.items():
if X not in names: names.append(X)
if Y not in names: names.append(Y)
for k in d:
if k not in names: names.append(k)
from sage.structure.indexed_generators import standardize_names_index_set
names, index_set = standardize_names_index_set(names, index_set)
s_coeff = LieAlgebraWithStructureCoefficients._standardize_s_coeff(
s_coeff, index_set)
cat = LieAlgebras(R).FiniteDimensional().WithBasis().Nilpotent()
category = cat.or_subcategory(category)
return super(NilpotentLieAlgebra_dense,
cls).__classcall__(cls,
R,
s_coeff,
names,
index_set,
category=category,
**kwds)
def __init__(self, R, cartan_type):
r"""
Initialize ``self``.
TESTS::
sage: L = LieAlgebra(QQ, cartan_type=['A',2])
sage: TestSuite(L).run() # long time
"""
self._cartan_type = cartan_type
RL = cartan_type.root_system().root_lattice()
alpha = RL.simple_roots()
p_roots = list(RL.positive_roots_by_height())
n_roots = [-x for x in p_roots]
self._p_roots_index = {al: i for i,al in enumerate(p_roots)}
alphacheck = RL.simple_coroots()
roots = frozenset(RL.roots())
num_sroots = len(alpha)
one = R.one()
# Determine the signs for the structure coefficients from the root system
# We first create the special roots
sp_sign = {}
for i,a in enumerate(p_roots):
for b in p_roots[i+1:]:
if a + b not in p_roots:
continue
# Compute the sign for the extra special pair
x, y = (a + b).extraspecial_pair()
if (x, y) == (a, b): # If it already is an extra special pair
if (x, y) not in sp_sign:
# This swap is so the structure coefficients match with GAP
if (sum(x.coefficients()) == sum(y.coefficients())
and str(x) > str(y)):
y,x = x,y
sp_sign[(x, y)] = -one
sp_sign[(y, x)] = one
continue
if b - x in roots:
t1 = ((b-x).norm_squared() / b.norm_squared()
* sp_sign[(x, b-x)] * sp_sign[(a, y-a)])
else:
t1 = 0
if a - x in roots:
t2 = ((a-x).norm_squared() / a.norm_squared()
* sp_sign[(x, a-x)] * sp_sign[(b, y-b)])
else:
t2 = 0
if t1 - t2 > 0:
sp_sign[(a,b)] = -one
elif t2 - t1 > 0:
sp_sign[(a,b)] = one
sp_sign[(b,a)] = -sp_sign[(a,b)]
# Function to construct the structure coefficients (up to sign)
def e_coeff(r, s):
p = 1
while r - p*s in roots:
p += 1
return p
# Now we can compute all necessary structure coefficients
s_coeffs = {}
for i,r in enumerate(p_roots):
# [e_r, h_i] and [h_i, f_r]
for ac in alphacheck:
c = r.scalar(ac)
if c == 0:
continue
s_coeffs[(r, ac)] = {r: -c}
s_coeffs[(ac, -r)] = {-r: -c}
# [e_r, f_r]
s_coeffs[(r, -r)] = {alphacheck[j]: c
for j, c in r.associated_coroot()}
# [e_r, e_s] and [e_r, f_s] with r != +/-s
# We assume s is positive, as otherwise we negate
# both r and s and the resulting coefficient
for j, s in enumerate(p_roots[i+1:]):
j += i+1 # Offset
# Since h(s) >= h(r), we have s - r > 0 when s - r is a root
# [f_r, e_s]
if s - r in p_roots:
c = e_coeff(r, -s)
a, b = s-r, r
if self._p_roots_index[a] > self._p_roots_index[b]: # Note a != b
c *= -sp_sign[(b, a)]
else:
c *= sp_sign[(a, b)]
s_coeffs[(-r, s)] = {a: -c}
s_coeffs[(r, -s)] = {-a: c}
# [e_r, e_s]
a = r + s
if a in p_roots:
# (r, s) is a special pair
c = e_coeff(r, s) * sp_sign[(r, s)]
s_coeffs[(r, s)] = {a: c}
s_coeffs[(-r, -s)] = {-a: -c}
# Lastly, make sure a < b for all (a, b) in the coefficients and flip if necessary
for k in s_coeffs.keys():
a,b = k[0], k[1]
if self._basis_key(a) > self._basis_key(b):
s_coeffs[(b,a)] = [(index, -v) for index,v in s_coeffs[k].items()]
del s_coeffs[k]
else:
s_coeffs[k] = s_coeffs[k].items()
names = ['e{}'.format(i) for i in range(1, num_sroots+1)]
names += ['f{}'.format(i) for i in range(1, num_sroots+1)]
names += ['h{}'.format(i) for i in range(1, num_sroots+1)]
category = LieAlgebras(R).FiniteDimensional().WithBasis()
index_set = p_roots + list(alphacheck) + n_roots
names = tuple(names)
from sage.sets.finite_enumerated_set import FiniteEnumeratedSet
index_set = FiniteEnumeratedSet(index_set)
LieAlgebraWithStructureCoefficients.__init__(self, R, s_coeffs, names, index_set,
category, prefix='E', bracket='[',
sorting_key=self._basis_key)
def __classcall_private__(cls,
I,
ambient=None,
names=None,
index_set=None,
category=None):
r"""
Normalize input to ensure a unique representation.
EXAMPLES:
Specifying the ambient Lie algebra is not necessary::
sage: from sage.algebras.lie_algebras.quotient import LieQuotient_finite_dimensional_with_basis
sage: L.<X,Y> = LieAlgebra(QQ, {('X','Y'): {'X': 1}})
sage: Q1 = LieQuotient_finite_dimensional_with_basis(X, ambient=L)
sage: Q2 = LieQuotient_finite_dimensional_with_basis(X)
sage: Q1 is Q2
True
Variable names are extracted from the ambient Lie algebra by default::
sage: Q3 = L.quotient(X, names=['Y'])
sage: Q1 is Q3
True
"""
if not isinstance(I, LieSubalgebra_finite_dimensional_with_basis):
# assume I is an element or list of elements of some lie algebra
if ambient is None:
if not isinstance(I, (list, tuple)):
ambient = I.parent()
else:
ambient = I[0].parent()
I = ambient.ideal(I)
if ambient is None:
ambient = I.ambient()
if not ambient.base_ring().is_field():
raise NotImplementedError("quotients over non-fields "
"not implemented")
# extract an index set from a complementary basis to the ideal
I_supp = [X.leading_support() for X in I.leading_monomials()]
inv = ambient.basis().inverse_family()
sorted_indices = [inv[X] for X in ambient.basis()]
index_set = [i for i in sorted_indices if i not in I_supp]
if names is None:
amb_names = dict(zip(sorted_indices, ambient.variable_names()))
names = [amb_names[i] for i in index_set]
elif isinstance(names, str):
if len(index_set) == 1:
names = [names]
else:
names = [
'%s_%d' % (names, k + 1) for k in range(len(index_set))
]
names, index_set = standardize_names_index_set(names, index_set)
cat = LieAlgebras(ambient.base_ring()).FiniteDimensional().WithBasis()
if ambient in LieAlgebras(ambient.base_ring()).Nilpotent():
cat = cat.Nilpotent()
category = cat.Subquotients().or_subcategory(category)
sup = super(LieQuotient_finite_dimensional_with_basis, cls)
return sup.__classcall__(cls,
I,
ambient,
names,
index_set,
category=category)
def __init__(self,
R,
s_coeff,
names,
index_set,
category=None,
prefix=None,
bracket=None,
latex_bracket=None,
string_quotes=None,
**kwds):
"""
Initialize ``self``.
EXAMPLES::
sage: L = LieAlgebra(QQ, 'x,y', {('x','y'): {'x':1}})
sage: TestSuite(L).run()
"""
default = (names != tuple(index_set))
if prefix is None:
if default:
prefix = 'L'
else:
prefix = ''
if bracket is None:
bracket = default
if latex_bracket is None:
latex_bracket = default
if string_quotes is None:
string_quotes = default
#self._pos_to_index = dict(enumerate(index_set))
self._index_to_pos = {k: i for i, k in enumerate(index_set)}
if "sorting_key" not in kwds:
kwds["sorting_key"] = self._index_to_pos.__getitem__
cat = LieAlgebras(R).WithBasis().FiniteDimensional().or_subcategory(
category)
FinitelyGeneratedLieAlgebra.__init__(self, R, names, index_set, cat)
IndexedGenerators.__init__(self,
self._indices,
prefix=prefix,
bracket=bracket,
latex_bracket=latex_bracket,
string_quotes=string_quotes,
**kwds)
self._M = FreeModule(R, len(index_set))
# Transform the values in the structure coefficients to elements
def to_vector(tuples):
vec = [R.zero()] * len(index_set)
for k, c in tuples:
vec[self._index_to_pos[k]] = c
vec = self._M(vec)
vec.set_immutable()
return vec
self._s_coeff = {(self._index_to_pos[k[0]], self._index_to_pos[k[1]]):
to_vector(s_coeff[k])
for k in s_coeff.keys()}
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)
