def __init__(self, base_ring=QQ['t'], prefix='S'): r""" Initialize ``self``. EXAMPLES:: sage: S = ShiftingOperatorAlgebra(QQ['t']) sage: TestSuite(S).run() """ indices = ShiftingSequenceSpace() cat = Algebras(base_ring).WithBasis() CombinatorialFreeModule.__init__(self, base_ring, indices, prefix=prefix, bracket=False, category=cat) # Setup default conversions sym = SymmetricFunctions(base_ring) self._sym_h = sym.h() self._sym_s = sym.s() self._sym_h.register_conversion( self.module_morphism(self._supp_to_h, codomain=self._sym_h)) self._sym_s.register_conversion( self.module_morphism(self._supp_to_s, codomain=self._sym_s))
def __init__(self, R, k, t=None): """ EXAMPLES:: sage: kSchurFunctions(QQ, 3).base_ring() doctest:1: DeprecationWarning: Deprecation warning: Please use SymmetricFunctions(QQ).kschur() instead! See http://trac.sagemath.org/5457 for details. Univariate Polynomial Ring in t over Rational Field sage: kSchurFunctions(QQ, 3, t=1).base_ring() Rational Field sage: ks3 = kSchurFunctions(QQ, 3) sage: ks3 == loads(dumps(ks3)) True """ self.k = k self._name = "k-Schur Functions at level %s" % k self._prefix = "ks%s" % k self._element_class = kSchurFunctions_t.Element if t is None: R = R['t'] self.t = R.gen() elif t not in R: raise ValueError, "t (=%s) must be in R (=%s)" % (t, R) else: self.t = R(t) if str(t) != 't': self._name += " with t=%s" % self.t self._s_to_self_cache = s_to_k_cache.get(k, {}) self._self_to_s_cache = k_to_s_cache.get(k, {}) # This is an abuse, since kschur functions do not form a basis of Sym from sage.combinat.sf.sf import SymmetricFunctions Sym = SymmetricFunctions(R) sfa.SymmetricFunctionAlgebra_generic.__init__(self, Sym) # so we need to take some counter measures self._basis_keys = sage.combinat.partition.Partitions(max_part=k) # The following line is just a temporary workaround to keep # the repr of those k-schur as they were before #13404; since # they are deprecated, there is no need to bother about them. self.rename(self._name + " over %s" % self.base_ring()) self._s = Sym.s() # temporary until Hom(GradedHopfAlgebrasWithBasis work better) category = sage.categories.all.ModulesWithBasis(self.base_ring()) # This really should be a conversion, not a coercion (it can fail) self.register_coercion( SetMorphism(Hom(self._s, self, category), self._s_to_self)) self._s.register_coercion( SetMorphism(Hom(self, self._s, category), self._self_to_s))
def __init__(self, R, k, t=None): """ EXAMPLES:: sage: kSchurFunctions(QQ, 3).base_ring() doctest:1: DeprecationWarning: Deprecation warning: Please use SymmetricFunctions(QQ).kschur() instead! See http://trac.sagemath.org/5457 for details. Univariate Polynomial Ring in t over Rational Field sage: kSchurFunctions(QQ, 3, t=1).base_ring() Rational Field sage: ks3 = kSchurFunctions(QQ, 3) sage: ks3 == loads(dumps(ks3)) True """ self.k = k self._name = "k-Schur Functions at level %s"%k self._prefix = "ks%s"%k self._element_class = kSchurFunctions_t.Element if t is None: R = R['t'] self.t = R.gen() elif t not in R: raise ValueError, "t (=%s) must be in R (=%s)"%(t,R) else: self.t = R(t) if str(t) != 't': self._name += " with t=%s"%self.t self._s_to_self_cache = s_to_k_cache.get(k, {}) self._self_to_s_cache = k_to_s_cache.get(k, {}) # This is an abuse, since kschur functions do not form a basis of Sym from sage.combinat.sf.sf import SymmetricFunctions Sym = SymmetricFunctions(R) sfa.SymmetricFunctionAlgebra_generic.__init__(self, Sym) # so we need to take some counter measures self._basis_keys = sage.combinat.partition.Partitions(max_part=k) # The following line is just a temporary workaround to keep # the repr of those k-schur as they were before #13404; since # they are deprecated, there is no need to bother about them. self.rename(self._name+" over %s"%self.base_ring()) self._s = Sym.s() # temporary until Hom(GradedHopfAlgebrasWithBasis work better) category = sage.categories.all.ModulesWithBasis(self.base_ring()) # This really should be a conversion, not a coercion (it can fail) self .register_coercion(SetMorphism(Hom(self._s, self, category), self._s_to_self)) self._s.register_coercion(SetMorphism(Hom(self, self._s, category), self._self_to_s))
def polarizationSpace(P, generators, verbose=False, row_symmetry=None, use_commutativity=False, side="down"): """ Starting from polynomials (generators)of the polynomial ring in one set of variables (possibly with additional inert variables), constructs the space obtained by polarization. The possible values for row_symmetry : - "permutation" : the action of the symmetric group on the rows - "euler+intersection" or "decompose" or "multipolarization" for stategies on lie algebras INPUT: - `P` -- a diagonal polynomial ring (or assymmetric version) - `generators`: polynomials in one set of variables (and possibly inert variables) OUTPUT: `F` -- a Subspace EXAMPLES:: sage: load("derivative_space.py") sage: P = DiagonalPolynomialRing(QQ, 3, 2, inert=1) sage: mu = Partition([3]) sage: basis = DerivativeHarmonicSpace(QQ, mu.size()).basis_by_shape(Partition([2,1])) sage: generators = {} sage: for gen in basis : ....: d = P.multidegree((P(gen))) ....: if d in generators.keys(): ....: generators[d] += [P(gen)] ....: else: ....: generators[d] = [P(gen)] sage: generators {(2, 0): [1/3*x00^2 - 2/3*x00*x01 + 2/3*x01*x02 - 1/3*x02^2], (1, 0): [-2*x00 + 2*x02]} sage: S = polarizationSpace(P, generators) sage: S.basis() {(0, 1): (x10 - x12,), (2, 0): (-1/2*x00^2 + x00*x01 - x01*x02 + 1/2*x02^2,), (1, 0): (x00 - x02,), (1, 1): (x00*x10 - x01*x10 - x00*x11 + x02*x11 + x01*x12 - x02*x12,), (0, 2): (1/2*x10^2 - x10*x11 + x11*x12 - 1/2*x12^2,)} sage: basis = DerivativeVandermondeSpaceWithInert(QQ, mu).basis_by_shape(Partition([1,1,1])) sage: generators = {P.multidegree(P(gen)): [P(gen) for gen in g] for (d,g) in basis.iteritems()} sage: generators {(3, 0): [-x00^2*x01 + x00*x01^2 + x00^2*x02 - x01^2*x02 - x00*x02^2 + x01*x02^2]} sage: S = polarizationSpace(P, generators) sage: S.basis() {(1, 2): (-1/2*x01*x10^2 + 1/2*x02*x10^2 - x00*x10*x11 + x01*x10*x11 + 1/2*x00*x11^2 - 1/2*x02*x11^2 + x00*x10*x12 - x02*x10*x12 - x01*x11*x12 + x02*x11*x12 - 1/2*x00*x12^2 + 1/2*x01*x12^2,), (3, 0): (x00^2*x01 - x00*x01^2 - x00^2*x02 + x01^2*x02 + x00*x02^2 - x01*x02^2,), (0, 3): (x10^2*x11 - x10*x11^2 - x10^2*x12 + x11^2*x12 + x10*x12^2 - x11*x12^2,), (1, 1): (-x01*x10 + x02*x10 + x00*x11 - x02*x11 - x00*x12 + x01*x12,), (2, 1): (-x00*x01*x10 + 1/2*x01^2*x10 + x00*x02*x10 - 1/2*x02^2*x10 - 1/2*x00^2*x11 + x00*x01*x11 - x01*x02*x11 + 1/2*x02^2*x11 + 1/2*x00^2*x12 - 1/2*x01^2*x12 - x00*x02*x12 + x01*x02*x12,)} sage: mu = Partition([2,1]) sage: basis = DerivativeVandermondeSpaceWithInert(QQ, mu).basis_by_shape(Partition([2,1])) sage: generators = {P.multidegree(P(gen)): [P(gen) for gen in g] for (d,g) in basis.iteritems()} sage: generators {(0, 0): [-theta00 + theta02]} sage: S = polarizationSpace(P, generators) sage: S.basis() {(0, 0): (theta00 - theta02,)} """ S = SymmetricFunctions(QQ) s = S.s() m = S.m() r = P._r if isinstance(P, DiagonalAntisymmetricPolynomialRing): antisymmetries = P._antisymmetries else: antisymmetries = None if row_symmetry in ("euler+intersection", "decompose", "multipolarization") : # The hilbert series will be directly expressed in terms of the # dimensions of the highest weight spaces, thus as a symmetric # function in the Schur basis def hilbert_parent(dimensions): return s.sum_of_terms([Partition(d), c] for d,c in dimensions.iteritems() if c) elif row_symmetry == "permutation": def hilbert_parent(dimensions): return s(m.sum_of_terms([Partition(d), c] for d,c in dimensions.iteritems()) ).restrict_partition_lengths(r, exact=False) else: def hilbert_parent(dimensions): return s(S.from_polynomial(P._hilbert_parent(dimensions)) ).restrict_partition_lengths(r,exact=False) operators = polarization_operators_by_multidegree(P, side=side, row_symmetry=row_symmetry, min_degree=1 if row_symmetry and row_symmetry!="permutation" else 0) #ajout operateurs Steenrod #for i in range(1, r): # for d in [2,3]: # operators[P._grading_set((-d+1 if j==i else 0 for j in range(0,r)))] = [functools.partial(P.steenrod_op, i=i, k=d)] if row_symmetry == "euler+intersection": operators[P._grading_set.zero()] = [ functools.partial(lambda v,i: P.polarization(P.polarization(v, i+1, i, 1, antisymmetries=antisymmetries), i, i+1, 1, antisymmetries=antisymmetries), i=i) for i in range(r-1)] elif row_symmetry == "decompose": def post_compose(f): return lambda x: [q for (q,word) in P.highest_weight_vectors_decomposition(f(x))] operators = {d: [post_compose(op) for op in ops]for d, ops in operators.iteritems()} elif row_symmetry == "multipolarization": F = HighestWeightSubspace(generators, ambient=self, add_degrees=add_degree, degree=P.multidegree, hilbert_parent = hilbert_parent, antisymmetries=antisymmetries, verbose=verbose) return F operators_by_degree = {} for degree,ops in operators.iteritems(): d = sum(degree) operators_by_degree.setdefault(d,[]) operators_by_degree[d].extend(ops) ranks = {} for d, ops in operators_by_degree.iteritems(): ranker = rank_from_list(ops) for op in ops: ranks[op] = (d, ranker(op)) ranker = ranks.__getitem__ def extend_word(word, op): new_word = word + [ranker(op)] if use_commutativity and sorted(new_word) != new_word: return None return new_word if row_symmetry == "permutation": add_deg = add_degree_symmetric else: add_deg = add_degree F = Subspace(generators, operators=operators, add_degrees=add_deg, degree=P.multidegree, hilbert_parent = hilbert_parent, extend_word=extend_word, verbose=verbose) F._antisymmetries = antisymmetries return F