Up One Level SAGE Reference Manual Contents Module Index Index
Previous: Up: 28. Power Series Rings Next:

28.4 Laurent Series

Module: sage.rings.laurent_series_ring_element

File: sage/rings/laurent_series_ring_element.pyx (starting at line 1)

Laurent Series 

sage: R.<t> = LaurentSeriesRing(GF(7), 't'); R
Laurent Series Ring in t over Finite Field of size 7
sage: f = 1/(1-t+O(t^10)); f
1 + t + t^2 + t^3 + t^4 + t^5 + t^6 + t^7 + t^8 + t^9 + O(t^10)

Laurent series are immutable: 

sage: f[2]
1
sage: f[2] = 5
Traceback (most recent call last):
...
IndexError: Laurent series are immutable

We compute with a Laurent series over the complex mpfr numbers. 

sage: K.<q> = Frac(CC[['q']])
sage: K
Laurent Series Ring in q over Complex Field with 53 bits of precision
sage: q
1.00000000000000*q

Saving and loading. 

sage: loads(q.dumps()) == q
True
sage: loads(K.dumps()) == K
True

IMPLEMENTATION: Laurent series in SAGE are represented internally as a power of the variable times the unit part (which need not be a unit - it's a polynomial with nonzero constant term). The zero Laurent series has unit part 0.

Author Log:

Module-level Functions

is_LaurentSeries( )

make_element_from_parent( )

Class: LaurentSeries

class LaurentSeries
File: sage/rings/laurent_series_ring_element.pyx (starting at line 65)

A Laurent Series.

Functions: add_bigoh,$ $ change_ring,$ $ common_prec,$ $ copy,$ $ degree,$ $ derivative,$ $ integral,$ $ is_unit,$ $ is_zero,$ $ list,$ $ power_series,$ $ prec,$ $ shift,$ $ truncate,$ $ truncate_neg,$ $ valuation,$ $ valuation_zero_part,$ $ variable

add_bigoh( )

sage: R.<t> = LaurentSeriesRing(QQ)
sage: f = t^2 + t^3 + O(t^10); f
t^2 + t^3 + O(t^10)
sage: f.add_bigoh(5)
t^2 + t^3 + O(t^5)

common_prec( )

Returns minimum precision of $ f$ and self. 

sage: R.<t> = LaurentSeriesRing(QQ)


sage: f = t^(-1) + t + t^2 + O(t^3)
sage: g = t + t^3 + t^4 + O(t^4)
sage: f.common_prec(g)
3
sage: g.common_prec(f)
3


sage: f = t + t^2 + O(t^3)
sage: g = t^(-3) + t^2
sage: f.common_prec(g)
3
sage: g.common_prec(f)
3


sage: f = t + t^2
sage: f = t^2
sage: f.common_prec(g)
+Infinity


sage: f = t^(-3) + O(t^(-2))
sage: g = t^(-5) + O(t^(-1))
sage: f.common_prec(g)
-2

degree( )

Return the degree of a polynomial equivalent to this power series modulo big oh of the precision. 

sage: x = Frac(QQ[['x']]).0
sage: g = x^2 - x^4 + O(x^8)
sage: g.degree()
4
sage: g = -10/x^5 + x^2 - x^4 + O(x^8)
sage: g.degree()
4

derivative( )

The formal derivative of this Laurent series. 

sage: x = Frac(QQ[['x']]).0
sage: f = x^2 + 3*x^4 + O(x^7)
sage: f.derivative()
2*x + 12*x^3 + O(x^6)
sage: g = 1/x^10 - x + x^2 - x^4 + O(x^8)
sage: g.derivative()
-10*x^-11 - 1 + 2*x - 4*x^3 + O(x^7)

integral( )

The formal integral of this Laurent series with 0 constant term.

The integral may or may not be defined if the base ring is not a field. 

sage: t = LaurentSeriesRing(ZZ, 't').0
sage: f = 2*t^-3 + 3*t^2 + O(t^4)
sage: f.integral()
-t^-2 + t^3 + O(t^5)


sage: f = t^3
sage: f.integral()
Traceback (most recent call last):
...
ArithmeticError: Coefficients of integral cannot be coerced into the base
ring

The integral of 1/t is $ \log(t)$, which is not given by a Laurent series: 

sage: t = Frac(QQ[['t']]).0
sage: f = -1/t^3 - 31/t + O(t^3)
sage: f.integral()
Traceback (most recent call last):
...
ArithmeticError: The integral of is not a Laurent series, since t^-1 has
nonzero coefficient.

is_unit( )

Returns True if this is Laurent series is a unit in this ring. 

sage: R.<t> = LaurentSeriesRing(QQ)
sage: (2+t).is_unit()
True
sage: f = 2+t^2+O(t^10); f.is_unit()
True
sage: 1/f
1/2 - 1/4*t^2 + 1/8*t^4 - 1/16*t^6 + 1/32*t^8 + O(t^10)
sage: R(0).is_unit()
False
sage: R.<s> = LaurentSeriesRing(ZZ)
sage: f = 2 + s^2 + O(s^10)
sage: f.is_unit()
False
sage: 1/f
Traceback (most recent call last):
...
ArithmeticError: division not defined

ALGORITHM: A Laurent series is a unit if and only if its "unit part" is a unit.

is_zero( )

sage: x = Frac(QQ[['x']]).0
sage: f = 1/x + x + x^2 + 3*x^4 + O(x^7)
sage: f.is_zero()
0
sage: z = 0*f
sage: z.is_zero()
1

power_series( )

sage: R.<t> = LaurentSeriesRing(ZZ)
sage: f = 1/(1-t+O(t^10)); f.parent()
Laurent Series Ring in t over Integer Ring
sage: g = f.power_series(); g
1 + t + t^2 + t^3 + t^4 + t^5 + t^6 + t^7 + t^8 + t^9 + O(t^10)
sage: parent(g)
Power Series Ring in t over Integer Ring
sage: f = 3/t^2 +  t^2 + t^3 + O(t^10)
sage: f.power_series()
Traceback (most recent call last):
...
ArithmeticError: self is a not a power series

prec( )

This function returns the n so that the Laurent series is of the form (stuff) + $ O(t^n)$. It doesn't matter how many negative powers appear in the expansion. In particular, prec could be negative. 

sage: x = Frac(QQ[['x']]).0
sage: f = x^2 + 3*x^4 + O(x^7)
sage: f.prec()
7
sage: g = 1/x^10 - x + x^2 - x^4 + O(x^8)
sage: g.prec()
8

shift( )

Returns this laurent series multiplied by the power $ t^n$. Does not change this series.

NOTE: Despite the fact that higher order terms are printed to the right in a power series, right shifting decreases the powers of $ t$, while left shifting increases them. This is to be consistant with polynomials, integers, etc. 

sage: R.<t> = LaurentSeriesRing(QQ['y'])
sage: f = (t+t^-1)^4; f
t^-4 + 4*t^-2 + 6 + 4*t^2 + t^4
sage: f.shift(10)
t^6 + 4*t^8 + 6*t^10 + 4*t^12 + t^14
sage: f >> 10
t^-14 + 4*t^-12 + 6*t^-10 + 4*t^-8 + t^-6
sage: t << 4
t^5
sage: t + O(t^3) >> 4
t^-3 + O(t^-1)

Author: Robert Bradshaw (2007-04-18)

truncate( )

Returns the laurent series of degree $ < n$ which is equivalent to self modulo $ x^n$.

truncate_neg( )

Returns the laurent series equivalent to self except without any degree < n terms.

This is equivalent to $ \code{self - self.truncate(n)}$.

valuation( )

sage: x = Frac(QQ[['x']]).0
sage: f = 1/x + x^2 + 3*x^4 + O(x^7)
sage: g = 1 - x + x^2 - x^4 + O(x^8)
sage: f.valuation()
-1
sage: g.valuation()
0

valuation_zero_part( )

sage: x = Frac(QQ[['x']]).0
sage: f = x + x^2 + 3*x^4 + O(x^7)
sage: f/x
1 + x + 3*x^3 + O(x^6)
sage: f.valuation_zero_part()
1 + x + 3*x^3 + O(x^6)
sage: g = 1/x^7 - x + x^2 - x^4 + O(x^8)
sage: g.valuation_zero_part()
1 - x^8 + x^9 - x^11 + O(x^15)

variable( )

sage: x = Frac(QQ[['x']]).0
sage: f = 1/x + x^2 + 3*x^4 + O(x^7)
sage: f.variable()
'x'

Special Functions: __call__,$ $ __delitem__,$ $ __eq__,$ $ __ge__,$ $ __getitem__,$ $ __getslice__,$ $ __gt__,$ $ __iter__,$ $ __le__,$ $ __lshift__,$ $ __lt__,$ $ __ne__,$ $ __neg__,$ $ __normalize,$ $ __pow__,$ $ __reduce__,$ $ __rlshift__,$ $ __rpow__,$ $ __rrshift__,$ $ __rshift__,$ $ __setitem__,$ $ _im_gens_,$ $ _latex_,$ $ _repr_,$ $ _unsafe_mutate

__normalize( )

A Laurent series is a pair (u(t), n), where either u=0 (to some precision) or u is a unit. This pair corresponds to $ t^n\cdot u(t)$.

__reduce__( )

_im_gens_( )

_latex_( )

sage: x = Frac(QQ[['x']]).0
sage: f = (17/2)*x^-2 + x + x^2 + 3*x^4 + O(x^7)
sage: latex(f)
\frac{\frac{17}{2}}{x^{2}} + x + x^{2} + 3x^{4} + O(\text{x}^{7})

_repr_( )

sage: R.<t> = LaurentSeriesRing(QQ)
sage: (2 + (2/3)*t^3).__repr__()
'2 + 2/3*t^3'

_unsafe_mutate( )

SAGE assumes throughout that commutative ring elements are immutable. This is relevant for caching, etc. But sometimes you need to change a Laurent series and you really know what you're doing. That's when this function is for you.

Up One Level SAGE Reference Manual Contents Module Index Index
Previous: Up: 28. Power Series Rings Next:
Release 2007.10.28, documentation updated on October 28, 2007.
See About this document... for information on suggesting changes.