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