convert to inert sum representation - a formal power series
convert to sum representation
Optional arguments for Global conversions
convert( expr, Sum, opts, Sum_opts );
convert( expr, sum, opts, Sum_opts );
valid Maple expression, equation, set, list, or similar structure
(optional) arguments as described in convert/to_special_function
(optional) any of the following arguments intrinsic to a Sum:
expansionvariable = x
indicates the expansion variable - the rhs could be any name
dummy = n
indicates the dummy (summation) variable - the rhs could be any name
x = a
the lhs and rhs respectively indicate the expansion variable and expansion point
a function name with an expansion variable as argument, representing the "kth coefficient" of the series expansion
method = value
indicates the method to be used; value can be any of: default, Local, Global, rational, exponential, hypergeometric
makereal = value
indicates that a series with real coefficients should be returned; value can be true or false
differentialorder = n
indicates an upper bound for the order the intermediate differential equation used to represent expr; n can be any positive integer
dir = value
indicates the direction of the limit computation for initial values; value can be any of: default, left, right, real, or complex
recurrence = value
indicates that the output should be a recurrence for b(k) when a closed form for these coefficients, to represent expr as a Sum, cannot be computed; value can be true or false
The convert(expr, Sum) command attempts representing the given expr as a "formal power series", expressed using the inert Sum command. For that purpose, two approaches are used: one is a Global approach, which aims at representing the whole expression as a Sum of terms of the form cn⁢x−an, with a representing a constant and cn a coefficient not depending on x, the main variable; another one is Local and consists of replacing, in expr, occurrences of mathematical functions in by their Sum representations - in this case the terms summed are of the generic form cn⁢f⁡xn, where f(x) is a mapping of x not involving functions for which a sum representation is known. The conversion to Sum does not include computing the sums.
All the optional arguments accepted by the Maple convert/to_special_function network are allowed, so that one can restrict the application of convert to Sum in different manners.
The convert(expr, sum) command does the same as convert(expr, Sum) followed by an attempt to compute all the Sums introduced, and here again to override the default behavior you can use any of the optional arguments described in convert/to_special_function.
By default, a combination of the Global and Local methods is used; in this approach, when possible, all mathematical functions found expr are converted, and in cases of nested mathematical functions, or linear combination of functions which admit a hypergeometric representation, a Global conversion is attempted first, taking advantage of the properties of such expressions. By invoking this conversion with the optional argument method = Global (or skip = Local), or with method = Local (or skip = Global), respectively only the Global or the Local methods are used.
NOTE: The use of the following optional arguments automatically make convert/Sum to skip the Local method and only work using the Global method: x = a, makereal = true, differentialorder = n, dir = value, method = value, indicating one of the methods rational, exponential, hypergeometric, and recurrence = value. Also, powers of x are not converted unless you explicitly request that using the optional argument include = powers (all powers) or include = radicals (only fractional powers).
The implementation for Global conversions is based on references  and  (see at the end), and mainly expands meromorphic expressions of certain type (see next paragraph) into their corresponding Laurent-Puiseux series as a Sum of terms of the form ∑k=0∞⁡b⁡k⁢x−am⁢k+sq, where m is called the symmetry number, s is the shift number, and a is the expansion point. If the expansion point is not given, then an expansion around the origin is computed; if the expansion point is at infinity, then the command searches for an asymptotic (possibly divergent) series. This implementation also works for formal Laurent-Puiseux series, and in certain cases of logarithmic singularities.
The algorithm: given expr to be represented as a Sum, consists of first representing expr as a homogeneous linear differential equation with polynomial coefficients with appropriate initial conditions, an ODE-IVP (see gfun[holexprtodiffeq], PDEtools[dpolyform]), then finding a formal power series for it (see Slode[FPseries], dsolve, formal_series, dsolve, formal_solution).
The types of expressions that Global conversions can handle are:
expressions of hypergeometric type, where b(k+m)/b(k) is a rational function of k for some integer m
expressions of exponential type, which satisfy a linear homogeneous differential equation with constant coefficients
expressions of rational type, which are either rational or have a rational derivative
linear combinations of hypergeometric functions are treated by the Petkovsek-van-Hoeij algorithm; see LREtools[hypergeomsols].
differentialorder: a positive integer n (default: n=4); upper bound for the order of the differential equation searched for. This controls the depth of the search for a differential equation for expr. Higher values of n will increase the chance to find the solution, but increase the running time as well.
dir: one of default, left, right, real, or complex; direction of the limit computation for initial values. If a, the expansion point, is finite, then the default is dir = complex. If a is either infinity or -infinity, then the default is dir = real. See also limit. This optional argument can be used to request real or one-sided (e.g. asymptotic) series.
makereal: either true or false (default); makereal = true (or just makereal for short) indicates that a series with real coefficients should be returned.
method: one of default, Global, Local, hypergeometric, rational, or exponential. Specifies the method that will be used; the default method uses an internal selection strategy. See the Examples below for an illustration of the various methods.
recurrence: either true or false (default). If recurrence = true (or recurrence for short) is given and the coefficients entering the formal power series can be computed in closed form, then the output is a recurrence for b(k).
The 7 functions in the "Ei_related" class are:
By default, the following command only converts Sum into sum.
Verify lhs = rhs
Note that some conversions are possible only under assumptions.
* Partial match of "sum" against topic "sum_form".
Therefore, the following is not converted.
The conversion occurs only when you specify the proper assumptions.
By default, powers, or rational expressions, are not converted to Sum unless explicitly requested, e.g. using the include = powers (could also be include = ratpoly or include = radicals) optional argument; make the dummy summation be n
The output above is computed using the Global algorithm; let's see the output representing first, Locally, each of the powers found in ee as MeijerG functions, then representing these functions as Sums
Expansions around t = 0 or t = 1; note the indication of the expansion variable when indicating the expansion point
This command also computes around t = 0
For composite mathematical functions, first the Global approach is attempted
The following examples illustrate the use of the method 'rational', 'exponential', 'hypergeometric'.
User-defined functions are handled provided their derivative is known. You define the derivative of the function g as follows (see diff for more information).
`diff/g` := proc(a,x) g(a)*diff(a,x) end proc;
Indefinite integrals are handled.
Linear combinations of hypergeometric functions are recognized; compare the default output with the output requesting makereal = true
In the next example, the output is expressed in terms of algebraic numbers.
Maple's special functions are handled.
In this case, convert/Sum returns without expanding
because a conversion exists only for restricted values of the parameters; these restrictions are seen via (see FunctionAdvisor):