Creation Functions

Contents

Creation of Structures

PowerSeriesRing(R) : Rng -> RngSerPow
PowerSeriesRing(R, p) : Rng, RngIntElt -> RngSerPow
    Global: BoolElt                     Default: true
    Precision: RngIntElt                Default: 20
Given a commutative ring R, create the ring R[[x]] of formal power series over R. If a second integer argument p is given, the resulting ring is a fixed precision series ring with fixed precision p; otherwise the resulting ring is a free precision series ring and the optional argument Precision may be used to set the default precision for elements of the power series ring (it will be 20 otherwise; see the section above on free and fixed precision). By default, a global series ring will be returned; if the parameter Global is set to false, a non-global series ring will be returned (to which a separate name for the indeterminate can be assigned). The angle bracket notation can be used to assign a name to the indeterminate: S<x> := PowerSeriesRing(R).
LaurentSeriesRing(R) : Rng -> RngSerLaur
LaurentSeriesRing(R, p) : Rng, RngIntElt -> RngSerLaur
    Global: BoolElt                     Default: true
    Precision: RngIntElt                Default: 20
Given a commutative ring R, create the ring R((x)) of formal Laurent series over R. If a second integer argument p is given, the resulting ring is a fixed precision series ring with fixed precision p; otherwise the resulting ring is a free precision series ring and the optional argument Precision may be used to set the default precision for elements of the power series ring (it will be 20 otherwise; see the section above on free and fixed precision). By default, a global series ring will be returned; if the parameter Global is set to false, a non-global series ring will be returned (to which a separate name for the indeterminate can be assigned). The angle bracket notation can be used to assign a name to the indeterminate: S<x> := LaurentSeriesRing(R).
PuiseuxSeriesRing(R) : Rng -> RngSerPuis
PuiseuxSeriesRing(R, p) : Rng, RngIntElt -> RngSerPuis
    Global: BoolElt                     Default: true
    Precision: RngIntElt                Default: 20
Given a commutative ring R, create the ring R< < x > > of formal Puiseux series over R. If a second integer argument p is given, the resulting ring is a fixed precision series ring with fixed precision p; otherwise the resulting ring is a free precision series ring and the optional argument Precision may be used to set the default precision for elements of the power series ring (it will be 20 otherwise; see the section above on free and fixed precision). The optional argument Precision may be used to set the default precision for elements of the power series ring. By default, a global series ring will be returned; if the parameter Global is set to false, a non-global series ring will be returned (to which a separate name for the indeterminate can be assigned). The angle bracket notation can be used to assign a name to the indeterminate: S<x> := PuiseuxSeriesRing(R).

Example RngSer_Creation (H50E1)

We demonstrate the difference between global and non-global rings. We first create the global power series ring over {Q} twice.
> Q := RationalField();
> P<x> := PowerSeriesRing(Q);
> PP := PowerSeriesRing(Q);
> P;
Power series ring in x over Rational Field
> PP;
Power series ring in x over Rational Field
> PP.1;
x
PP is identical to P. We now create non-global series rings (which are also different to the global series ring). Note that elements of all the rings are mathematically equal by automatic coercion.
> Pa<a> := PowerSeriesRing(Q: Global := false);
> Pb<b> := PowerSeriesRing(Q: Global := false);
> Pa;
Power series ring in a over Rational Field
> Pb;
Power series ring in b over Rational Field
> a;
a
> b;
b
> P;
Power series ring in x over Rational Field
> x;
x
> x eq a; // Automatic coercion
true
> x + a;
2*x

Special Options

AssertAttribute(S, "DefaultPrecision", n) : RngSer, MonStgElt, RngIntElt ->
Procedure to change the default precision on a free series ring series S; the default precision will be set to n, which must be a non-negative integer.
HasAttribute(S, "DefaultPrecision") : RngSer, MonStgElt -> BoolElt, RngIntElt
Function that returns a Boolean indicating whether a default precision has been set on the free series ring S (which will always be true), as well as its (non-negative) integer value (which is 20 by default).
AssignNames(~S, ["x"]) : RngSer, [ MonStgElt ] ->
Procedure to change the name of the `indeterminate' transcendental element generating the series ring or field S; the name (used in printing elements of S) is changed to the string x. Note that no assignment to the identifier x is made (so x cannot be used for the specification of elements of S without further assignment).
Name(S, 1) : RngSer, RngIntElt -> RngSerElt
S . 1 : RngSer, RngIntElt -> RngSerElt
Name(S, 1) : RngSer, RngIntElt -> RngSerElt
S . 1 : RngSer, RngIntElt -> RngSerElt
Return the element of the series ring or field with a name attached to it, that is, return the `indeterminate' transcendental element generating S over its coefficient ring.

Creation of Elements

The easiest way to create power and Laurent series in a given ring is to use the angle bracket construction to attach names to the indeterminate, and to use these names to express the series (see the examples). Below we list other options.

One(Q) : RngSer -> RngSerElt
One(Q) : RngSer -> RngSerElt
Identity(Q) : RngSer -> RngSerElt
Identity(Q) : RngSer -> RngSerElt
Zero(Q) : RngSer -> RngSerElt
Zero(Q) : RngSer -> RngSerElt
Representative(Q) : RngSer -> RngSerElt
Representative(Q) : RngSer -> RngSerElt
R . 1 : RngSer, RngInt -> RngSerElt
UniformizingElement(R) : RngSer -> RngSerElt
Return the generator (indeterminate) for the series ring R.
elt< R | v, [ a1, ..., ad], p > : RngIntElt, SeqEnum, RngIntElt -> RngSerElt
Given a series ring R, integers v and p (where p > 0 or p = ∞), and a sequence a=[a1, ..., ad] of elements of R, create the element in R with valuation v, known coefficients given by a and relative precision p. That is, this function returns the series a1xv + ... + adxv + d - 1 + O(xv + p), or, if p = (-1), the exact series a1xv + ... + adxv + d - 1. If R is a power series ring, then v must be non-negative.

The integer v or the integer p or both may be omitted. If v is omitted, it will be set to zero by default; if p is omitted it will be taken to be v + d, where d is the length of the sequence a.

R ! s : RngSer, SeqEnum -> RngSerElt
Coerce s into the series ring R. Here s is allowed to be a sequence of elements from (or coercible into) the coefficient ring of R, or just an element from (or coercible into) R. A sequence [a1, ..., ad] is converted into the series a1 + a2x1 + ... + adxd - 1 + O(xd).
BigO(f) : RngSerElt -> RngIntElt
O(f) : RngSerElt -> RngIntElt
Create the series O(xv) where x is the generator of the parent of f and v is the valuation of f. The most typical usage of this function is the expression O(xn) where x is the generator of a series ring, but a general series f is actually allowed.
V2.28, 13 July 2023