Elements of Laurent polynomial rings - Polynomials

Skip to content
Back to top
View this page
Edit this page

# Elements of Laurent polynomial rings

class sage.rings.polynomial.laurent_polynomial.LaurentPolynomial

  Bases: `CommutativeAlgebraElement`

  Base class for Laurent polynomials.

  change_ring(R)

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

    EXAMPLES:

    Sage

        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

    Python

        >>> from sage.all import *
        >>> R = LaurentPolynomialRing(QQ, names=('x',)); (x,) = R._first_ngens(1)
        >>> a = x**Integer(2) + Integer(3)*x**Integer(3) + Integer(5)*x**-Integer(1)
        >>> a.change_ring(GF(Integer(3)))
        2*x^-1 + x^2

    Check that Issue #22277 is fixed:

    Sage

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

    [Python]

        >>> from sage.all import *
        >>> R = LaurentPolynomialRing(QQ, names=('x', 'y',)); (x, y,) = R._first_ngens(2)
        >>> a = Integer(2)*x**Integer(2) + Integer(3)*x**Integer(3) + Integer(4)*x**-Integer(1)
        >>> a.change_ring(GF(Integer(3)))
        -x^2 + x^-1

  dict()

    alias of `monomial_coefficients()`.

  hamming_weight()

    Return the hamming weight of `self`.

    The hamming weight is number of nonzero coefficients and also known as the weight or sparsity.

    EXAMPLES:

    Sage

        sage: R.<x> = LaurentPolynomialRing(ZZ)
        sage: f = x^3 - 1
        sage: f.hamming_weight()
        2

    Python

        >>> from sage.all import *
        >>> R = LaurentPolynomialRing(ZZ, names=('x',)); (x,) = R._first_ngens(1)
        >>> f = x**Integer(3) - Integer(1)
        >>> f.hamming_weight()
        2

  map_coefficients(f, new_base_ring=None)

    Apply `f` to the coefficients of `self`.

    If `f` is a `sage.categories.map.Map`, then the resulting polynomial will be defined over the codomain of `f`. Otherwise, the resulting polynomial will be over the same ring as `self`. Set `new_base_ring` to override this behavior.

    INPUT:

    - `f` – a callable that will be applied to the coefficients of `self`

    - `new_base_ring` – (optional) if given, the resulting polynomial will be defined over this ring

    EXAMPLES:

    Sage

        sage: k.<a> = GF(9)
        sage: R.<x> = LaurentPolynomialRing(k)
        sage: f = x*a + a
        sage: f.map_coefficients(lambda a: a + 1)
        (a + 1) + (a + 1)*x
        sage: R.<x,y> = LaurentPolynomialRing(k, 2)                                 # needs sage.modules
        sage: f = x*a + 2*x^3*y*a + a                                               # needs sage.modules
        sage: f.map_coefficients(lambda a: a + 1)                                   # needs sage.modules
        (2*a + 1)*x^3*y + (a + 1)*x + a + 1

    Python

        >>> from sage.all import *
        >>> k = GF(Integer(9), names=('a',)); (a,) = k._first_ngens(1)
        >>> R = LaurentPolynomialRing(k, names=('x',)); (x,) = R._first_ngens(1)
        >>> f = x*a + a
        >>> f.map_coefficients(lambda a: a + Integer(1))
        (a + 1) + (a + 1)*x
        >>> R = LaurentPolynomialRing(k, Integer(2), names=('x', 'y',)); (x, y,) = R._first_ngens(2)# needs sage.modules
        >>> f = x*a + Integer(2)*x**Integer(3)*y*a + a                                               # needs sage.modules
        >>> f.map_coefficients(lambda a: a + Integer(1))                                   # needs sage.modules
        (2*a + 1)*x^3*y + (a + 1)*x + a + 1

    Examples with different base ring:

    Sage

        sage: R.<r> = GF(9); S.<s> = GF(81)
        sage: h = Hom(R, S)[0]; h
        Ring morphism:
          From: Finite Field in r of size 3^2
          To:   Finite Field in s of size 3^4
          Defn: r |--> 2*s^3 + 2*s^2 + 1
        sage: T.<X,Y> = LaurentPolynomialRing(R, 2)
        sage: f = r*X + Y
        sage: g = f.map_coefficients(h); g
        (2*s^3 + 2*s^2 + 1)*X + Y
        sage: g.parent()
        Multivariate Laurent Polynomial Ring in X, Y
         over Finite Field in s of size 3^4
        sage: h = lambda x: x.trace()
        sage: g = f.map_coefficients(h); g
        X - Y
        sage: g.parent()
        Multivariate Laurent Polynomial Ring in X, Y
         over Finite Field in r of size 3^2
        sage: g = f.map_coefficients(h, new_base_ring=GF(3)); g
        X - Y
        sage: g.parent()
        Multivariate Laurent Polynomial Ring in X, Y over Finite Field of size 3

    [Python]

        >>> from sage.all import *
        >>> R = GF(Integer(9), names=('r',)); (r,) = R._first_ngens(1); S = GF(Integer(81), names=('s',)); (s,) = S._first_ngens(1)
        >>> h = Hom(R, S)[Integer(0)]; h
        Ring morphism:
          From: Finite Field in r of size 3^2
          To:   Finite Field in s of size 3^4
          Defn: r |--> 2*s^3 + 2*s^2 + 1
        >>> T = LaurentPolynomialRing(R, Integer(2), names=('X', 'Y',)); (X, Y,) = T._first_ngens(2)
        >>> f = r*X + Y
        >>> g = f.map_coefficients(h); g
        (2*s^3 + 2*s^2 + 1)*X + Y
        >>> g.parent()
        Multivariate Laurent Polynomial Ring in X, Y
         over Finite Field in s of size 3^4
        >>> h = lambda x: x.trace()
        >>> g = f.map_coefficients(h); g
        X - Y
        >>> g.parent()
        Multivariate Laurent Polynomial Ring in X, Y
         over Finite Field in r of size 3^2
        >>> g = f.map_coefficients(h, new_base_ring=GF(Integer(3))); g
        X - Y
        >>> g.parent()
        Multivariate Laurent Polynomial Ring in X, Y over Finite Field of size 3

  monomial_coefficients()

    Abstract `dict` method.

    EXAMPLES:

    Sage

        sage: R.<x> = LaurentPolynomialRing(ZZ)
        sage: from sage.rings.polynomial.laurent_polynomial import LaurentPolynomial
        sage: LaurentPolynomial.monomial_coefficients(x)
        Traceback (most recent call last):
        ...
        NotImplementedError

    Python

        >>> from sage.all import *
        >>> R = LaurentPolynomialRing(ZZ, names=('x',)); (x,) = R._first_ngens(1)
        >>> from sage.rings.polynomial.laurent_polynomial import LaurentPolynomial
        >>> LaurentPolynomial.monomial_coefficients(x)
        Traceback (most recent call last):
        ...
        NotImplementedError

  number_of_terms()

    Abstract method for number of terms

    EXAMPLES:

    Sage

        sage: R.<x> = LaurentPolynomialRing(ZZ)
        sage: from sage.rings.polynomial.laurent_polynomial import LaurentPolynomial
        sage: LaurentPolynomial.number_of_terms(x)
        Traceback (most recent call last):
        ...
        NotImplementedError

    Python

        >>> from sage.all import *
        >>> R = LaurentPolynomialRing(ZZ, names=('x',)); (x,) = R._first_ngens(1)
        >>> from sage.rings.polynomial.laurent_polynomial import LaurentPolynomial
        >>> LaurentPolynomial.number_of_terms(x)
        Traceback (most recent call last):
        ...
        NotImplementedError

