### Navigation

- index
- modules |
- next |
- previous |
- Polynomial Rings »
- Laurent Polynomials and Polynomial Rings »

# Elements of Laurent polynomial rings

Elements of Laurent polynomial rings

class `sage.rings.polynomial.laurent_polynomial.``LaurentPolynomial_generic`

  Bases: `sage.structure.element.CommutativeAlgebraElement`

  A generic Laurent polynomial.

class `sage.rings.polynomial.laurent_polynomial.``LaurentPolynomial_mpair`

  Bases: `sage.rings.polynomial.laurent_polynomial.LaurentPolynomial_generic`

  Multivariate Laurent polynomials.

  `coefficient`(mon)

    Return the coefficient of `mon` in `self`, where `mon` must have the same parent as `self`.

    The coefficient is defined as follows. If \(f\) is this polynomial, then the coefficient \(c_m\) is sum:

    \[c_m := \sum_T \frac{T}{m}\]

    where the sum is over terms \(T\) in \(f\) that are exactly divisible by \(m\).

    A monomial \(m(x,y)\) ‘exactly divides’ \(f(x,y)\) if \(m(x,y) | f(x,y)\) and neither \(x \cdot m(x,y)\) nor \(y \cdot m(x,y)\) divides \(f(x,y)\).

    INPUT:

    - `mon` – a monomial

    OUTPUT:

    Element of the parent of `self`.

    Note

    To get the constant coefficient, call `constant_coefficient()`.

    EXAMPLES:

        sage: P.<x,y> = LaurentPolynomialRing(QQ)

    The coefficient returned is an element of the parent of `self`; in this case, `P`.

        sage: f = 2 * x * y
        sage: c = f.coefficient(x*y); c
        2
        sage: c.parent()
        Multivariate Laurent Polynomial Ring in x, y over Rational Field

        sage: P.<x,y> = LaurentPolynomialRing(QQ)
        sage: f = (y^2 - x^9 - 7*x*y^2 + 5*x*y)*x^-3; f
        -x^6 - 7*x^-2*y^2 + 5*x^-2*y + x^-3*y^2
        sage: f.coefficient(y)
        5*x^-2
        sage: f.coefficient(y^2)
        -7*x^-2 + x^-3
        sage: f.coefficient(x*y)
        0
        sage: f.coefficient(x^-2)
        -7*y^2 + 5*y
        sage: f.coefficient(x^-2*y^2)
        -7
        sage: f.coefficient(1)
        -x^6 - 7*x^-2*y^2 + 5*x^-2*y + x^-3*y^2

  `coefficients`()

    Return the nonzero coefficients of this polynomial in a list. The returned list is decreasingly ordered by the term ordering of `self.parent()`.

    EXAMPLES:

        sage: L.<x,y,z> = LaurentPolynomialRing(QQ,order='degrevlex')
        sage: f = 4*x^7*z^-1 + 3*x^3*y + 2*x^4*z^-2 + x^6*y^-7
        sage: f.coefficients()
        [4, 3, 2, 1]
        sage: L.<x,y,z> = LaurentPolynomialRing(QQ,order='lex')
        sage: f = 4*x^7*z^-1 + 3*x^3*y + 2*x^4*z^-2 + x^6*y^-7
        sage: f.coefficients()
        [4, 1, 2, 3]

  `constant_coefficient`()

    Return the constant coefficient of `self`.

    EXAMPLES:

        sage: P.<x,y> = LaurentPolynomialRing(QQ)
        sage: f = (y^2 - x^9 - 7*x*y^2 + 5*x*y)*x^-3; f
        -x^6 - 7*x^-2*y^2 + 5*x^-2*y + x^-3*y^2
        sage: f.constant_coefficient()
        0
        sage: f = (x^3 + 2*x^-2*y+y^3)*y^-3; f
        x^3*y^-3 + 1 + 2*x^-2*y^-2
        sage: f.constant_coefficient()
        1

  `degree`(x=None)

    Returns the degree of x in self

    EXAMPLES:

        sage: R.<x,y,z> = LaurentPolynomialRing(QQ)
        sage: f = 4*x^7*z^-1 + 3*x^3*y + 2*x^4*z^-2 + x^6*y^-7
        sage: f.degree(x)
        7
        sage: f.degree(y)
        1
        sage: f.degree(z)
        0

  `derivative`(*args)

    The formal derivative of this Laurent polynomial, with respect to variables supplied in args.

    Multiple variables and iteration counts may be supplied; see documentation for the global derivative() function for more details.

    See also

    `_derivative()`

    EXAMPLES:

        sage: R = LaurentPolynomialRing(ZZ,'x, y')
        sage: x, y = R.gens()
        sage: t = x**4*y+x*y+y+x**(-1)+y**(-3)
        sage: t.derivative(x, x)
        12*x^2*y + 2*x^-3
        sage: t.derivative(y, 2)
        12*y^-5

  `dict`()

    EXAMPLES:

        sage: L.<x,y,z> = LaurentPolynomialRing(QQ)
        sage: f = 4*x^7*z^-1 + 3*x^3*y + 2*x^4*z^-2 + x^6*y^-7
        sage: list(sorted(f.dict().iteritems()))
        [((3, 1, 0), 3), ((4, 0, -2), 2), ((6, -7, 0), 1), ((7, 0, -1), 4)]

  `diff`(*args)

    The formal derivative of this Laurent polynomial, with respect to variables supplied in args.

    Multiple variables and iteration counts may be supplied; see documentation for the global derivative() function for more details.

    See also

    `_derivative()`

    EXAMPLES:

        sage: R = LaurentPolynomialRing(ZZ,'x, y')
        sage: x, y = R.gens()
        sage: t = x**4*y+x*y+y+x**(-1)+y**(-3)
        sage: t.derivative(x, x)
        12*x^2*y + 2*x^-3
        sage: t.derivative(y, 2)
        12*y^-5

  `differentiate`(*args)

    The formal derivative of this Laurent polynomial, with respect to variables supplied in args.

    Multiple variables and iteration counts may be supplied; see documentation for the global derivative() function for more details.

    See also

    `_derivative()`

    EXAMPLES:

        sage: R = LaurentPolynomialRing(ZZ,'x, y')
        sage: x, y = R.gens()
        sage: t = x**4*y+x*y+y+x**(-1)+y**(-3)
        sage: t.derivative(x, x)
        12*x^2*y + 2*x^-3
        sage: t.derivative(y, 2)
        12*y^-5

  `exponents`()

    Returns a list of the exponents of self.

    EXAMPLES:

        sage: L.<w,z> = LaurentPolynomialRing(QQ)
        sage: a = w^2*z^-1+3; a
        w^2*z^-1 + 3
        sage: e = a.exponents()
        sage: e.sort(); e
        [(0, 0), (2, -1)]

  `factor`()

    Returns a Laurent monomial (the unit part of the factorization) and a factored multi-polynomial.

    EXAMPLES:

        sage: L.<x,y,z> = LaurentPolynomialRing(QQ)
        sage: f = 4*x^7*z^-1 + 3*x^3*y + 2*x^4*z^-2 + x^6*y^-7
        sage: f.factor()
        (x^3*y^-7*z^-2) * (4*x^4*y^7*z + 3*y^8*z^2 + 2*x*y^7 + x^3*z^2)

  `has_any_inverse`()

    Returns True if self contains any monomials with a negative exponent, False otherwise.

    EXAMPLES:

        sage: L.<x,y,z> = LaurentPolynomialRing(QQ)
        sage: f = 4*x^7*z^-1 + 3*x^3*y + 2*x^4*z^-2 + x^6*y^-7
        sage: f.has_any_inverse()
        True
        sage: g = x^2 + y^2
        sage: g.has_any_inverse()
        False

  `has_inverse_of`(i)

    INPUT:

    - `i` – The index of a generator of `self.parent()`

    OUTPUT:

    Returns True if self contains a monomial including the inverse of `self.parent().gen(i)`, False otherwise.

    EXAMPLES:

        sage: L.<x,y,z> = LaurentPolynomialRing(QQ)
        sage: f = 4*x^7*z^-1 + 3*x^3*y + 2*x^4*z^-2 + x^6*y^-7
        sage: f.has_inverse_of(0)
        False
        sage: f.has_inverse_of(1)
        True
        sage: f.has_inverse_of(2)
        True

  `is_monomial`()

    Return True if this element is a monomial.

    EXAMPLES:

        sage: k.<y,z> = LaurentPolynomialRing(QQ)
        sage: z.is_monomial()
        True
        sage: k(1).is_monomial()
        True
        sage: (z+1).is_monomial()
        False
        sage: (z^-2909).is_monomial()
        True
        sage: (38*z^-2909).is_monomial()
        False

  `is_univariate`()

    Return `True` if this is a univariate or constant Laurent polynomial, and `False` otherwise.

    EXAMPLES:

        sage: R.<x,y,z> = LaurentPolynomialRing(QQ)
        sage: f = (x^3 + y^-3)*z
        sage: f.is_univariate()
        False
        sage: g = f(1,y,4)
        sage: g.is_univariate()
        True
        sage: R(1).is_univariate()
        True

  `monomial_coefficient`(mon)

    Return the coefficient in the base ring of the monomial `mon` in `self`, where `mon` must have the same parent as `self`.

    This function contrasts with the function `coefficient()` which returns the coefficient of a monomial viewing this polynomial in a polynomial ring over a base ring having fewer variables.

    INPUT:

    - `mon` - a monomial

    See also

    For coefficients in a base ring of fewer variables, see `coefficient()`.

    EXAMPLES:

        sage: P.<x,y> = LaurentPolynomialRing(QQ)
        sage: f = (y^2 - x^9 - 7*x*y^3 + 5*x*y)*x^-3
        sage: f.monomial_coefficient(x^-2*y^3)
        -7
        sage: f.monomial_coefficient(x^2)
        0

  `monomials`()

    Return the list of monomials in `self`.

    EXAMPLES:

        sage: P.<x,y> = LaurentPolynomialRing(QQ)
        sage: f = (y^2 - x^9 - 7*x*y^3 + 5*x*y)*x^-3
        sage: f.monomials()
        [x^6, x^-3*y^2, x^-2*y, x^-2*y^3]

  `subs`(in_dict=None, **kwds)

    Note that this is a very unsophisticated implementation.

    EXAMPLES:

        sage: L.<x,y,z> = LaurentPolynomialRing(QQ)
        sage: f = x + 2*y + 3*z
        sage: f.subs(x=1)
        2*y + 3*z + 1
        sage: f.subs(y=1)
        x + 3*z + 2
        sage: f.subs(z=1)
        x + 2*y + 3
        sage: f.subs(x=1,y=1,z=1)
        6

        sage: f = x^-1
        sage: f.subs(x=2)
        1/2
        sage: f.subs({x:2})
        1/2

        sage: f = x + 2*y + 3*z
        sage: f.subs({x:1,y:1,z:1})
        6
        sage: f.substitute(x=1,y=1,z=1)
        6

    TESTS:

        sage: f = x + 2*y + 3*z
        sage: f(q=10)
        x + 2*y + 3*z

  `univariate_polynomial`(R=None)

    Returns a univariate polynomial associated to this multivariate polynomial.

    INPUT:

    - `R` - (default: `None`) PolynomialRing

    If this polynomial is not in at most one variable, then a `ValueError` exception is raised. The new polynomial is over the same base ring as the given `LaurentPolynomial` and in the variable `x` if no ring `R` is provided.

    EXAMPLES:

        sage: R.<x, y> = LaurentPolynomialRing(ZZ)
        sage: f = 3*x^2 - 2*y^-1 + 7*x^2*y^2 + 5
        sage: f.univariate_polynomial()
        Traceback (most recent call last):
        ...
        TypeError: polynomial must involve at most one variable
        sage: g = f(10,y); g
        700*y^2 + 305 - 2*y^-1
        sage: h = g.univariate_polynomial(); h
        -2*y^-1 + 305 + 700*y^2
        sage: h.parent()
        Univariate Laurent Polynomial Ring in y over Integer Ring
        sage: g.univariate_polynomial(LaurentPolynomialRing(QQ,'z'))
        -2*z^-1 + 305 + 700*z^2

    Here’s an example with a constant multivariate polynomial:

        sage: g = R(1)
        sage: h = g.univariate_polynomial(); h
        1
        sage: h.parent()
        Univariate Laurent Polynomial Ring in x over Integer Ring

  `variables`(sort=True)

    Return a tuple of all variables occurring in self.

    INPUT:

    - `sort` – specifies whether the indices shall be sorted

    EXAMPLES:

        sage: L.<x,y,z> = LaurentPolynomialRing(QQ)
        sage: f = 4*x^7*z^-1 + 3*x^3*y + 2*x^4*z^-2 + x^6*y^-7
        sage: f.variables()
        (z, y, x)
        sage: f.variables(sort=False) #random
        (y, z, x)

