def basis(self):
r"""
Return the basis of ``self``.
EXAMPLES::
sage: g = LieAlgebra(QQ, cartan_type=['D',4,1])
sage: B = g.basis()
sage: al = RootSystem(['D',4]).root_lattice().simple_roots()
sage: B[al[1]+al[2]+al[4],4]
(E[alpha[1] + alpha[2] + alpha[4]])#t^4
sage: B[-al[1]-2*al[2]-al[3]-al[4],2]
(E[-alpha[1] - 2*alpha[2] - alpha[3] - alpha[4]])#t^2
sage: B[al[4],-2]
(E[alpha[4]])#t^-2
sage: B['c']
c
sage: B['d']
d
"""
K = cartesian_product([self._g.basis().keys(), ZZ])
from sage.sets.finite_enumerated_set import FiniteEnumeratedSet
c = FiniteEnumeratedSet(['c'])
if self._kac_moody:
d = FiniteEnumeratedSet(['d'])
keys = DisjointUnionEnumeratedSets([c, d, K])
else:
keys = DisjointUnionEnumeratedSets([c, K])
return Family(keys, self.monomial)
def __init__(self,R, index_set=None, central_elements=None, category=None,
element_class=None, prefix=None, **kwds):
"""
Initialize self.
TESTS::
sage: V = lie_conformal_algebras.Virasoro(QQ)
sage: TestSuite(V).run()
"""
self._generators = Family(index_set)
E = cartesian_product([index_set, NonNegativeIntegers()])
if central_elements is not None:
self._generators = DisjointUnionEnumeratedSets([index_set,
Family(central_elements)])
E = DisjointUnionEnumeratedSets((cartesian_product([
Family(central_elements), {Integer(0)}]),E))
super(FreelyGeneratedLieConformalAlgebra,self).__init__(R, basis_keys=E,
element_class=element_class, category=category, prefix=prefix,
**kwds)
if central_elements is not None:
self._central_elements = Family(central_elements)
else:
self._central_elements = tuple()
def __init__(self, ct, c, t, base_ring, prefix):
r"""
Initialize ``self``.
EXAMPLES::
sage: k = QQ['c,t']
sage: R = algebras.RationalCherednik(['A',2], k.gen(0), k.gen(1))
sage: TestSuite(R).run() # long time
"""
self._c = c
self._t = t
self._cartan_type = ct
self._weyl = RootSystem(ct).root_lattice().weyl_group(prefix=prefix[1])
self._hd = IndexedFreeAbelianMonoid(ct.index_set(),
prefix=prefix[0],
bracket=False)
self._h = IndexedFreeAbelianMonoid(ct.index_set(),
prefix=prefix[2],
bracket=False)
indices = DisjointUnionEnumeratedSets([self._hd, self._weyl, self._h])
CombinatorialFreeModule.__init__(
self,
base_ring,
indices,
category=Algebras(base_ring).WithBasis().Graded(),
sorting_key=self._genkey)
def __init__(self, R, q):
r"""
Initialize ``self``.
TESTS::
sage: A = algebras.AlternatingCentralExtensionQuantumOnsager(QQ)
sage: TestSuite(A).run() # long time
"""
I = DisjointUnionEnumeratedSets(
[PositiveIntegers(), ZZ,
PositiveIntegers()],
keepkey=True,
facade=True)
monomials = IndexedFreeAbelianMonoid(I, prefix='A', bracket=False)
self._q = q
CombinatorialFreeModule.__init__(
self,
R,
monomials,
prefix='',
bracket=False,
latex_bracket=False,
sorting_key=self._monomial_key,
category=Algebras(R).WithBasis().Filtered())
def basis(self):
"""
Return the basis of ``self``.
EXAMPLES::
sage: L = LieAlgebra(QQ, 3, 'x')
sage: L.Hall().basis()
Disjoint union of Lazy family (graded basis(i))_{i in Positive integers}
"""
from sage.sets.disjoint_union_enumerated_sets import DisjointUnionEnumeratedSets
from sage.sets.positive_integers import PositiveIntegers
from sage.sets.family import Family
return DisjointUnionEnumeratedSets(Family(PositiveIntegers(), self.graded_basis, name="graded basis"))
def __init__(self,
base,
names,
degrees,
max_degree,
category=None,
**kwargs):
r"""
Construct a commutative graded algebra with finite degree.
TESTS::
sage: A.<x,y,z,t> = GradedCommutativeAlgebra(QQ, max_degree=6)
sage: TestSuite(A).run()
sage: A = GradedCommutativeAlgebra(QQ, ('x','y','z'), [2,3,4], max_degree=8)
sage: TestSuite(A).run()
sage: A = GradedCommutativeAlgebra(QQ, ('x','y','z','t'), [1,2,3,4], max_degree=10)
sage: TestSuite(A).run()
"""
from sage.arith.misc import gcd
if max_degree not in ZZ:
raise TypeError('max_degree must be an integer')
if max_degree < max(degrees):
raise ValueError(f'max_degree must not deceed {max(degrees)}')
self._names = names
self.__ngens = len(self._names)
self._degrees = degrees
self._max_deg = max_degree
self._weighted_vectors = WeightedIntegerVectors(degrees)
self._mul_symbol = kwargs.pop('mul_symbol', '*')
self._mul_latex_symbol = kwargs.pop('mul_latex_symbol', '')
step = gcd(degrees)
universe = DisjointUnionEnumeratedSets(
self._weighted_vectors.subset(k)
for k in range(0, max_degree, step))
base_cat = Algebras(
base).WithBasis().Super().Supercommutative().FiniteDimensional()
category = base_cat.or_subcategory(category, join=True)
indices = ConditionSet(universe, self._valid_index)
sorting_key = self._weighted_vectors.grading
CombinatorialFreeModule.__init__(self,
base,
indices,
sorting_key=sorting_key,
category=category)
def basis(self):
r"""
Return the basis of ``self``.
EXAMPLES::
sage: O = lie_algebras.OnsagerAlgebra(QQ)
sage: O.basis()
Lazy family (Onsager monomial(i))_{i in
Disjoint union of Family (Integer Ring, Positive integers)}
"""
from sage.rings.all import ZZ
from sage.sets.disjoint_union_enumerated_sets import DisjointUnionEnumeratedSets
from sage.sets.positive_integers import PositiveIntegers
I = DisjointUnionEnumeratedSets([ZZ, PositiveIntegers()],
keepkey=True, facade=True)
return Family(I, self.monomial, name='Onsager monomial')
def __init__(self, R, g):
r"""
Initialize ``self``.
EXAMPLES::
sage: L = lie_algebras.SymplecticDerivation(QQ, 5)
sage: TestSuite(L).run()
"""
if g < 4:
raise ValueError("g must be at least 4")
cat = LieAlgebras(R).WithBasis().Graded()
self._g = g
d = Family(NonNegativeIntegers(), lambda n: Partitions(n, min_length=2, max_part=2*g))
indices = DisjointUnionEnumeratedSets(d)
InfinitelyGeneratedLieAlgebra.__init__(self, R, index_set=indices, category=cat)
IndexedGenerators.__init__(self, indices, sorting_key=self._basis_key)
def basis(self):
"""
Return a basis of ``self``.
EXAMPLES::
sage: d = lie_algebras.VirasoroAlgebra(QQ)
sage: B = d.basis(); B
Lazy family (basis map(i))_{i in Disjoint union of
Family ({'c'}, Integer Ring)}
sage: B['c']
c
sage: B[3]
d[3]
sage: B[-15]
d[-15]
"""
I = DisjointUnionEnumeratedSets([Set(['c']), ZZ])
return Family(I, self.monomial, name='basis map')
def __init__(self, R):
r"""
Initialize ``self``.
EXAMPLES::
sage: L = lie_algebras.RankTwoHeisenbergVirasoro(QQ)
sage: TestSuite(L).run()
"""
cat = LieAlgebras(R).WithBasis()
self._KI = FiniteEnumeratedSet([1, 2, 3, 4])
self._V = ZZ**2
d = {'K': self._KI, 'E': self._V, 't': self._V}
indices = DisjointUnionEnumeratedSets(d, keepkey=True, facade=True)
InfinitelyGeneratedLieAlgebra.__init__(self,
R,
index_set=indices,
category=cat)
IndexedGenerators.__init__(self, indices, sorting_key=self._basis_key)
def basis(self, region=None):
if hasattr(self, "_domain"):
# hack: we're grading a Steenrod algebra module
gb = []
for idx in range(0, len(self._summands)):
def mkfam(emb, xx):
return xx.map(lambda u: emb(u))
x = self._summands[idx].basis(region)
gb.append(mkfam(self._domain.summand_embedding(idx), x))
if all(fam.cardinality() < Infinity for fam in gb):
category = FiniteEnumeratedSets()
else:
category = EnumeratedSets()
return DisjointUnionEnumeratedSets(gb,
keepkey=False,
category=category)
# this is probably a sample grading...
return set.union(*[x.basis(region) for x in self._summands])
def IntegerListsNN(**kwds):
"""
Lists of nonnegative integers with constraints.
This function returns the union of ``IntegerListsLex(n, **kwds)``
where `n` ranges over all nonnegative integers.
EXAMPLES::
sage: from sage.combinat.integer_lists.nn import IntegerListsNN
sage: L = IntegerListsNN(max_length=3, max_slope=-1)
sage: L
Disjoint union of Lazy family (<lambda>(i))_{i in Non negative integer semiring}
sage: it = iter(L)
sage: for _ in range(20):
....: print(next(it))
[]
[1]
[2]
[3]
[2, 1]
[4]
[3, 1]
[5]
[4, 1]
[3, 2]
[6]
[5, 1]
[4, 2]
[3, 2, 1]
[7]
[6, 1]
[5, 2]
[4, 3]
[4, 2, 1]
[8]
"""
return DisjointUnionEnumeratedSets(
Family(NN, lambda i: IntegerListsLex(i, **kwds)))
def basis(self):
"""
Return the basis of ``self``.
EXAMPLES::
sage: L = lie_algebras.Heisenberg(QQ, oo)
sage: L.basis()
Lazy family (basis map(i))_{i in Disjoint union of Family ({'z'},
The Cartesian product of (Positive integers, {'p', 'q'}))}
sage: L.basis()['z']
z
sage: L.basis()[(12, 'p')]
p12
"""
S = cartesian_product([PositiveIntegers(), ['p','q']])
I = DisjointUnionEnumeratedSets([Set(['z']), S])
def basis_elt(x):
if isinstance(x, str):
return self.monomial(x)
return self.monomial(x[1] + str(x[0]))
return Family(I, basis_elt, name="basis map")
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,
s_coeff,
index_set=None,
central_elements=None,
category=None,
element_class=None,
prefix=None,
names=None,
latex_names=None,
parity=None,
**kwds):
"""
Initialize self.
TESTS::
sage: V = lie_conformal_algebras.NeveuSchwarz(QQ)
sage: TestSuite(V).run()
"""
names, index_set = standardize_names_index_set(names, index_set)
if central_elements is None:
central_elements = tuple()
if names is not None and names != tuple(index_set):
names2 = names + tuple(central_elements)
index_set2 = DisjointUnionEnumeratedSets(
(index_set, Family(tuple(central_elements))))
d = {x: index_set2[i] for i, x in enumerate(names2)}
try:
#If we are given a dictionary with names as keys,
#convert to index_set as keys
s_coeff = {(d[k[0]], d[k[1]]): {
a: {(d[x[1]], x[2]): s_coeff[k][a][x]
for x in s_coeff[k][a]}
for a in s_coeff[k]
}
for k in s_coeff.keys()}
except KeyError:
# We assume the dictionary was given with keys in the
# index_set
pass
issuper = kwds.pop('super', False)
if parity is None:
parity = (0, ) * index_set.cardinality()
else:
issuper = True
try:
assert len(parity) == index_set.cardinality()
except AssertionError:
raise ValueError("parity should have the same length as the "\
"number of generators, got {}".format(parity))
s_coeff = LieConformalAlgebraWithStructureCoefficients\
._standardize_s_coeff(s_coeff, index_set, central_elements,
parity)
if names is not None and central_elements is not None:
names += tuple(central_elements)
self._index_to_pos = {k: i for i, k in enumerate(index_set)}
#Add central parameters to index_to_pos so that we can
#represent names
if central_elements is not None:
for i, ce in enumerate(central_elements):
self._index_to_pos[ce] = len(index_set) + i
default_category = LieConformalAlgebras(
R).WithBasis().FinitelyGenerated()
if issuper:
category = default_category.Super().or_subcategory(category)
else:
category = default_category.or_subcategory(category)
if element_class is None:
element_class = LCAStructureCoefficientsElement
FinitelyFreelyGeneratedLCA.__init__(self,
R,
index_set=index_set,
central_elements=central_elements,
category=category,
element_class=element_class,
prefix=prefix,
names=names,
latex_names=latex_names,
**kwds)
s_coeff = dict(s_coeff)
self._s_coeff = Family({
k: tuple((j, sum(c * self.monomial(i) for i, c in v))
for j, v in s_coeff[k])
for k in s_coeff
})
self._parity = dict(
zip(self.gens(), parity + (0, ) * len(central_elements)))
