def symmetrized_coordinate_sums(dim, n): """ Return formal symmetrized sum of multi-indices INPUT: - ``dim`` -- integer. The dimension (range of each index). - ``n`` -- integer. The total number of indices. OUTPUT: A symmetrized formal sum of multi-indices (tuples of integers) EXAMPLES:: sage: from sage.modules.tensor_operations import symmetrized_coordinate_sums sage: symmetrized_coordinate_sums(2, 2) ((0, 1) + (1, 0), (0, 0), (1, 1)) """ from sage.structure.formal_sum import FormalSum coordinates = [range(dim) for i in range(n)] table = dict() from sage.categories.cartesian_product import cartesian_product for i in cartesian_product(coordinates): sort_i = tuple(sorted(i)) x = table.get(sort_i, []) x.append([+1, tuple(i)]) table[sort_i] = x return tuple(FormalSum(x) for x in table.values())
def antisymmetrized_coordinate_sums(dim, n): """ Return formal anti-symmetrized sum of multi-indices INPUT: - ``dim`` -- integer. The dimension (range of each index). - ``n`` -- integer. The total number of indices. OUTPUT: An anti-symmetrized formal sum of multi-indices (tuples of integers) EXAMPLES:: sage: from sage.modules.tensor_operations import antisymmetrized_coordinate_sums sage: antisymmetrized_coordinate_sums(3, 2) ((0, 1) - (1, 0), (0, 2) - (2, 0), (1, 2) - (2, 1)) """ from sage.structure.formal_sum import FormalSum table = [] from sage.groups.perm_gps.permgroup_named import SymmetricGroup S_d = SymmetricGroup(n) from sage.combinat.combination import Combinations for i in Combinations(range(dim), n): i = tuple(i) x = [] for g in S_d: x.append([g.sign(), g(i)]) x = FormalSum(x) table.append(x) return tuple(table)
def divisor(self): r""" Return the divisor of self, as a formal sum of CuspFamily objects. EXAMPLES:: sage: e = EtaProduct(12, {1:-336, 2:576, 3:696, 4:-216, 6:-576, 12:-144}) sage: e.divisor() # FormalSum seems to print things in a random order? -131*(Inf) - 50*(c_{2}) + 11*(0) + 50*(c_{6}) + 169*(c_{4}) - 49*(c_{3}) sage: e = EtaProduct(2^8, {8:1,32:-1}) sage: e.divisor() # random -(c_{2}) - (Inf) - (c_{8,2}) - (c_{8,3}) - (c_{8,4}) - (c_{4,2}) - (c_{8,1}) - (c_{4,1}) + (c_{32,4}) + (c_{32,3}) + (c_{64,1}) + (0) + (c_{32,2}) + (c_{64,2}) + (c_{128}) + (c_{32,1}) """ return FormalSum([ (self.order_at_cusp(c), c) for c in AllCusps(self.level())])
def __init__(self, v, parent, check=True, reduce=True): r""" Construct a :class:`Divisor_generic`. INPUT: INPUT: - ``v`` -- object. Usually a list of pairs ``(coefficient,divisor)``. - ``parent`` -- FormalSums(R) module (default: FormalSums(ZZ)) - ``check`` -- bool (default: True). Whether to coerce coefficients into base ring. Setting it to ``False`` can speed up construction. - ``reduce`` -- reduce (default: True). Whether to combine common terms. Setting it to ``False`` can speed up construction. .. WARNING:: The coefficients of the divisor must be in the base ring and the terms must be reduced. If you set ``check=False`` and/or ``reduce=False`` it is your responsibility to pass a valid object ``v``. EXAMPLES:: sage: from sage.schemes.generic.divisor import Divisor_generic sage: from sage.schemes.generic.divisor_group import DivisorGroup sage: Divisor_generic( [(4,5)], DivisorGroup(Spec(ZZ)), False, False) 4*V(5) """ FormalSum.__init__(self, v, parent, check, reduce)
def local_basis(dop, point, order=None): r""" Generalized series expansions the local basis. INPUT: * dop - Differential operator * point - Point where the local basis is to be computed * order (optional) - Number of terms to compute, **starting from each “leftmost” valuation of a group of solutions with valuations differing by integers**. (Thus, the absolute truncation order will be the same for all solutions in such a group, with some solutions having more actual coefficients computed that others.) The default is to choose the truncation order in such a way that the structure of the basis is apparent, and in particular that logarithmic terms appear if logarithms are involved at all in that basis. The corresponding order may be very large in some cases. EXAMPLES:: sage: from ore_algebra import * sage: from ore_algebra.analytic.local_solutions import local_basis sage: Dops, x, Dx = DifferentialOperators(QQ, 'x') sage: local_basis(Dx - 1, 0) [1 + x + 1/2*x^2 + 1/6*x^3] sage: from ore_algebra.analytic.examples import ssw sage: local_basis(ssw.dop3, 0) [t^(-4) + 24*log(t)/t^2 - 48*log(t) - 96*t^2*log(t) - 88*t^2, t^(-2), 1 + 2*t^2] sage: dop = (x^2*(x^2-34*x+1)*Dx^3 + 3*x*(2*x^2-51*x+1)*Dx^2 ....: + (7*x^2-112*x+1)*Dx + (x-5)) sage: local_basis(dop, 0, 3) [1/2*log(x)^2 + 5/2*x*log(x)^2 + 12*x*log(x) + 73/2*x^2*log(x)^2 + 210*x^2*log(x) + 72*x^2, log(x) + 5*x*log(x) + 12*x + 73*x^2*log(x) + 210*x^2, 1 + 5*x + 73*x^2] sage: roots = dop.leading_coefficient().roots(AA) sage: local_basis(dop, roots[1][0], 3) [1 - (-239/12*a+169/6)*(x + 12*sqrt(2) - 17)^2, sqrt(x + 12*sqrt(2) - 17) - (-203/32*a+9)*(x + 12*sqrt(2) - 17)^(3/2) + (-24031/160*a+1087523/5120)*(x + 12*sqrt(2) - 17)^(5/2), x + 12*sqrt(2) - 17 - (-55/6*a+13)*(x + 12*sqrt(2) - 17)^2] TESTS:: sage: local_basis(4*x^2*Dx^2 + (-x^2+8*x-11), 0, 2) [x^(-sqrt(3) + 1/2) + (-4/11*a+2/11)*x^(-sqrt(3) + 3/2), x^(sqrt(3) + 1/2) - (-4/11*a-2/11)*x^(sqrt(3) + 3/2)] sage: local_basis((27*x^2+4*x)*Dx^2 + (54*x+6)*Dx + 6, 0, 2) [1/sqrt(x) + 3/8*sqrt(x), 1 - x] """ from .path import Point point = Point(point, dop) ldop = point.local_diffop() if order is None: ind = ldop.indicial_polynomial(ldop.base_ring().gen()) order = max(dop.order(), ind.dispersion()) + 3 sols = map_local_basis(ldop, lambda ini, bwrec: log_series(ini, bwrec, order), lambda leftmost, shift: {}) dx = SR(dop.base_ring().gen()) - point.value # Working with symbolic expressions here is too complicated: let's try # returning FormalSums. def log_monomial(expo, n, k): expo = simplify_exponent(expo) return dx**(expo + n) * symbolic_log(dx, hold=True)**k cm = get_coercion_model() Coeffs = cm.common_parent(dop.base_ring().base_ring(), point.value.parent(), *(sol.leftmost for sol in sols)) res = [ FormalSum([(c / ZZ(k).factorial(), log_monomial(sol.leftmost, n, k)) for n, vec in enumerate(sol.value) for k, c in reversed(list(enumerate(vec)))], FormalSums(Coeffs)) for sol in sols ] return res