# Maple packages: powseries

The `powseries` package is an implementation of the objects in, and operations over, the (unitary) ring of formal power series. This is actually a subset of the full algebraic notion due to certain restrictions:

• The coefficient ring is always composed of Maple expressions. This works since - with a little caution - Maple expressions built with ``+``, ``*``, and `1` can be viewed as forming a (commutative) unitary ring. The caution we must note is that for complicated expressions the default level of simplification in Maple may not be sufficient to notice when, for example, the expression for given coefficient is equal to zero. In practice this would tend to be an usual situation to run into when using this particular package, but it should be kept in mind.
• Since the coefficient ring of Maple expressions is commutative, the resulting formal power series ring implemented by `powseries` is commutative.
• The coefficients for a given series must be specified in a finite way by specifying a single recurrence relation with a single index variable, together with an optional finite number of values for particular coefficients (referred to as 'initial conditions' in the Maple help on `powcreate`).
• The monomials are always over a single indeterminant (ie: one variable).

The primary resulting limitation to remember is that you can neither create power series with multivariate monomials, nor create the isomorphic equivalent which is a formal power series with a coefficient ring that is itself based on a (different) ring of formal power series. In other words, there is no way with `powseries` to create (for example) the formal power series equivalent of the 2-variable polynomial `x*y`. If you do need such a capability, it is possible to implement the second (isomorphic) approach with the `Gauss` package, in particular by making use of the `UnivariatePowerSeries` category. Similarly, since `powseries` is effectively limited to using a commutative coefficient ring, to create a non-commutative ring of formal power series you would also need to make use of `Gauss`.

## Getting Started

Starting from the Maple prompt (`>`) the command:

`> with(powseries);`

will prepare you to use all the routines contained in the `powseries` package. Online help information for this package is available with the command:

`> ?powseries`

For each of the `powseries` routines, detailed online help is available with the command (using `add` as an example):

`> ?powseries,add`

## Summary

The routines in `powseries` represent formal power series as a particular kind of Maple `proc` that is created by `powcreate`, and not as a `series` datatype. If `X` is such an object, then X(1) would return the value of the coefficient for the monomial term `x^1`, and `X(2)` would return the coefficient for the monomial term `x^2`, etc. It is not the case that `X(n)` for a variable argument named `n` will return a general algebraic expression for an arbitrary coefficient. It will simply be returned unevaluated.

`add` - add one or more formal power series.
Example: `result := add(F1, F2, F3, F4):`

`compose` - compose two formal power series.
Example: `result := compose(F1,F2):`
This works if and only if `F2(0)=0`. Algebraically speaking, the composition is also supposed to exist when `F2(0)<>0` and `F1` is a polynomial, but the `powseries` routines have no way to distinguish when a formal power series is only a polynomial. In such situations, you should instead use `evalpow` with a polynomial expression in `F2`.

`evalpow` - evaluate an arithmetic expression in formal power series.
Example: `result := evalpow(3*F1^2+inverse(F2)):`

`inverse` - form the multiplicative inverse (ie: reciprocal) formal power series.
Example: `result := inverse(F):`
This works if and only if `F(0)<>0`.

`multconst` - multiply a formal power series by a constant.
Example: `result := multconst(F, 17):`

`multiply` - multiply two formal power series.
Example: `result := multiply(F1,F2):`

`negative` - negate a formal power series.
Example: `result := negative(F):`
This is faster but otherwise has the same effect as `multconst(F,-1)`.

`powcreate` - create a formal power series.
Example: `powcreate(F(i)=i!,F(0)=0):`
The argument `F` should be an unassigned variable name, which `powcreate` will use as the name for the `proc` that it creates. Remember that in some circumstances you may need to delay evaluation of the right-hand side of the recurrence equation. You will need to experiment to find the best way to do this for your particular situation, but remember that right quotes (`'`) can come in handy.

`powdiff` - take the derivative of a formal power series.
Example: `result := powdiff(F):`
Perform the natural term-by-term differentiation with respect to the variable that the power series is based on.

`powexp` - form the exponential of a formal power series.
Example: `result := powexp(F):`
This generates the formal power series corresponding to the composition `exp(F)`.

`powint` - take the integral of a formal power series.
Example: `result := powint(F):`
Perform the natural term-by-term integration with respect to the variable that the power series is based on.

`powlog` - form the logarithm of a formal power series.
Example: `result := powlog(F):`
This generates the formal power series corresponding to the composition `log(1-F)`, which is well defined if and only if `F(0)<>0`.

`powpoly` - convert a single-variable polynomial into a formal power series.
Example: `result := powpoly(a*x^2+1,x):`
This takes the polynomial in `x` and returns the corresponding formal power series such that `result(0)=1`, `result(2)=a`, and all other coefficients are `0`.

