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)))