class sage.rings.polynomial.laurent_polynomial.LaurentPolynomial_univariate

  Bases: `LaurentPolynomial`

  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 that can be coerced to one)

  - `n` – integer (default: 0)

  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

  coefficients()

    Return the nonzero coefficients of `self`.

    EXAMPLES:

    Sage

        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]

    Python

        >>> from sage.all import *
        >>> R = LaurentPolynomialRing(QQ, names=('t',)); (t,) = R._first_ngens(1)
        >>> f = -Integer(5)/t**(Integer(2)) + t + t**Integer(2) - Integer(10)/Integer(3)*t**Integer(3)
        >>> f.coefficients()
        [-5, 1, 1, -10/3]

  constant_coefficient()

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

    EXAMPLES:

    Sage

        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

    Python

        >>> from sage.all import *
        >>> R = LaurentPolynomialRing(QQ, names=('t',)); (t,) = R._first_ngens(1)
        >>> f = Integer(3)*t**-Integer(2) - t**-Integer(1) + Integer(3) + t**Integer(2)
        >>> f.constant_coefficient()
        3
        >>> g = -Integer(2)*t**-Integer(2) + t**-Integer(1) + Integer(3)*t
        >>> g.constant_coefficient()
        0

  degree()

    Return the degree of `self`.

    EXAMPLES:

    Sage

        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

    Python

        >>> from sage.all import *
        >>> R = LaurentPolynomialRing(ZZ, names=('x',)); (x,) = R._first_ngens(1)
        >>> g = x**Integer(2) - x**Integer(4)
        >>> g.degree()
        4
        >>> g = -Integer(10)/x**Integer(5) + x**Integer(2) - x**Integer(7)
        >>> g.degree()
        7

    The zero polynomial is defined to have degree \(-\infty\):

    Sage

        sage: R.<x> = LaurentPolynomialRing(ZZ)
        sage: R.zero().degree()
        -Infinity

    [Python]

        >>> from sage.all import *
        >>> R = LaurentPolynomialRing(ZZ, names=('x',)); (x,) = R._first_ngens(1)
        >>> R.zero().degree()
        -Infinity

  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

        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

    Python

        >>> from sage.all import *
        >>> R = LaurentPolynomialRing(QQ, names=('x',)); (x,) = R._first_ngens(1)
        >>> g = Integer(1)/x**Integer(10) - x + x**Integer(2) - x**Integer(4)
        >>> g.derivative()
        -10*x^-11 - 1 + 2*x - 4*x^3
        >>> g.derivative(x)
        -10*x^-11 - 1 + 2*x - 4*x^3

    Sage

        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

    [Python]

        >>> from sage.all import *
        >>> R = PolynomialRing(ZZ, names=('t',)); (t,) = R._first_ngens(1)
        >>> S = LaurentPolynomialRing(R, names=('x',)); (x,) = S._first_ngens(1)
        >>> f = Integer(2)*t/x + (Integer(3)*t**Integer(2) + Integer(6)*t)*x
        >>> f.derivative()
        -2*t*x^-2 + (3*t^2 + 6*t)
        >>> f.derivative(x)
        -2*t*x^-2 + (3*t^2 + 6*t)
        >>> f.derivative(t)
        2*x^-1 + (6*t + 6)*x

  dict()

    alias of `monomial_coefficients()`.

  divides(other)

    Return `True` if `self` divides `other`.

    Note

    This method is only implemented for Laurent polynomials over integral domains. For rings with zero divisors, a `NotImplementedError` is raised.

    EXAMPLES:

    Sage

        sage: R.<x> = LaurentPolynomialRing(ZZ)
        sage: (2*x**-1 + 1).divides(4*x**-2 - 1)
        True
        sage: (2*x + 1).divides(4*x**2 + 1)
        False
        sage: (2*x + x**-1).divides(R(0))
        True
        sage: R(0).divides(2*x ** -1 + 1)
        False
        sage: R(0).divides(R(0))
        True
        sage: (x^2).divides(x)
        True

        sage: R.<x,y> = GF(2)[]
        sage: S.<z> = LaurentPolynomialRing(R)
        sage: p = (x+y+1) * z**-1 + x*y
        sage: q = (y^2-x^2) * z**-2 + z + x-y
        sage: p.divides(q), p.divides(p*q)                                          # needs sage.libs.singular
        (False, True)

    Python

        >>> from sage.all import *
        >>> R = LaurentPolynomialRing(ZZ, names=('x',)); (x,) = R._first_ngens(1)
        >>> (Integer(2)*x**-Integer(1) + Integer(1)).divides(Integer(4)*x**-Integer(2) - Integer(1))
        True
        >>> (Integer(2)*x + Integer(1)).divides(Integer(4)*x**Integer(2) + Integer(1))
        False
        >>> (Integer(2)*x + x**-Integer(1)).divides(R(Integer(0)))
        True
        >>> R(Integer(0)).divides(Integer(2)*x ** -Integer(1) + Integer(1))
        False
        >>> R(Integer(0)).divides(R(Integer(0)))
        True
        >>> (x**Integer(2)).divides(x)
        True

        >>> R = GF(Integer(2))['x, y']; (x, y,) = R._first_ngens(2)
        >>> S = LaurentPolynomialRing(R, names=('z',)); (z,) = S._first_ngens(1)
        >>> p = (x+y+Integer(1)) * z**-Integer(1) + x*y
        >>> q = (y**Integer(2)-x**Integer(2)) * z**-Integer(2) + z + x-y
        >>> p.divides(q), p.divides(p*q)                                          # needs sage.libs.singular
        (False, True)

  euclidean_degree()

    Return the degree of `self` as an element of an Euclidean domain.

    This is the Euclidean degree of the underlying polynomial.

    EXAMPLES:

    Sage

        sage: R.<x> = LaurentPolynomialRing(QQ)
        sage: (x^-5 + x^2).euclidean_degree()
        7

        sage: R.<x> = LaurentPolynomialRing(ZZ)
        sage: (x^-5 + x^2).euclidean_degree()
        Traceback (most recent call last):
        ...
        NotImplementedError

    Python

        >>> from sage.all import *
        >>> R = LaurentPolynomialRing(QQ, names=('x',)); (x,) = R._first_ngens(1)
        >>> (x**-Integer(5) + x**Integer(2)).euclidean_degree()
        7

        >>> R = LaurentPolynomialRing(ZZ, names=('x',)); (x,) = R._first_ngens(1)
        >>> (x**-Integer(5) + x**Integer(2)).euclidean_degree()
        Traceback (most recent call last):
        ...
        NotImplementedError

  exponents()

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

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> R = LaurentPolynomialRing(QQ, names=('t',)); (t,) = R._first_ngens(1)
        >>> f = -Integer(5)/t**(Integer(2)) + t + t**Integer(2) - Integer(10)/Integer(3)*t**Integer(3)
        >>> f.exponents()
        [-2, 1, 2, 3]

  factor()

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

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> R = LaurentPolynomialRing(ZZ, names=('t',)); (t,) = R._first_ngens(1)
        >>> f = Integer(4)*t**-Integer(7) + Integer(3)*t**Integer(3) + Integer(2)*t**Integer(4) + t**-Integer(6)
        >>> f.factor()                                                            # needs sage.libs.pari
        (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

        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

    Python

        >>> from sage.all import *
        >>> R = LaurentPolynomialRing(QQ, names=('t',)); (t,) = R._first_ngens(1)
        >>> t.gcd(Integer(2))
        1
        >>> gcd(t**-Integer(2) + Integer(1), t**-Integer(4) + Integer(3)*t**-Integer(1))
        t^-4
        >>> gcd((t**-Integer(2) + t)*(t + t**-Integer(1)), (t**Integer(5) + t**Integer(8))*(Integer(1) + t**-Integer(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

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

    Python

        >>> from sage.all import *
        >>> t = LaurentPolynomialRing(ZZ, 't').gen(0)
        >>> f = Integer(2)*t**-Integer(3) + Integer(3)*t**Integer(2)
        >>> f.integral()
        -t^-2 + t^3

    Sage

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

    [Python]

        >>> from sage.all import *
        >>> f = t**Integer(3)
        >>> 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

        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

    Python

        >>> from sage.all import *
        >>> t = LaurentPolynomialRing(ZZ,'t').gen(0)
        >>> f = -Integer(1)/t**Integer(3) - Integer(31)/t
        >>> 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

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

    [Python]

        >>> from sage.all import *
        >>> A = LaurentPolynomialRing(QQ, names=('t',)); (t,) = A._first_ngens(1)
        >>> f = -Integer(2)*t**(-Integer(4))
        >>> f.integral()
        2/3*t^-3
        >>> f.integral().derivative() == f
        True

  inverse_mod(a, m)

    Invert the polynomial `a` with respect to `m`, or raise a `ValueError` if no such inverse exists.

    The parameter `m` may be either a single polynomial or an ideal (for consistency with `inverse_mod()` in other rings).

    ALGORITHM: Solve the system \(as + mt = 1\), returning \(s\) as the inverse of \(a\) mod \(m\).

    EXAMPLES:

    Sage

        sage: S.<t> = LaurentPolynomialRing(QQ)
        sage: f = inverse_mod(t^-2 + 1, t^-3 + 1); f
        1/2*t^2 - 1/2*t^3 - 1/2*t^4
        sage: f * (t^-2 + 1) + (1/2*t^4 + 1/2*t^3) * (t^-3 + 1)
        1

    Python

        >>> from sage.all import *
        >>> S = LaurentPolynomialRing(QQ, names=('t',)); (t,) = S._first_ngens(1)
        >>> f = inverse_mod(t**-Integer(2) + Integer(1), t**-Integer(3) + Integer(1)); f
        1/2*t^2 - 1/2*t^3 - 1/2*t^4
        >>> f * (t**-Integer(2) + Integer(1)) + (Integer(1)/Integer(2)*t**Integer(4) + Integer(1)/Integer(2)*t**Integer(3)) * (t**-Integer(3) + Integer(1))
        1

  inverse_of_unit()

    Return the inverse of `self` if a unit.

    EXAMPLES:

    Sage

        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

    Python

        >>> from sage.all import *
        >>> R = LaurentPolynomialRing(QQ, names=('t',)); (t,) = R._first_ngens(1)
        >>> (t**-Integer(2)).inverse_of_unit()
        t^2
        >>> (t + Integer(2)).inverse_of_unit()
        Traceback (most recent call last):
        ...
        ArithmeticError: element is not a unit

  is_constant()

    Return whether this Laurent polynomial is constant.

    EXAMPLES:

    Sage

        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
        sage: R(0).is_constant()
        True
        sage: R(42).is_constant()
        True
        sage: x.is_constant()
        False
        sage: (1/x).is_constant()
        False

    Python

        >>> from sage.all import *
        >>> R = LaurentPolynomialRing(QQ, names=('x',)); (x,) = R._first_ngens(1)
        >>> x.is_constant()
        False
        >>> R.one().is_constant()
        True
        >>> (x**-Integer(2)).is_constant()
        False
        >>> (x**Integer(2)).is_constant()
        False
        >>> (x**-Integer(2) + Integer(2)).is_constant()
        False
        >>> R(Integer(0)).is_constant()
        True
        >>> R(Integer(42)).is_constant()
        True
        >>> x.is_constant()
        False
        >>> (Integer(1)/x).is_constant()
        False

  is_monomial()

    Return `True` if `self` is a monomial; that is, if `self` is \(x^n\) for some integer \(n\).

    EXAMPLES:

    Sage

        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

    Python

        >>> from sage.all import *
        >>> k = LaurentPolynomialRing(QQ, names=('z',)); (z,) = k._first_ngens(1)
        >>> z.is_monomial()
        True
        >>> k(Integer(1)).is_monomial()
        True
        >>> (z+Integer(1)).is_monomial()
        False
        >>> (z**-Integer(2909)).is_monomial()
        True
        >>> (Integer(38)*z**-Integer(2909)).is_monomial()
        False

  is_square(root=False)

    Return whether this Laurent polynomial is a square.

    If `root` is set to `True` then return a pair made of the boolean answer together with `None` or a square root.

    EXAMPLES:

    Sage

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

        sage: R.one().is_square()
        True
        sage: R(2).is_square()
        False

        sage: t.is_square()
        False
        sage: (t**-2).is_square()
        True

    Python

        >>> from sage.all import *
        >>> R = LaurentPolynomialRing(QQ, names=('t',)); (t,) = R._first_ngens(1)

        >>> R.one().is_square()
        True
        >>> R(Integer(2)).is_square()
        False

        >>> t.is_square()
        False
        >>> (t**-Integer(2)).is_square()
        True

    Usage of the `root` option:

    Sage

        sage: p = (1 + t^-1 - 2*t^3)
        sage: p.is_square(root=True)
        (False, None)
        sage: (p**2).is_square(root=True)
        (True, -t^-1 - 1 + 2*t^3)

    [Python]

        >>> from sage.all import *
        >>> p = (Integer(1) + t**-Integer(1) - Integer(2)*t**Integer(3))
        >>> p.is_square(root=True)
        (False, None)
        >>> (p**Integer(2)).is_square(root=True)
        (True, -t^-1 - 1 + 2*t^3)

    The answer is dependent of the base ring:

    Sage

        sage: S.<u> = LaurentPolynomialRing(QQbar)
        sage: (2 + 4*t + 2*t^2).is_square()
        False
        sage: (2 + 4*u + 2*u^2).is_square()
        True

    Python

        >>> from sage.all import *
        >>> S = LaurentPolynomialRing(QQbar, names=('u',)); (u,) = S._first_ngens(1)
        >>> (Integer(2) + Integer(4)*t + Integer(2)*t**Integer(2)).is_square()
        False
        >>> (Integer(2) + Integer(4)*u + Integer(2)*u**Integer(2)).is_square()
        True

  is_unit()

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

    EXAMPLES:

    Sage

        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

    Python

        >>> from sage.all import *
        >>> R = LaurentPolynomialRing(QQ, names=('t',)); (t,) = R._first_ngens(1)
        >>> (Integer(2) + t).is_unit()
        False
        >>> f = Integer(2)*t
        >>> f.is_unit()
        True
        >>> Integer(1)/f
        1/2*t^-1
        >>> R(Integer(0)).is_unit()
        False
        >>> R = LaurentPolynomialRing(ZZ, names=('s',)); (s,) = R._first_ngens(1)
        >>> g = Integer(2)*s
        >>> g.is_unit()
        False
        >>> Integer(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

        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

    Python

        >>> from sage.all import *
        >>> R = LaurentPolynomialRing(QQ, names=('x',)); (x,) = R._first_ngens(1)
        >>> f = Integer(1)/x + x + x**Integer(2) + Integer(3)*x**Integer(4)
        >>> f.is_zero()
        0
        >>> z = Integer(0)*f
        >>> z.is_zero()
        1

  monomial_coefficients()

    Return a dictionary representing `self`.

    EXAMPLES:

    Sage

        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.monomial_coefficients()
        {-9: y^3, -6: 3*x^3*y^2, -3: 3*x^6*y, 0: x^9, 2: 1}

    Python

        >>> from sage.all import *
        >>> R = ZZ['x, y']; (x, y,) = R._first_ngens(2)
        >>> Q = LaurentPolynomialRing(R, names=('t',)); (t,) = Q._first_ngens(1)
        >>> f = (x**Integer(3) + y/t**Integer(3))**Integer(3) + t**Integer(2); f
        y^3*t^-9 + 3*x^3*y^2*t^-6 + 3*x^6*y*t^-3 + x^9 + t^2
        >>> f.monomial_coefficients()
        {-9: y^3, -6: 3*x^3*y^2, -3: 3*x^6*y, 0: x^9, 2: 1}

    `dict` is an alias:

    Sage

        sage: f.dict()
        {-9: y^3, -6: 3*x^3*y^2, -3: 3*x^6*y, 0: x^9, 2: 1}

    [Python]

        >>> from sage.all import *
        >>> f.dict()
        {-9: y^3, -6: 3*x^3*y^2, -3: 3*x^6*y, 0: x^9, 2: 1}

  monomial_reduction()

    Return the decomposition as a polynomial and a power of the variable. Constructed for compatibility with the multivariate case.

    OUTPUT:

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

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> R = LaurentPolynomialRing(QQ, names=('x',)); (x,) = R._first_ngens(1)
        >>> f = Integer(1)/x + x**Integer(2) + Integer(3)*x**Integer(4)
        >>> f.monomial_reduction()
        (3*x^5 + x^3 + 1, x^-1)

  newton_polytope()

    Return the Newton polytope of this Laurent polynomial.

    EXAMPLES:

    Sage

        sage: R.<x> = LaurentPolynomialRing(QQ)
        sage: f = 1 + x + 33 * x^-3
        sage: P = f.newton_polytope(); P                                            # needs sage.geometry.polyhedron
        A 1-dimensional polyhedron in ZZ^1 defined as the convex hull of 2 vertices

    Python

        >>> from sage.all import *
        >>> R = LaurentPolynomialRing(QQ, names=('x',)); (x,) = R._first_ngens(1)
        >>> f = Integer(1) + x + Integer(33) * x**-Integer(3)
        >>> P = f.newton_polytope(); P                                            # needs sage.geometry.polyhedron
        A 1-dimensional polyhedron in ZZ^1 defined as the convex hull of 2 vertices

  number_of_terms()

    Return the number of nonzero coefficients of `self`.

    Also called weight, hamming weight or sparsity.

    EXAMPLES:

    Sage

        sage: R.<x> = LaurentPolynomialRing(ZZ)
        sage: f = x^3 - 1
        sage: f.number_of_terms()
        2
        sage: R(0).number_of_terms()
        0
        sage: f = (x+1)^100
        sage: f.number_of_terms()
        101

    Python

        >>> from sage.all import *
        >>> R = LaurentPolynomialRing(ZZ, names=('x',)); (x,) = R._first_ngens(1)
        >>> f = x**Integer(3) - Integer(1)
        >>> f.number_of_terms()
        2
        >>> R(Integer(0)).number_of_terms()
        0
        >>> f = (x+Integer(1))**Integer(100)
        >>> f.number_of_terms()
        101

    The method `hamming_weight()` is an alias:

    Sage

        sage: f.hamming_weight()
        101

    [Python]

        >>> from sage.all import *
        >>> f.hamming_weight()
        101

  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

        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)

    Python

        >>> from sage.all import *
        >>> R = LaurentPolynomialRing(QQ, names=('x',)); (x,) = R._first_ngens(1)
        >>> f = Integer(1)/x + x**Integer(2) + Integer(3)*x**Integer(4)
        >>> f.polynomial_construction()
        (3*x^5 + x^3 + 1, -1)

  quo_rem(other)

    Divide `self` by `other` and return a quotient `q` and a remainder `r` such that `self == q * other + r`.

    EXAMPLES:

    Sage

        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: num = t^-2 + t
        sage: den = t^-2 + 1
        sage: q, r = num.quo_rem(den)
        sage: num == q * den + r
        True

    Python

        >>> from sage.all import *
        >>> R = LaurentPolynomialRing(QQ, names=('t',)); (t,) = R._first_ngens(1)
        >>> (t**-Integer(3) - t**Integer(3)).quo_rem(t**-Integer(1) - t)
        (t^-2 + 1 + t^2, 0)
        >>> (t**-Integer(2) + Integer(3) + t).quo_rem(t**-Integer(4))
        (t^2 + 3*t^4 + t^5, 0)

        >>> num = t**-Integer(2) + t
        >>> den = t**-Integer(2) + Integer(1)
        >>> q, r = num.quo_rem(den)
        >>> num == q * den + r
        True

  residue()

    Return the residue of `self`.

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

    EXAMPLES:

    Sage

        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

    Python

        >>> from sage.all import *
        >>> R = LaurentPolynomialRing(QQ, names=('t',)); (t,) = R._first_ngens(1)
        >>> f = Integer(3)*t**-Integer(2) - t**-Integer(1) + Integer(3) + t**Integer(2)
        >>> f.residue()
        -1
        >>> g = -Integer(2)*t**-Integer(2) + Integer(4) + Integer(3)*t
        >>> g.residue()
        0
        >>> f.residue().parent()
        Rational Field

  shift(k)

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

    EXAMPLES:

    Sage

        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

    Python

        >>> from sage.all import *
        >>> R = LaurentPolynomialRing(QQ['y'], names=('t',)); (t,) = R._first_ngens(1)
        >>> f = (t+t**-Integer(1))**Integer(4); f
        t^-4 + 4*t^-2 + 6 + 4*t^2 + t^4
        >>> f.shift(Integer(10))
        t^6 + 4*t^8 + 6*t^10 + 4*t^12 + t^14
        >>> f >> Integer(10)
        t^-14 + 4*t^-12 + 6*t^-10 + 4*t^-8 + t^-6
        >>> f << Integer(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

        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

    Python

        >>> from sage.all import *
        >>> R = LaurentPolynomialRing(QQ, names=('x',)); (x,) = R._first_ngens(1)
        >>> f = Integer(1)/x**Integer(12) + x**Integer(3) + x**Integer(5) + x**Integer(9)
        >>> f.truncate(Integer(10))
        x^-12 + x^3 + x^5 + x^9
        >>> f.truncate(Integer(5))
        x^-12 + x^3
        >>> f.truncate(-Integer(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

        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

    Python

        >>> from sage.all import *
        >>> R = LaurentPolynomialRing(ZZ, names=('x',)); (x,) = R._first_ngens(1)
        >>> f = Integer(1)/x + x**Integer(2) + Integer(3)*x**Integer(4)
        >>> g = Integer(1) - x + x**Integer(2) - x**Integer(4)
        >>> f.valuation()
        -1
        >>> g.valuation()
        0

  variable_name()

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

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> R = LaurentPolynomialRing(QQ, names=('x',)); (x,) = R._first_ngens(1)
        >>> f = Integer(1)/x + x**Integer(2) + Integer(3)*x**Integer(4)
        >>> f.variable_name()
        'x'

  variables()

    Return the tuple of variables occurring in this Laurent polynomial.

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> R = LaurentPolynomialRing(QQ, names=('x',)); (x,) = R._first_ngens(1)
        >>> f = Integer(1)/x + x**Integer(2) + Integer(3)*x**Integer(4)
        >>> f.variables()
        (x,)
        >>> R.one().variables()
        ()

  xgcd(other)

    Extended `gcd()` for univariate Laurent polynomial rings over a field.

    OUTPUT:

    A triple `(g, p, q)` such that `g` is the `gcd()` of `self` (\(= a\)) and `other` (\(= b\)), and `p` and `q` are cofactors satisfying the Bezout identity

    \[g = p \cdot a + q \cdot b.\]

    EXAMPLES:

    Sage

        sage: S.<t> = LaurentPolynomialRing(QQ)
        sage: a = t^-2 + 1
        sage: b = t^-3 + 1
        sage: g, p, q = a.xgcd(b); (g, p, q)
        (t^-3, 1/2*t^-1 - 1/2 - 1/2*t, 1/2 + 1/2*t)
        sage: g == p * a + q * b
        True
        sage: g == a.gcd(b)
        True
        sage: t.xgcd(t)
        (t, 0, 1)
        sage: t.xgcd(5)
        (1, 0, 1/5)

    Python

        >>> from sage.all import *
        >>> S = LaurentPolynomialRing(QQ, names=('t',)); (t,) = S._first_ngens(1)
        >>> a = t**-Integer(2) + Integer(1)
        >>> b = t**-Integer(3) + Integer(1)
        >>> g, p, q = a.xgcd(b); (g, p, q)
        (t^-3, 1/2*t^-1 - 1/2 - 1/2*t, 1/2 + 1/2*t)
        >>> g == p * a + q * b
        True
        >>> g == a.gcd(b)
        True
        >>> t.xgcd(t)
        (t, 0, 1)
        >>> t.xgcd(Integer(5))
        (1, 0, 1/5)