def __init__(self, crystals, facade, keepkey, category, **options):
"""
TESTS::
sage: C = crystals.Letters(['A',2])
sage: B = crystals.DirectSum([C,C], keepkey=True)
sage: B
Direct sum of the crystals Family (The crystal of letters for type ['A', 2], The crystal of letters for type ['A', 2])
sage: B.cartan_type()
['A', 2]
sage: from sage.combinat.crystals.direct_sum import DirectSumOfCrystals
sage: isinstance(B, DirectSumOfCrystals)
True
"""
if facade:
Parent.__init__(self, facade=tuple(crystals), category=category)
else:
Parent.__init__(self, category=category)
DisjointUnionEnumeratedSets.__init__(self, crystals, keepkey=keepkey, facade=facade)
self.rename("Direct sum of the crystals {}".format(crystals))
self._keepkey = keepkey
self.crystals = crystals
if len(crystals) == 0:
raise ValueError("The direct sum is empty")
else:
assert(crystal.cartan_type() == crystals[0].cartan_type() for crystal in crystals)
self._cartan_type = crystals[0].cartan_type()
if keepkey:
self.module_generators = [ self(tuple([i,b])) for i in range(len(crystals))
for b in crystals[i].module_generators ]
else:
self.module_generators = sum( (list(B.module_generators) for B in crystals), [])
def __init__(self, max_entry=None):
r"""
Initialize ``self``.
TESTS::
sage: CT = CompositionTableaux()
sage: TestSuite(CT).run()
"""
self.max_entry = max_entry
CT_n = lambda n: CompositionTableaux_size(n, max_entry)
DisjointUnionEnumeratedSets.__init__(self,
Family(NonNegativeIntegers(), CT_n),
facade=True, keepkey = False)
def __init__(self):
"""
TESTS::
sage: sum(x**len(t) for t in
....: set(RootedTree(t) for t in OrderedTrees(6)))
x^5 + x^4 + 3*x^3 + 6*x^2 + 9*x
sage: sum(x**len(t) for t in RootedTrees(6))
x^5 + x^4 + 3*x^3 + 6*x^2 + 9*x
sage: TestSuite(RootedTrees()).run() # long time
"""
DisjointUnionEnumeratedSets.__init__(
self, Family(NonNegativeIntegers(), RootedTrees_size),
facade=True, keepkey=False)
def __init__(self, n=None):
r"""
EXAMPLES::
sage: from sage.combinat.baxter_permutations import BaxterPermutations_all
sage: BaxterPermutations_all()
Baxter permutations
"""
self.element_class = Permutations().element_class
from sage.categories.examples.infinite_enumerated_sets import NonNegativeIntegers
from sage.sets.family import Family
DisjointUnionEnumeratedSets.__init__(self,
Family(NonNegativeIntegers(),
BaxterPermutations_size),
facade=False, keepkey=False)
def __init__(self, weight):
"""
TESTS::
sage: C = WeightedIntegerVectors([2,1,3])
sage: C.category()
Category of facade infinite enumerated sets with grading
sage: TestSuite(C).run()
"""
self._weights = weight
from sage.sets.all import Family, NonNegativeIntegers
# Use "partial" to make the basis function (with the weights
# argument specified) pickleable. Otherwise, it seems to
# cause problems...
from functools import partial
F = Family(NonNegativeIntegers(), partial(WeightedIntegerVectors, weight=weight))
cat = (SetsWithGrading(), InfiniteEnumeratedSets())
DisjointUnionEnumeratedSets.__init__(self, F, facade=True, keepkey=False,
category=cat)
def __init__(self, crystals, **options):
"""
TESTS::
sage: C = CrystalOfLetters(['A',2])
sage: B = DirectSumOfCrystals([C,C], keepkey=True)
sage: B
Direct sum of the crystals Family (The crystal of letters for type ['A', 2], The crystal of letters for type ['A', 2])
sage: B.cartan_type()
['A', 2]
sage: isinstance(B, DirectSumOfCrystals)
True
"""
if options.has_key('keepkey'):
keepkey = options['keepkey']
else:
keepkey = False
# facade = options['facade']
if keepkey:
facade = False
else:
facade = True
category = Category.meet([Category.join(crystal.categories()) for crystal in crystals])
Parent.__init__(self, category = category)
DisjointUnionEnumeratedSets.__init__(self, crystals, keepkey = keepkey, facade = facade)
self.rename("Direct sum of the crystals %s"%(crystals,))
self._keepkey = keepkey
self.crystals = crystals
if len(crystals) == 0:
raise ValueError, "The direct sum is empty"
else:
assert(crystal.cartan_type() == crystals[0].cartan_type() for crystal in crystals)
self._cartan_type = crystals[0].cartan_type()
if keepkey:
self.module_generators = [ self(tuple([i,b])) for i in range(len(crystals))
for b in crystals[i].module_generators ]
else:
self.module_generators = sum( (list(B.module_generators) for B in crystals), [])
def __init__(self):
"""
TESTS::
sage: from sage.combinat.ordered_tree import OrderedTrees_all
sage: B = OrderedTrees_all()
sage: B.cardinality()
+Infinity
sage: it = iter(B)
sage: (next(it), next(it), next(it), next(it), next(it))
([], [[]], [[], []], [[[]]], [[], [], []])
sage: next(it).parent()
Ordered trees
sage: B([])
[]
sage: B is OrderedTrees_all()
True
sage: TestSuite(B).run() # long time
"""
DisjointUnionEnumeratedSets.__init__(
self, Family(NonNegativeIntegers(), OrderedTrees_size),
facade=True, keepkey=False)
def __init__(self):
"""
TESTS::
sage: from sage.combinat.binary_tree import BinaryTrees_all
sage: B = BinaryTrees_all()
sage: B.cardinality()
+Infinity
sage: it = iter(B)
sage: (it.next(), it.next(), it.next(), it.next(), it.next())
(., [., .], [., [., .]], [[., .], .], [., [., [., .]]])
sage: it.next().parent()
Binary trees
sage: B([])
[., .]
sage: B is BinaryTrees_all()
True
sage: TestSuite(B).run()
"""
DisjointUnionEnumeratedSets.__init__(
self, Family(NonNegativeIntegers(), BinaryTrees_size),
facade=True, keepkey = False)
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 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 __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)))