class `sage.rings.polynomial.laurent_polynomial.``LaurentPolynomial_univariate`

  Bases: `sage.rings.polynomial.laurent_polynomial.LaurentPolynomial_generic`

  A univariate Laurent polynomial in the form of \(t^n \cdot f\) where \(f\) is a polynomial in \(t\).

  INPUT:

  - `parent` – a Laurent polynomial ring
  - `f` – a polynomial (or something can be coerced to one)
  - `n` – (default: 0) an integer

  AUTHORS:

  - Tom Boothby (2011) copied this class almost verbatim from `laurent_series_ring_element.pyx`, so most of the credit goes to William Stein, David Joyner, and Robert Bradshaw
  - Travis Scrimshaw (09-2013): Cleaned-up and added a few extra methods
  `change_ring`(R)

    Return a copy of this Laurent polynomial, with coefficients in `R`.

    EXAMPLES:

        sage: R.<x> = LaurentPolynomialRing(QQ)
        sage: a = x^2 + 3*x^3 + 5*x^-1
        sage: a.change_ring(GF(3))
        2*x^-1 + x^2

  `coefficients`()

    Return the nonzero coefficients of `self`.

    EXAMPLES:

        sage: R.<t> = LaurentPolynomialRing(QQ)
        sage: f = -5/t^(2) + t + t^2 - 10/3*t^3
        sage: f.coefficients()
        [-5, 1, 1, -10/3]

  `constant_coefficient`()

    Return the coefficient of the constant term of `self`.

    EXAMPLES:

        sage: R.<t> = LaurentPolynomialRing(QQ)
        sage: f = 3*t^-2 - t^-1 + 3 + t^2
        sage: f.constant_coefficient()
        3
        sage: g = -2*t^-2 + t^-1 + 3*t
        sage: g.constant_coefficient()
        0

  `degree`()

    Return the degree of this polynomial.

    EXAMPLES:

        sage: R.<x> = LaurentPolynomialRing(ZZ)
        sage: g = x^2 - x^4
        sage: g.degree()
        4
        sage: g = -10/x^5 + x^2 - x^7
        sage: g.degree()
        7

  `derivative`(*args)

    The formal derivative of this Laurent polynomial, with respect to variables supplied in args.

    Multiple variables and iteration counts may be supplied; see documentation for the global :func`derivative()` function for more details.

    See also

    `_derivative()`

    EXAMPLES:

        sage: R.<x> = LaurentPolynomialRing(QQ)
        sage: g = 1/x^10 - x + x^2 - x^4
        sage: g.derivative()
        -10*x^-11 - 1 + 2*x - 4*x^3
        sage: g.derivative(x)
        -10*x^-11 - 1 + 2*x - 4*x^3

        sage: R.<t> = PolynomialRing(ZZ)
        sage: S.<x> = LaurentPolynomialRing(R)
        sage: f = 2*t/x + (3*t^2 + 6*t)*x
        sage: f.derivative()
        -2*t*x^-2 + (3*t^2 + 6*t)
        sage: f.derivative(x)
        -2*t*x^-2 + (3*t^2 + 6*t)
        sage: f.derivative(t)
        2*x^-1 + (6*t + 6)*x

  `dict`()

    Return a dictionary representing `self`.

    EXAMPLES::
      sage: R.<x,y> = ZZ[] sage: Q.<t> = LaurentPolynomialRing(R) sage: f = (x^3 + y/t^3)^3 + t^2; f y^3*t^-9 + 3*x^3*y^2*t^-6 + 3*x^6*y*t^-3 + x^9 + t^2 sage: f.dict() {-9: y^3, -6: 3*x^3*y^2, -3: 3*x^6*y, 0: x^9, 2: 1}
  `exponents`()

    Return the exponents appearing in `self` with nonzero coefficients.

    EXAMPLES:

        sage: R.<t> = LaurentPolynomialRing(QQ)
        sage: f = -5/t^(2) + t + t^2 - 10/3*t^3
        sage: f.exponents()
        [-2, 1, 2, 3]

  `factor`()

    Return a Laurent monomial (the unit part of the factorization) and a factored polynomial.

    EXAMPLES:

        sage: R.<t> = LaurentPolynomialRing(ZZ)
        sage: f = 4*t^-7 + 3*t^3 + 2*t^4 + t^-6
        sage: f.factor()
        (t^-7) * (4 + t + 3*t^10 + 2*t^11)

  `gcd`(right)

    Return the gcd of `self` with `right` where the common divisor `d` makes both `self` and `right` into polynomials with the lowest possible degree.

    EXAMPLES:

        sage: R.<t> = LaurentPolynomialRing(QQ)
        sage: t.gcd(2)
        1
        sage: gcd(t^-2 + 1, t^-4 + 3*t^-1)
        t^-4
        sage: gcd((t^-2 + t)*(t + t^-1), (t^5 + t^8)*(1 + t^-2))
        t^-3 + t^-1 + 1 + t^2

  `integral`()

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

    EXAMPLES:

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

        sage: t = LaurentPolynomialRing(ZZ, 't').0
        sage: f = 2*t^-3 + 3*t^2
        sage: f.integral()
        -t^-2 + t^3

        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 polynomial:

        sage: t = LaurentPolynomialRing(ZZ,'t').0
        sage: f = -1/t^3 - 31/t
        sage: f.integral()
        Traceback (most recent call last):
        ...
        ArithmeticError: the integral of is not a Laurent polynomial, since t^-1 has nonzero coefficient

    Another example with just one negative coefficient:

        sage: A.<t> = LaurentPolynomialRing(QQ)
        sage: f = -2*t^(-4)
        sage: f.integral()
        2/3*t^-3
        sage: f.integral().derivative() == f
        True

  `inverse_of_unit`()

    Return the inverse of `self` if a unit.

    EXAMPLES:

        sage: R.<t> = LaurentPolynomialRing(QQ)
        sage: (t^-2).inverse_of_unit()
        t^2
        sage: (t + 2).inverse_of_unit()
        Traceback (most recent call last):
        ...
        ArithmeticError: element is not a unit

  `is_constant`()

    Return `True` if `self` is constant.

    EXAMPLES:

        sage: R.<x> = LaurentPolynomialRing(QQ)
        sage: x.is_constant()
        False
        sage: R.one().is_constant()
        True
        sage: (x^-2).is_constant()
        False
        sage: (x^2).is_constant()
        False
        sage: (x^-2 + 2).is_constant()
        False

  `is_monomial`()

    Return True if this element is a monomial. That is, if self is \(x^n\) for some integer \(n\).

    EXAMPLES:

        sage: k.<z> = LaurentPolynomialRing(QQ)
        sage: z.is_monomial()
        True
        sage: k(1).is_monomial()
        True
        sage: (z+1).is_monomial()
        False
        sage: (z^-2909).is_monomial()
        True
        sage: (38*z^-2909).is_monomial()
        False

  `is_unit`()

    Return `True` if this Laurent polynomial is a unit in this ring.

    EXAMPLES:

        sage: R.<t> = LaurentPolynomialRing(QQ)
        sage: (2+t).is_unit()
        False
        sage: f = 2*t
        sage: f.is_unit()
        True
        sage: 1/f
        1/2*t^-1
        sage: R(0).is_unit()
        False
        sage: R.<s> = LaurentPolynomialRing(ZZ)
        sage: g = 2*s
        sage: g.is_unit()
        False
        sage: 1/g
        1/2*s^-1

    ALGORITHM: A Laurent polynomial is a unit if and only if its “unit part” is a unit.

  `is_zero`()

    Return `1` if `self` is 0, else return `0`.

    EXAMPLES:

        sage: R.<x> = LaurentPolynomialRing(QQ)
        sage: f = 1/x + x + x^2 + 3*x^4
        sage: f.is_zero()
        0
        sage: z = 0*f
        sage: z.is_zero()
        1

  `polynomial_construction`()

    Return the polynomial and the shift in power used to construct the Laurent polynomial \(t^n u\).

    OUTPUT:

    A tuple `(u, n)` where `u` is the underlying polynomial and `n` is the power of the exponent shift.

    EXAMPLES:

        sage: R.<x> = LaurentPolynomialRing(QQ)
        sage: f = 1/x + x^2 + 3*x^4
        sage: f.polynomial_construction()
        (3*x^5 + x^3 + 1, -1)

  `quo_rem`(right_r)

    Attempts to divide `self` by `right` and returns a quotient and a remainder.

    EXAMPLES:

        sage: R.<t> = LaurentPolynomialRing(QQ)
        sage: (t^-3 - t^3).quo_rem(t^-1 - t)
        (t^-2 + 1 + t^2, 0)
        sage: (t^-2 + 3 + t).quo_rem(t^-4)
        (t^2 + 3*t^4 + t^5, 0)
        sage: (t^-2 + 3 + t).quo_rem(t^-4 + t)
        (0, 1 + 3*t^2 + t^3)

  `residue`()

    Return the residue of `self`.

    The residue is the coefficient of \(t^-1\).

    EXAMPLES:

        sage: R.<t> = LaurentPolynomialRing(QQ)
        sage: f = 3*t^-2 - t^-1 + 3 + t^2
        sage: f.residue()
        -1
        sage: g = -2*t^-2 + 4 + 3*t
        sage: g.residue()
        0
        sage: f.residue().parent()
        Rational Field

  `shift`(k)

    Return this Laurent polynomial multiplied by the power \(t^n\). Does not change this polynomial.

    EXAMPLES:

        sage: R.<t> = LaurentPolynomialRing(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: f << 4
        1 + 4*t^2 + 6*t^4 + 4*t^6 + t^8

  `truncate`(n)

    Return a polynomial with degree at most \(n-1\) whose \(j\)-th coefficients agree with `self` for all \(j < n\).

    EXAMPLES:

        sage: R.<x> = LaurentPolynomialRing(QQ)
        sage: f = 1/x^12 + x^3 + x^5 + x^9
        sage: f.truncate(10)
        x^-12 + x^3 + x^5 + x^9
        sage: f.truncate(5)
        x^-12 + x^3
        sage: f.truncate(-16)
        0

  `valuation`(p=None)

    Return the valuation of `self`.

    The valuation of a Laurent polynomial \(t^n u\) is \(n\) plus the valuation of \(u\).

    EXAMPLES:

        sage: R.<x> = LaurentPolynomialRing(ZZ)
        sage: f = 1/x + x^2 + 3*x^4
        sage: g = 1 - x + x^2 - x^4
        sage: f.valuation()
        -1
        sage: g.valuation()
        0

  `variable_name`()

    Return the name of variable of `self` as a string.

    EXAMPLES:

        sage: R.<x> = LaurentPolynomialRing(QQ)
        sage: f = 1/x + x^2 + 3*x^4
        sage: f.variable_name()
        'x'

  `variables`()

    Return the tuple of variables occuring in this Laurent polynomial.

    EXAMPLES:

        sage: R.<x> = LaurentPolynomialRing(QQ)
        sage: f = 1/x + x^2 + 3*x^4
        sage: f.variables()
        (x,)
        sage: R.one().variables()
        ()

### Navigation

- index
- modules |
- next |
- previous |
- Polynomial Rings »
- Laurent Polynomials and Polynomial Rings »