def _o_to_s_on_basis(self, lam): r""" Return the orthogonal symmetric function ``o[lam]`` expanded in the Schur basis, where ``lam`` is a partition. TESTS: Check that this is the inverse:: sage: o = SymmetricFunctions(QQ).o() sage: s = SymmetricFunctions(QQ).s() sage: all(o(s(o[la])) == o[la] for i in range(5) for la in Partitions(i)) True sage: all(s(o(s[la])) == s[la] for i in range(5) for la in Partitions(i)) True """ R = self.base_ring() n = sum(lam) return self._s._from_dict({ mu: R.sum((-1)**j * lrcalc.lrcoef_unsafe(lam, mu, nu) for nu in Partitions(2 * j) if all( nu.arm_length(i, i) == nu.leg_length(i, i) + 1 for i in range(nu.frobenius_rank()))) for j in range(n // 2 + 1) # // 2 for horizontal dominoes for mu in Partitions(n - 2 * j) })
def _s_to_o_on_basis(self, lam): r""" Return the Schur symmetric function ``s[lam]`` expanded in the orthogonal basis, where ``lam`` is a partition. INPUT: - ``lam`` -- a partition OUTPUT: - the expansion of ``s[lam]`` in the orthogonal basis ``self`` EXAMPLES:: sage: Sym = SymmetricFunctions(QQ) sage: s = Sym.schur() sage: o = Sym.orthogonal() sage: o._s_to_o_on_basis(Partition([])) o[] sage: o._s_to_o_on_basis(Partition([4,2,1])) o[1] + 2*o[2, 1] + o[2, 2, 1] + o[3] + o[3, 1, 1] + o[3, 2] + o[4, 1] + o[4, 2, 1] sage: s(o._s_to_o_on_basis(Partition([3,1]))) == s[3,1] True """ R = self.base_ring() n = sum(lam) return self._from_dict({ mu: R.sum( lrcalc.lrcoef_unsafe(lam, mu, [2 * x for x in nu]) for nu in Partitions(j)) for j in range(n // 2 + 1) # // 2 for horizontal dominoes for mu in Partitions(n - 2 * j) })
def _s_to_sp_on_basis(self, lam): r""" Return the Schur symmetric function ``s[lam]`` expanded in the symplectic basis, where ``lam`` is a partition. INPUT: - ``lam`` -- a partition OUTPUT: - the expansion of ``s[lam]`` in the symplectic basis ``self`` EXAMPLES:: sage: Sym = SymmetricFunctions(QQ) sage: s = Sym.schur() sage: sp = Sym.symplectic() sage: sp._s_to_sp_on_basis(Partition([])) sp[] sage: sp._s_to_sp_on_basis(Partition([4,2,1])) sp[2, 1] + sp[3] + sp[3, 1, 1] + sp[3, 2] + sp[4, 1] + sp[4, 2, 1] sage: s(sp._s_to_sp_on_basis(Partition([3,1]))) == s[3,1] True """ R = self.base_ring() n = sum(lam) return self._from_dict({ mu: R.sum( lrcalc.lrcoef_unsafe(lam, mu, sum([[x, x] for x in nu], [])) for nu in Partitions(j)) for j in range(n // 2 + 1) # // 2 for vertical dominoes for mu in Partitions(n - 2 * j) })
def _llt_generic(self, skp, stat): r""" Takes in partition, list of partitions, or a list of skew partitions as well as a function which takes in two partitions and a level and returns a coefficient. INPUT: - ``self`` -- a family of LLT symmetric functions bases - ``skp`` -- a partition or a list of partitions or a list of skew partitions - ``stat`` -- a function which accepts two partitions and a value for the level and returns a coefficient which is a polynomial in a parameter `t`. The first partition is the index of the LLT function, the second partition is the index of the monomial basis element. OUTPUT: - returns the monomial expansion of the LLT symmetric function indexed by ``skp`` EXAMPLES:: sage: L3 = SymmetricFunctions(FractionField(QQ['t'])).llt(3) sage: f = lambda skp,mu,level: QQ(1) sage: L3._llt_generic([3,2,1],f) m[1, 1] + m[2] sage: L3._llt_generic([[2,1],[1],[2]],f) m[1, 1, 1, 1, 1, 1] + m[2, 1, 1, 1, 1] + m[2, 2, 1, 1] + m[2, 2, 2] + m[3, 1, 1, 1] + m[3, 2, 1] + m[3, 3] + m[4, 1, 1] + m[4, 2] + m[5, 1] + m[6] sage: L3._llt_generic([[[2,2],[1]],[[2,1],[]]],f) m[1, 1, 1, 1] + m[2, 1, 1] + m[2, 2] + m[3, 1] + m[4] """ if skp in _Partitions: m = (sum(skp) / self.level()).floor() if m == 0: raise ValueError("level (%s=) must divide %s " % (sum(skp), self.level())) mu = Partitions( ZZ(sum(skp) / self.level()) ) elif isinstance(skp, list) and skp[0] in sage.combinat.skew_partition.SkewPartitions(): #skp is a list of skew partitions skp2 = [Partition(core=[], quotient=[skp[i][0] for i in range(len(skp))])] skp2 += [Partition(core=[], quotient=[skp[i][1] for i in range(len(skp))])] mu = Partitions(ZZ((skp2[0].size()-skp2[1].size()) / self.level())) skp = skp2 elif isinstance(skp, list) and skp[0] in _Partitions: #skp is a list of partitions skp = Partition(core=[], quotient=skp) mu = Partitions( ZZ(sum(skp) / self.level()) ) else: raise ValueError("LLT polynomials not defined for %s"%skp) BR = self.base_ring() return sum([ BR(stat(skp,nu,self.level()).subs(t=self.t))*self._m(nu) for nu in mu])
def antipode_on_basis(self, a): """ Return the antipode of the basis element indexed by ``a``. EXAMPLES:: sage: R = PolynomialRing(ZZ, 'q').fraction_field() sage: q = R.gen() sage: I = HallAlgebra(R, q).monomial_basis() sage: I.antipode_on_basis(Partition([1])) -I[1] sage: I.antipode_on_basis(Partition([2])) 1/q*I[1, 1] - I[2] sage: I.antipode_on_basis(Partition([2,1])) -1/q*I[1, 1, 1] + I[2, 1] sage: R.<q> = LaurentPolynomialRing(ZZ) sage: I = HallAlgebra(R, q).monomial_basis() sage: I.antipode_on_basis(Partition([2,1])) -(q^-1)*I[1, 1, 1] + I[2, 1] """ H = HallAlgebra(self.base_ring(), self._q) cur = self.one() for r in a: q = (-1) ** r * self._q ** (-(r * (r - 1)) // 2) cur *= self(H._from_dict({p: q for p in Partitions(r)})) return cur
def _repr_(self): """ Return a string representation of ``self``. EXAMPLES:: sage: RC = RiggedConfigurations(['A', 4, 1], [[2, 2]]) sage: elt = RC(partition_list=[[2],[2,2],[2,1],[2]])[2] sage: elt # indirect doctest 0[ ][ ]0 -1[ ]-1 <BLANKLINE> sage: Partitions.global_options(convention="french") sage: elt # indirect doctest -1[ ]-1 0[ ][ ]0 <BLANKLINE> sage: Partitions.global_options.reset() """ # If it is empty, return saying so if len(self._list) == 0: return("(/)\n") from sage.combinat.partition import Partitions if Partitions.global_options("convention") == "french": itr = reversed(list(enumerate(self._list))) else: itr = enumerate(self._list) retStr = "" for i, val in itr: retStr += str(self.vacancy_numbers[i]) retStr += "[ ]"*val retStr += str(self.rigging[i]) retStr += "\n" return(retStr)
def __init__(self, t, domain, codomain): """ Initialization of ``self``. INPUT: - ``t`` -- a function taking a monomial in CombinatorialFreeModule(QQ, Partitions()), and returning a (partition, coefficient) list. - ``domain``, ``codomain`` -- parents Construct a function mapping a partition to an element of ``codomain``. This is a temporary quick hack to wrap around the existing symmetrica conversions, without changing their specs. EXAMPLES:: sage: Sym = SymmetricFunctions(QQ[x]) sage: p = Sym.p(); s = Sym.s() sage: def t(x) : [(p,c)] = x; return [ (p,2*c), (p.conjugate(), c) ] sage: f = sage.combinat.sf.sf.SymmetricaConversionOnBasis(t, p, s) sage: f(Partition([3,1])) s[2, 1, 1] + 2*s[3, 1] """ self._domain = domain self.fake_sym = CombinatorialFreeModule(QQ, Partitions()) self._codomain = codomain self._t = t
def __iter__(self): """ An iterator for ``self``. This generates the rooted trees of given size. The algorithm first picks a partition for the sizes of subtrees, then picks appropriate tuples of smaller trees. EXAMPLES:: sage: from sage.combinat.rooted_tree import * sage: RootedTrees(1).list() [[]] sage: RootedTrees(2).list() [[[]]] sage: RootedTrees(3).list() [[[[]]], [[], []]] sage: RootedTrees(4).list() [[[[[]]]], [[[], []]], [[], [[]]], [[], [], []]] """ if self._n == 1: yield self._element_constructor_([]) return from sage.combinat.partition import Partitions from itertools import combinations_with_replacement, product for part in Partitions(self._n - 1): mults = part.to_exp_dict() choices = [] for p, mp in mults.items(): lp = self.__class__(p).list() new_choice = [list(z) for z in combinations_with_replacement(lp, mp)] choices.append(new_choice) for c in product(*choices): yield self.element_class(self._parent_for, sum(c, []))
def _qbar_to_p_on_generator(self, n): r""" Convert a generator of the basis indexed by ``n`` to the power sum basis. INPUT: - ``n`` -- a non-negative integer EXAMPLES:: sage: qbar = SymmetricFunctions(QQ['q'].fraction_field()).qbar('q') sage: qbar._qbar_to_p_on_generator(3) (1/6*q^2-1/3*q+1/6)*p[1, 1, 1] + (1/2*q^2-1/2)*p[2, 1] + (1/3*q^2+1/3*q+1/3)*p[3] sage: qbar = SymmetricFunctions(QQ).qbar(-1) sage: qbar._qbar_to_p_on_generator(3) 2/3*p[1, 1, 1] + 1/3*p[3] """ if n == 1: return self._p([1]) q = self.q BR = self.base_ring() return q**(n-1) * self._p.sum(sum(q**(-i) for i in range(mu[0])) * BR.prod(1 - q**(-p) for p in mu[1:]) * self._p(mu) / mu.centralizer_size() for mu in Partitions(n) if not any(q**p == 1 for p in mu[1:]))
def antipode_on_basis(self, la): """ Return the antipode of the basis element indexed by ``la``. EXAMPLES:: sage: R = PolynomialRing(ZZ, 'q').fraction_field() sage: q = R.gen() sage: H = HallAlgebra(R, q) sage: H.antipode_on_basis(Partition([1,1])) 1/q*H[2] + 1/q*H[1, 1] sage: H.antipode_on_basis(Partition([2])) -1/q*H[2] + ((q^2-1)/q)*H[1, 1] sage: R.<q> = LaurentPolynomialRing(ZZ) sage: H = HallAlgebra(R, q) sage: H.antipode_on_basis(Partition([1,1])) (q^-1)*H[2] + (q^-1)*H[1, 1] sage: H.antipode_on_basis(Partition([2])) -(q^-1)*H[2] - (q^-1-q)*H[1, 1] """ if all(x == 1 for x in la): r = len(la) q = (-1) ** r * self._q ** (-(r * (r - 1)) // 2) return self._from_dict({p: q for p in Partitions(r)}) I = HallAlgebraMonomials(self.base_ring(), self._q) return self(I(self.monomial(la)).antipode())
def __classcall_private__(cls, s, part=None): """ Normalize input to ensure a unique representation. EXAMPLES:: sage: S = SetPartitions(4) sage: T = SetPartitions([1,2,3,4]) sage: S is T True """ if isinstance(s, (int, Integer)): s = frozenset(range(1, s + 1)) else: try: if s.cardinality() == infinity: raise ValueError("The set must be finite") except AttributeError: pass s = frozenset(s) if part is not None: if isinstance(part, (int, Integer)): if len(s) < part: raise ValueError("part must be <= len(set)") else: return SetPartitions_setn(s, part) else: if part not in Partitions(len(s)): raise ValueError("part must be a partition of %s" % len(s)) else: return SetPartitions_setparts(s, Partition(part)) else: return SetPartitions_set(s)
def _repr_(self): """ Return a string representation of ``self``. EXAMPLES:: sage: RC = RiggedConfigurations(['A', 4, 1], [[2, 2]]) sage: elt = RC(partition_list=[[2],[2,2],[2,1],[2]])[2] sage: elt # indirect doctest 0[ ][ ]0 -1[ ]-1 <BLANKLINE> sage: Partitions.global_options(convention="french") sage: elt # indirect doctest -1[ ]-1 0[ ][ ]0 <BLANKLINE> sage: Partitions.global_options.reset() """ # If it is empty, return saying so if len(self._list) == 0: return ("(/)\n") from sage.combinat.partition import Partitions if Partitions.global_options("convention") == "french": itr = reversed(list(enumerate(self._list))) else: itr = enumerate(self._list) retStr = "" for i, val in itr: retStr += str(self.vacancy_numbers[i]) retStr += "[ ]" * val retStr += str(self.rigging[i]) retStr += "\n" return (retStr)
def YoungsLattice(n): """ Return Young's Lattice up to rank `n`. In other words, the poset of partitions of size less than or equal to `n` ordered by inclusion. INPUT: - ``n`` -- a positive integer EXAMPLES:: sage: P = Posets.YoungsLattice(3); P Finite meet-semilattice containing 7 elements sage: P.cover_relations() [[[], [1]], [[1], [1, 1]], [[1], [2]], [[1, 1], [1, 1, 1]], [[1, 1], [2, 1]], [[2], [2, 1]], [[2], [3]]] """ from sage.combinat.partition import Partitions, Partition from sage.misc.flatten import flatten partitions = flatten([list(Partitions(i)) for i in range(n + 1)]) return JoinSemilattice((partitions, Partition.contains)).dual()
def _functorial_compose_gen(self, g, ao): """ Return a generator for the coefficients of the functorial composition of ``self`` with ``g``. EXAMPLES:: sage: E = species.SetSpecies() sage: E2 = species.SetSpecies(size=2) sage: WP = species.SubsetSpecies() sage: P2 = E2*E sage: P2_cis = P2.cycle_index_series() sage: WP_cis = WP.cycle_index_series() sage: g = WP_cis._functorial_compose_gen(P2_cis,0) sage: [next(g) for i in range(5)] [p[], p[1], p[1, 1] + p[2], 4/3*p[1, 1, 1] + 2*p[2, 1] + 2/3*p[3], 8/3*p[1, 1, 1, 1] + 4*p[2, 1, 1] + 2*p[2, 2] + 4/3*p[3, 1] + p[4]] """ p = self.parent().base_ring() n = 0 while True: res = p(0) for s in Partitions(n): t = g._cycle_type(s) q = self.count(t) / s.aut() res += q * p(s) yield res n += 1
def bulgarian_solitaire(n): r""" Return the finite discrete dynamical system defined by Bulgarian solitaire on partitions of size `n`. Let `n` be a nonnegative integer. Let `P` be the set of all integer partitions of size `n`. Let `B : P \to P` be the map that sends each partition `\lambda = (\lambda_1, \lambda_2, \ldots, \lambda_k)` of `n` (with all the `\lambda_i` positive) to `(\lambda_1 - 1, \lambda_2 - 1, \ldots, \lambda_k - 1, k)`, where zero entries have been removed and the remaining entries sorted into decreasing order. (For example, `B(5, 4, 2, 2, 1, 1) = (6, 4, 3, 1, 1)`.) This method yields the finite DDS whose ground set is `P` and whose evolution is `B`. EXAMPLES:: sage: BS = finite_dynamical_systems.bulgarian_solitaire sage: BS(3).evolution()(Partition([3])) [2, 1] sage: BS(3).evolution()(Partition([2, 1])) [2, 1] sage: BS(3).evolution()(Partition([1, 1, 1])) [3] sage: BS(4).evolution()(Partition([4])) [3, 1] sage: BS(4).orbit(Partition([4])) [[4], [3, 1], [2, 2], [2, 1, 1]] sage: BS(4).orbit(Partition([3, 1])) [[3, 1], [2, 2], [2, 1, 1]] sage: BS(7).orbit(Partition([6, 1]), preperiod=True) ([[6, 1], [5, 2], [4, 2, 1], [3, 3, 1], [3, 2, 2], [3, 2, 1, 1]], 2) sage: BS(6).is_homomesic(lambda lam: len(lam)) True sage: BS(6).is_homomesic(lambda lam: lam[0]) True sage: BS(6).is_homomesic(lambda lam: lam[-1]) True sage: BS(8).is_homomesic(lambda lam: len(lam)) True sage: BS(8).is_homomesic(lambda lam: lam[0]) True sage: BS(8).is_homomesic(lambda lam: lam[-1]) False """ from sage.combinat.partition import Partition, Partitions X = Partitions(n) def phi(lam): mu = [p - 1 for p in lam if p > 0] nu = sorted(mu + [len(lam)], reverse=True) return Partition(nu) return FiniteDynamicalSystem(X, phi)
def __iter__(self): r""" Iterate over ``self``. EXAMPLES:: sage: PTC = PrimarySimilarityClassTypes(2) sage: PTC.cardinality() 3 """ n = self._n if self._min[0].divides(n): for par in Partitions(ZZ(n / self._min[0]), starting=self._min[1]): yield self.element_class(self, self._min[0], par) for d in filter(lambda d: d > self._min[0], divisors(n)): for par in Partitions(ZZ(n / d)): yield self.element_class(self, d, par)
def k_schur_noncommutative_variables(self, la): r""" In type `A^{(1)}` this is the `k`-Schur function in noncommutative variables defined by Thomas Lam. REFERENCES: .. [Lam2005] T. Lam, Affine Stanley symmetric functions, Amer. J. Math. 128 (2006), no. 6, 1553--1586. This function is currently only defined in type `A^{(1)}`. INPUT: - ``la`` -- a partition with first part bounded by the rank of the Weyl group EXAMPLES:: sage: A = NilCoxeterAlgebra(WeylGroup(['A',3,1])) sage: A.k_schur_noncommutative_variables([2,2]) u[0,3,1,0] + u[3,1,2,0] + u[1,2,0,1] + u[3,2,0,3] + u[2,0,3,1] + u[2,3,1,2] TESTS:: sage: A = NilCoxeterAlgebra(WeylGroup(['A',3,1])) sage: A.k_schur_noncommutative_variables([]) 1 sage: A.k_schur_noncommutative_variables([1,2]) Traceback (most recent call last): ... AssertionError: [1, 2] is not a partition. sage: A.k_schur_noncommutative_variables([4,2]) Traceback (most recent call last): ... AssertionError: [4, 2] is not a 3-bounded partition. sage: C = NilCoxeterAlgebra(WeylGroup(['C',3,1])) sage: C.k_schur_noncommutative_variables([2,2]) Traceback (most recent call last): ... AssertionError: Weyl Group of type ['C', 3, 1] (as a matrix group acting on the root space) is not affine type A. """ assert self._cartan_type[0] == 'A' and len( self._cartan_type) == 3 and self._cartan_type[ 2] == 1, "%s is not affine type A." % (self._W) assert la in Partitions(), "%s is not a partition." % (la) assert (len(la) == 0 or la[0] < self._W.n ), "%s is not a %s-bounded partition." % (la, self._W.n - 1) Sym = SymmetricFunctions(self._base_ring) h = Sym.homogeneous() ks = Sym.kschur(self._n - 1, 1) f = h(ks[la]) return sum( f.coefficient(x) * self.homogeneous_noncommutative_variables(x) for x in f.support())
def __iter__(self): r""" An iterator for super partitions of degree ``n`` and sector ``m``. EXAMPLES:: sage: SuperPartitions(6,2).cardinality() 28 sage: SuperPartitions(6,4).first() [3, 2, 1, 0; ] """ for r in range(self.n + 1): for p1 in Partitions(r): for p0 in Partitions(self.n - r, max_slope=-1, length=self.m): yield self.element_class(self, [list(p0), list(p1)]) for p0 in Partitions(self.n - r, max_slope=-1, length=self.m - 1): yield self.element_class(self, [list(p0) + [0], list(p1)])
def __init__(self, base_ring): """ EXAMPLES:: sage: A = GradedModulesWithBasis(QQ).example(); A An example of a graded module with basis: the free module on partitions over Rational Field sage: TestSuite(A).run() """ CombinatorialFreeModule.__init__(self, base_ring, Partitions(), category=GradedModulesWithBasis(base_ring))
def _DualGrothendieck(self,la): r""" Returns the expansion of the K-`k`-Schur function in the homogeneous basis. This method is here for caching purposes. INPUT: - ``la`` -- A `k`-bounded partition. OUTPUT: - A symmetric function in the homogeneous basis. EXAMPLES:: sage: g = SymmetricFunctions(QQ).kBoundedSubspace(3,1).K_kschur() sage: g._DualGrothendieck(Partition([2,1])) h[2] + h[2, 1] - h[3] sage: g._DualGrothendieck(Partition([])) h[] sage: g._DualGrothendieck(Partition([4,1])) 0 """ m = la.size() h = SymmetricFunctions(self.base_ring()).h() M = self._DualGrothMatrix(m) vec = [] for i in range(m+1): for x in Partitions(m-i, max_part=self.k): if x == la: vec.append(1) else: vec.append(0) from sage.modules.free_module_element import vector vec = vector(vec) sol = M.solve_right(vec) new_function = h.zero() count = 0 for i in range(m+1): for x in Partitions(m-i, max_part=self.k): new_function+= h(x) * sol[count] count += 1 return new_function
def __init__(self, R): """ TESTS:: sage: s = sage.combinat.combinatorial_algebra.TestAlgebra(QQ) sage: TestSuite(s).run() """ from sage.combinat.partition import Partition, Partitions self._one = Partition([]) CombinatorialAlgebra.__init__(self, R, cc=Partitions())
def _DualGrothMatrix(self, m): r""" Returns the change of basis matrix between the K_kschur basis and the `k`-bounded homogeneous basis. INPUT: - ``m`` -- An integer OUTPUT: - A matrix. EXAMPLES:: sage: g = SymmetricFunctions(QQ).kBoundedSubspace(3,1).K_kschur() sage: g._DualGrothMatrix(3) [ 1 1 1 0 0 0 0] [ 0 1 2 0 0 0 0] [ 0 0 1 0 0 0 0] [ 0 -1 -2 1 1 0 0] [ 0 0 -2 0 1 0 0] [ 0 0 1 0 -1 1 0] [ 0 0 0 0 0 0 1] sage: g._DualGrothMatrix(0) [1] """ new_mat = [] Sym = SymmetricFunctions(self.base_ring()) Q = Sym.kBoundedQuotient(self.k,t=1) mon = Q.km() G = Q.AffineGrothendieckPolynomial for i in range(m+1): for x in Partitions(m-i, max_part = self.k): f = mon(G(x,m)) vec = [] for j in range(m+1): for y in Partitions(m-j, max_part = self.k): vec.append(f.coefficient(y)) new_mat.append(vec) from sage.matrix.constructor import Matrix return Matrix(new_mat)
def cardinality(self): """ Return the cardinality of ``self``. EXAMPLES:: sage: sp = SymmetricGroupRepresentations(4, "specht") sage: sp.cardinality() 5 """ return Partitions(self._n).cardinality()
def list(self): r""" Returns the list of all `k`-cores of length `n`. EXAMPLES:: sage: C = Cores(3,4) sage: C.list() [[4, 2], [3, 1, 1], [2, 2, 1, 1]] """ return [la.to_core(self.k-1) for la in Partitions(self.n, max_part=self.k-1)]
def transition_matrix(self, other, n): """ Return the degree ``n`` transition matrix between ``self`` and ``other``. INPUT: - ``other`` -- a basis in the ring of symmetric functions - ``n`` -- a positive integer The entry in the `i^{th}` row and `j^{th}` column is the coefficient obtained by writing the `i^{th}` element of the basis of ``self`` in terms of the basis ``other``, and extracting the `j^{th}` coefficient. EXAMPLES:: sage: Sym = SymmetricFunctions(QQ); s = Sym.schur() sage: ks3 = Sym.kschur(3,1) sage: ks3.transition_matrix(s,5) [1 1 1 0 0 0 0] [0 1 0 1 0 0 0] [0 0 1 0 1 0 0] [0 0 0 1 0 1 0] [0 0 0 0 1 1 1] sage: Sym = SymmetricFunctions(QQ['t']) sage: s = Sym.schur() sage: ks = Sym.kschur(3) sage: ks.transition_matrix(s,5) [t^2 t 1 0 0 0 0] [ 0 t 0 1 0 0 0] [ 0 0 t 0 1 0 0] [ 0 0 0 t 0 1 0] [ 0 0 0 0 t^2 t 1] """ P = Partitions(n, max_part=self.k) # todo: Q should be set by getting the degree n index set for # `other`. Q = Partitions(n) return matrix( [[other(self[row]).coefficient(col) for col in Q] for row in P] )
def __iter__(self): """ Iterate over ``self``. EXAMPLES:: sage: SetPartitions(3).list() [{{1, 2, 3}}, {{1}, {2, 3}}, {{1, 3}, {2}}, {{1, 2}, {3}}, {{1}, {2}, {3}}] """ for p in Partitions(len(self._set)): for sp in self._iterator_part(p): yield self.element_class(self, sp)
def list(self): r""" Returns the list of all `k`-cores of size `n`. EXAMPLES:: sage: C = Cores(3, size = 4) sage: C.list() [[3, 1], [2, 1, 1]] """ k_cores = filter(lambda x: x.is_core(self.k), Partitions(self.n)) return [Core(x, self.k) for x in k_cores]
def _exp_term(n, R = RationalField()): """ Compute the order-n term of the cycle index series of the species `E` of sets. EXAMPLES:: sage: from sage.combinat.species.generating_series import _exp_term sage: [_exp_term(i) for i in range(4)] [p[], p[1], 1/2*p[1, 1] + 1/2*p[2], 1/6*p[1, 1, 1] + 1/2*p[2, 1] + 1/3*p[3]] """ p = SymmetricFunctions(R).power() return sum(p(part) / part.aut() for part in Partitions(n))
def create_power_values(r, s, poly_degree): list_of_power_values = [] for partition_set in Partitions(poly_degree, max_length=r + s).list(): partition_set = list(partition_set) if max(partition_set) < max(r, s): if len(partition_set) == r + s: list_of_power_values.append(partition_set) else: while len(partition_set) < r + s: partition_set.append(0) list_of_power_values.append(partition_set) return list_of_power_values
def __iter__(self): r""" TESTS:: sage: list(AbelianStrata(genus=1)) [H(0)] """ if self._genus == 0: pass elif self._genus == 1: yield AbelianStratum(0, marked_separatrix=self._marked_separatrix) else: if self._marked_separatrix == 'no': for p in Partitions(2*self._genus-2): yield AbelianStratum(p) else: for p in Partitions(2*self._genus-2): l = list(p) for t in set(l): i = l.index(t) yield AbelianStratum([t] + l[:i] + l[i+1:], marked_separatrix=self._marked_separatrix)
def list(self): r""" Returns the list of all `k`-cores of size `n`. EXAMPLES:: sage: C = Cores(3, size = 4) sage: C.list() [[3, 1], [2, 1, 1]] """ return [ Core(x, self.k) for x in Partitions(self.n) if x.is_core(self.k) ]
def _repr_(self): """ Return a string representation of ``self``. INPUT: - ``half_width_boxes`` -- (Default: ``True``) Display the partition using half width boxes EXAMPLES:: sage: RC = RiggedConfigurations(['B', 2, 1], [[2, 2]]) sage: elt = RC(partition_list=[[2],[2,1]])[1] sage: elt -2[][]-2 -2[]-2 <BLANKLINE> sage: RiggedConfigurations.use_half_width_boxes_type_B = False sage: elt -2[ ][ ]-2 -2[ ]-2 <BLANKLINE> sage: RiggedConfigurations.use_half_width_boxes_type_B = True """ # If it is empty, return saying so if len(self._list) == 0: return "(/)\n" from sage.combinat.partition import Partitions if Partitions.global_options("convention") == "french": itr = reversed(list(enumerate(self._list))) else: itr = enumerate(self._list) ret_str = "" from sage.combinat.rigged_configurations.rigged_configurations import RiggedConfigurations if RiggedConfigurations.use_half_width_boxes_type_B: box_str = "[]" else: box_str = "[ ]" vac_num_width = max(len(str(vac_num)) for vac_num in self.vacancy_numbers) for i, val in itr: ret_str += ("{:>" + str(vac_num_width) + "}").format(self.vacancy_numbers[i]) ret_str += box_str * val ret_str += str(self.rigging[i]) ret_str += "\n" return ret_str
def _repr_(self): """ Return a string representation of ``self``. EXAMPLES:: sage: RC = RiggedConfigurations(['A', 4, 1], [[2, 2]]) sage: elt = RC(partition_list=[[2],[2,2],[2,1],[2]])[2] sage: elt 0[ ][ ]0 -1[ ]-1 <BLANKLINE> sage: Partitions.global_options(convention="french") sage: elt -1[ ]-1 0[ ][ ]0 <BLANKLINE> sage: Partitions.global_options.reset() """ # If it is empty, return saying so if len(self._list) == 0: return "(/)\n" from sage.combinat.partition import Partitions if Partitions.global_options("convention") == "French": itr = reversed(list(enumerate(self._list))) else: itr = enumerate(self._list) ret_str = "" vac_num_width = max(len(str(vac_num)) for vac_num in self.vacancy_numbers) for i, val in itr: ret_str += ("{:>" + str(vac_num_width) + "}").format(self.vacancy_numbers[i]) ret_str += "[ ]" * val ret_str += str(self.rigging[i]) ret_str += "\n" return ret_str
def GL_irreducible_character(n, mu, KK): r""" Return the character of the irreducible module indexed by ``mu`` of `GL(n)` over the field ``KK``. INPUT: - ``n`` -- a positive integer - ``mu`` -- a partition of at most ``n`` parts - ``KK`` -- a field OUTPUT: a symmetric function which should be interpreted in ``n`` variables to be meaningful as a character EXAMPLES: Over `\QQ`, the irreducible character for `\mu` is the Schur function associated to `\mu`, plus garbage terms (Schur functions associated to partitions with more than `n` parts):: sage: from sage.algebras.schur_algebra import GL_irreducible_character sage: sbasis = SymmetricFunctions(QQ).s() sage: z = GL_irreducible_character(2, [2], QQ) sage: sbasis(z) s[2] sage: z = GL_irreducible_character(4, [3, 2], QQ) sage: sbasis(z) -5*s[1, 1, 1, 1, 1] + s[3, 2] Over a Galois field, the irreducible character for `\mu` will in general be smaller. In characteristic `p`, for a one-part partition `(r)`, where `r = a_0 + p a_1 + p^2 a_2 + \dots`, the result is (see [GreenPoly]_, after 5.5d) the product of `h[a_0], h[a_1]( pbasis[p]), h[a_2] ( pbasis[p^2]), \dots,` which is consistent with the following :: sage: from sage.algebras.schur_algebra import GL_irreducible_character sage: GL_irreducible_character(2, [7], GF(3)) m[4, 3] + m[6, 1] + m[7] """ mbasis = SymmetricFunctions(QQ).m() r = sum(mu) M = SchurTensorModule(KK, n, r) A = M._schur SGA = M._sga # make ST the superstandard tableau of shape mu from sage.combinat.tableau import from_shape_and_word ST = from_shape_and_word(mu, range(1, r + 1), convention="English") # make ell the reading word of the highest weight tableau of shape mu ell = [i + 1 for i, l in enumerate(mu) for dummy in range(l)] e = M.basis()[tuple(ell)] # the element e_l # This is the notation `\{X\}` from just before (5.3a) of [GreenPoly]_. S = SGA._indices BracC = SGA._from_dict({S(x.tuple()): x.sign() for x in ST.column_stabilizer()}, remove_zeros=False) f = e * BracC # M.action_by_symmetric_group_algebra(e, BracC) # [Green, Theorem 5.3b] says that a basis of the Carter-Lusztig # module V_\mu is given by taking this f, and multiplying by all # xi_{i,ell} with ell as above and i semistandard. carter_lusztig = [] for T in SemistandardTableaux(mu, max_entry=n): i = tuple(flatten(T)) schur_rep = schur_representative_from_index(i, tuple(ell)) y = A.basis()[schur_rep] * e # M.action_by_Schur_alg(A.basis()[schur_rep], e) carter_lusztig.append(y.to_vector()) # Therefore, we now have carter_lusztig as a list giving the basis # of `V_\mu` # We want to think of expressing this character as a sum of monomial # symmetric functions. # We will determine a basis element for each m_\lambda in the # character, and we want to keep track of them by \lambda. # That means that we only want to pick out the basis elements above for # those semistandard words whose content is a partition. contents = Partitions(r, max_length=n).list() # all partitions of r, length at most n # JJ will consist of a list for each element of `contents`, # recording the list # of semistandard tableaux words with that content # graded_basis will consist of the a corresponding basis element graded_basis = [] JJ = [] for i in range(len(contents)): graded_basis.append([]) JJ.append([]) for T in SemistandardTableaux(mu, max_entry=n): i = tuple(flatten(T)) # Get the content of T con = [0] * n for a in i: con[a - 1] += 1 try: P = Partition(con) P_index = contents.index(P) JJ[P_index].append(i) schur_rep = schur_representative_from_index(i, tuple(ell)) x = A.basis()[schur_rep] * f # M.action_by_Schur_alg(A.basis()[schur_rep], f) graded_basis[P_index].append(x.to_vector()) except ValueError: pass # There is an inner product on the Carter-Lusztig module V_\mu; its # maximal submodule is exactly the kernel of the inner product. # Now, for each possible partition content, we look at the graded piece of # that degree, and we record how these elements pair with each of the # elements of carter_lusztig. # The kernel of this pairing is the part of this graded piece which is # not in the irreducible module for \mu. length = len(carter_lusztig) phi = mbasis.zero() for aa in range(len(contents)): mat = [] for kk in range(len(JJ[aa])): temp = [] for j in range(length): temp.append(graded_basis[aa][kk].inner_product(carter_lusztig[j])) mat.append(temp) angle = Matrix(mat) phi += (len(JJ[aa]) - angle.nullity()) * mbasis(contents[aa]) return phi