definite and indefinite symbolic summation
inert form of sum
Examples for the parametric case
Comparing sum and add
sum(f, k=m..n, parametric, formal=b)
name; summation index
integers or arbitrary expressions
(optional) literal name
(optional) either true or false
expression, of type algebraic, not containing k
This help page contains complete information about the sum command. For basic information on the sum command, see the sum help page.
The sum command (definition of sum) is for symbolic summation. It is used to compute a closed form for an indefinite or definite sum. A typical example is sum(k,k=0..n-1), which returns 12⁢n2−12⁢n.
You can enter the sum command using either the 1-D or 2-D calling sequence. For example, sum(k^2, k) is equivalent to ∑k⁡k2.
To add a finite sequence of values, rather than compute a formula, use the add command. For example, add(k, k=0..9) returns 45. Although the sum command can often be used to compute explicit sums, it is strongly recommended that the add command be used in programs if an explicit sum is needed, in particular, when summing over all elements of a list, Array, Matrix, or similar data structure. For more details and examples, see the Comparing sum and add section in this help page.
The call sum(f, k) computes an indefinite sum of f⁡k with respect to k. It computes an anti-difference g⁡k of f⁡k such that g⁡k+1−g⁡k=f⁡k in general (SumTools[IndefiniteSum][Indefinite]).
The call sum(f, k=m..n) computes the definite sum of f⁡k over the given range m..n. That is, it computes f⁡m+f⁡m+1+...+f⁡n. If m=n+1, the value returned is 0. If m>n+1 are integers, the value returned is -sum(f, k=n+1..m-1). With these conventions, the following holds for all integers l,m,n.
The call sum(f, k=alpha) computes the definite sum of f⁡k summed over the roots of a polynomial given by alpha where alpha must be a RootOf.
The call sum(f, k=expr) substitutes the value of expr for k in f.
For indefinite summation, Maple uses the following methods:
Polynomials are summed using a formula based on Bernoulli polynomials.
Rational functions of k are summed using the algorithm that solves the additive decomposition problem of rational functions. The result is a rational function plus a sum of terms involving the Polygamma function and its derivatives.
Hypergeometric terms, for example, expressions containing factorials (including binomial coefficients) and powers, are summed using Gosper's algorithm and the algorithm that solves the additive decomposition problem of hypergeometric terms. An extension of Gosper's algorithm is used to handle summands which are sums of hypergeometric terms. Koepf's extension to Gosper's algorithm is used to handle j-fold hypergeometric terms.
The method of accurate summation.
Additionally, a library extension mechanism is used to include sums for which an algorithmic approach to finding closed forms is not yet implemented or does not yet exist (that is, the pattern match approach is employed in principal). Currently the computable summands include expressions containing the harmonic function; the logarithmic function; the digamma and polygamma functions; and the sine, cosine, and exponential functions.
For definite sums, if n-m is a small integer, the sum is computed directly by adding up terms. Otherwise, Maple uses the following methods:
Classical telescoping computes a closed form of the definite sum of f over the specified range of k using telescoping method, or Newton-Leibniz's formula. That is, it first computes a closed form of the corresponding indefinite sum.
Creative telescoping method for computing closed forms of definite sums of hypergeometric terms.
Conversion method computes a closed form of the definite sum of f over the specified range of k by first converting the specified sum into hypergeometric functions. If possible, the output is then converted to standard functions.
Note: To access directly one of the above three methods, see Telescoping for (a), CreativeTelescoping for (b), and pFqToStandardFunctions for (c).
As in the case for indefinite sums, the pattern-match approach is also employed.
For definite sums depending on one or more parameters other than the summation variable, the result will in general be a function of these parameters. However, that result may only be correct in a generic sense; it may not be correct for all possible values of the parameter(s). Use option parametric (see the Options section in this help page) to obtain a complete case discussion that is correct for all possible integer values of the parameter(s).
If Maple cannot find a closed form for the summation, the function call is returned. (Maple displays the sum function using a stylized summation sign.)
The capitalized function name Sum is the inert sum function, which simply returns unevaluated. It appears gray so that it is easily distinguished from a returned sum calling sequence.
For divergent sums, the sum command may return infinity, -infinity, unevaluated, or a finite result correct in the sense of analytic continuation. This behavior can be changed by setting the _EnvFormal environment variable or using the formal option. By default, the _EnvFormal environment variable is unassigned.
If _EnvFormal is assigned true, the sum command uses resummation methods to return a finite result for various classes of divergent sums.
If _EnvFormal is assigned false, the sum command uses more convergence testing to detect divergence for infinite sums. It more often returns infinity, -infinity, or unevaluated for divergent sums. This may slow down the computation.
If _EnvFormal is assigned false and the summation bounds are numeric, the sum command also tries harder to detect removable singularities in the interval of summation, and returns an error in that case. By default, sum will try to remove them.
The SumTools[IndefiniteSum] package provides an extension mechanism (AddIndefiniteSum) that is used by sum. Using this facility, you can add summation definitions related to additional special functions.
For numerical summation, see evalf/Sum.
There are two cases where the result of a call to sum may contain inert Sums:
When option parametric is used (see the Examples for the parametric case section in this help page).
When a definite hypergeometric sum can be expressed in terms of nested indefinite sums, these may be returned in Sum form if they are too costly or too complicated to be evaluated in closed form.
If the option parametric is specified for a definite parametric sum, then a result is returned that is valid at least for all possible integer values of the parameter(s) occurring in the summand or the summation bounds. In general, the result is expressed in terms of piecewise functions. The piecewise result may contain FAIL or undefined. Here, FAIL is used to indicate that there is a singularity in the range of summation, and undefined indicates that the sum is divergent.
Using the option formal is equivalent to assigning to the environment variable _EnvFormal (see above): specifying formal=true (or just formal for short) is equivalent to assigning true to _EnvFormal, and formal=false is equivalent to assigning false to _EnvFormal.
2-fold hypergeometric terms:
Sum of hypergeometric terms:
Additive decomposition of hypergeometric terms:
Sum of a logarithm of a rational function (provided the argument of the logarithm has constant sign):
Library extension mechanism:
Pattern match (Abel's type):
Maple returns the call unevaluated if it cannot find a closed form.
If the inert function is used, Maple returns unevaluated.
Some definite sums may return an expression containing inert Sums.
_EnvFormal ≔ true
Setting _EnvFormal to false will also trigger detection of removable singularities in the interval of summation for numerical bounds.
_EnvFormal ≔ false
Error, (in SumTools:-DefiniteSum:-ClosedForm) summand is singular in the interval of summation
_EnvFormal ≔ '_EnvFormal'
Using option formal instead of _EnvFormal has the advantage that the effect is local to the sum command; no "undoing" is necessary.
The summand is a hypergeometric term in the summation variable.
F := binomial(2*k-3,k)/4^k;
Sum(F,k=0..n) = sum(F,k=0..n,parametric);
The summand is a rational function in the summation variable.
Warning, unable to determine if the summand is singular in the interval of summation; try to use assumptions or use the parametric option
sum(1/k, k=a..b, parametric);
The summand is a hypergeometric term in two variables.
Sum((-1)^k*binomial(n, k)*k, k=0..n) = sum((-1)^k*binomial(n, k)*k, k=0..n, parametric);
Without option parametric, the generic answer 0 is returned.
sum((-1)^k*binomial(n, k)*k, k = 0 .. n);
In general, the piecewise expression returned may contain an unevaluated, inert Sum.
s := sum((-1)^k*binomial(n, k)*k^3, k=0..n, parametric);
Use the value command in order to evaluate the piecewise result at a point.
Sum(q^n, n=1..infinity) = sum(q^n, n=1..infinity, parametric);
The sum command tries to find a formula for a definite sum, while the add command adds a finite sequence of terms.
f := add(x^k,k=1..10000):
For short finite sums, the sum command uses the add command.
The add command can be used only if the summation bounds are numeric.
powersum := proc(a,b)
poweradd := proc(a,b)
Error, (in poweradd) unable to execute add
The results from sum and add differ when the upper bound is less than the lower bound.
In contrast to the sum command, the add command has special evaluation rules. Thus, no unevaluation quotes are necessary when summing over an expression that gives an error when evaluated at a non-integer.
v := Vector([1,2,3,4,5]);
Error, bad index into Vector
The summation variable is local to the add command, but not to the sum command. The sum command raises an error if the summation variable has a value.
k := 42;
Error, (in sum) summation variable previously assigned, second argument evaluates to 42 = 1 .. 10
k := 'k':
In contrast to the sum command, the add command is implemented in the Maple kernel. When it is applicable, it is usually much more efficient. An exception to this rule is the case in which there is a large number of terms and the sum command is able to compute a closed form.
t := time():
for i from 1 to 1000 do
time() - t;
for i from 1 to 1000 do
time() - t;
for i from 1 to 100 do
time() - t;