`powsolve` - formal power series solution to a system of linear differential equations.
Example: `result := powsolve(diff(f(x),x)=f(x),f(0)=0):`
The function argument `f` in this case is an unassigned name, and not formal power series. It is important to remember that the resulting power series solution is only a formal solution to the system, and not necessarily valid as an analytic solution. For instance, as an ODE the Riccati equation has a formal power series solution which is of no use in an analytic context.

`quotient` - perform division of formal power series.
Example: `result := quotient(F1,F2):`
This is faster but otherwise has the same effect as `multiply(F1,inverse(F2))`. As a result, the quotient is defined if and only if `F2(0)<>0`.

`reversion` - perform reversion of formal power series.
Example: `result := reversion(F1,F2):`
The relationship of the reversion process to the composition operation is analogous to the relationship of the division process to the multiplication operation. In other words, just as `inverse` forms the multiplicative inverse of a formal power series, `reversion` can be used (amongst other things) to find the compositional inverse of a formal power series. Reversion is well defined only when `F1(0)=0`, `F1(1)=1`, and `F2(0)=0`. The solution has the property that `compose(F1,result)=F2`.

`subtract` - subtract one formal power series from another.
Example: `result := subtract(F1,F2):`
This is faster but otherwise has the same effect as `add(F1,negative(F2))`.

`tpsform` - convert a formal power series into a truncated series.
Example: `result := tpsform(F,x,3):`
This returns a `series` data structure with the specified variable name and containing the specified number of initial terms from the original formal power series.

## Example

```> # Let's get started.
with(powseries):

> # Define F to be the Maclaurin series for sin(x).
powcreate(F(i)=(D@@i)(sin)(0)/i!);

> # Examine the coefficients for the terms x^0, ... x^8.
F(i)\$i=0..8;

0  1  0  -1/6  0  1/120  0  -1/5040  0

> # Find the compositional inverse of F,
# ie: find G such that F(G(x))=x.
X := powpoly(x,x):
G := reversion(F,X):

> # Now check to see that G is the compositional inverse.
# The order term O(x^6) indicates the point at which the
# formal power series was truncated.
tpsform(compose(F,G),x);

x+O(x^6)

> # Similarly:
tpsform(compose(G,F),x);

x+O(x^6)

> # Note that we could have created F using 'diff' and
# 'subs' but it is trickier because we must delay the
# substitution of x=0 until after the n-th order
# derivative is actually taken, and we also have to
# handle the F(0) case separately since diff(f(x),x\$0)
# isn't a valid use of the 'diff' command.  In the
# case above we didn't run into this problem;
# (D@@0) worked because it is the identity operator.
F := 'F':
powcreate(F(i)='subs'(x=0,diff(sin(x),x\$i)/i!),F(0)=0);

> # Some power series don't have a reciprocal.
inverse(X);

Error, (in powseries/inverse) inverse will have pole at zero

> # Similarly, some don't have a compositional inverse.
reversion(F,X);

Error, (in powseries/reversion) F,
does not have necessary coeffs. in constant and 1st order terms

> # This is how you compose a formal power series
# with a polynomial.
powcreate(C(i)=(D@@i)(cos)(0)/i!);
result := eval(subs(x=C,'evalpow'(7*x^2+1))):

> # It couldn't have been done if 7*x^2+1 was converted
# to a formal power series:
P := powpoly(7*x^2+1,x):
compose(P,C);

Error, (in powseries/compose) C, must have coefficient of x^0 = zero
```

## Related Features

• You can created truncated power series using the standard Maple library routines `series` and `taylor`.
• The `Gauss` package contains the `UnivariatePowerSeries` category and the `LazyUnivariatePowerSeries` domain for representing formal power series.
• More routines for univariate power series exist in the `calculus` portion of the Maple share library, in particular `FPS`, `gdev`, and `gfun`.

## Literature References

• Abell & Braselton's Maple V by Example discusses the application of `powseries` routines to the solution of ordinary differential equations.
• Geddes et al's Algorithms for Computer Algebra contains extensive material on the algebraic nature, computer representation, and algorithmic manipulation of polynomials and power series.
• Goulden & Jackson's Combinatorial Enumeration provides a condensed summary of the algebraic structure of formal power series, with the rest of the book devoted to discussing their application to solving combinatorial enumeration problems.
• Heck's Introduction to Maple contains an overview of the `powseries` package and a section on its application to the solution of ordinary differential equations.
• Lipson's Elements of Algebra and Algebraic Computing discusses algorithms for operations on polynomials and formal power series, including some brief mention of the relationship between operations such as reversion and the Fast Fourier Transform.
• Wilf's Generatingfunctionology contains an overview of operations on formal power series, with the rest of the book devoted to various solution methods for combinatorial enumeration problems.

HTML originally written by Reid M. Pinchback
Copyright 1996, Massachusetts Institute of Technology