Ring of Laurent Polynomials (base class)¶

If \(R\) is a commutative ring, then the ring of Laurent polynomials in \(n\) variables over \(R\) is \(R[x_1^{\pm 1}, x_2^{\pm 1}, \ldots, x_n^{\pm 1}]\).

AUTHORS:

David Roe (2008-2-23): created
David Loeffler (2009-07-10): cleaned up docstrings

class sage.rings.polynomial.laurent_polynomial_ring_base.LaurentPolynomialRing_generic(R)[source]¶

Bases: CommutativeRing, Parent

Laurent polynomial ring (base class).

EXAMPLES:

This base class inherits from CommutativeRing. Since Issue #11900, it is also initialised as such:

Sage

sage: R.<x1,x2> = LaurentPolynomialRing(QQ)
sage: R.category()
Join of Category of unique factorization domains
    and Category of algebras with basis
        over (number fields and quotient fields and metric spaces)
    and Category of commutative algebras
        over (number fields and quotient fields and metric spaces)
    and Category of infinite sets
sage: TestSuite(R).run()

Python

>>> from sage.all import *
>>> R = LaurentPolynomialRing(QQ, names=('x1', 'x2',)); (x1, x2,) = R._first_ngens(2)
>>> R.category()
Join of Category of unique factorization domains
    and Category of algebras with basis
        over (number fields and quotient fields and metric spaces)
    and Category of commutative algebras
        over (number fields and quotient fields and metric spaces)
    and Category of infinite sets
>>> TestSuite(R).run()

Sage Live

R.<x1,x2> = LaurentPolynomialRing(QQ)
R.category()
TestSuite(R).run()

change_ring(base_ring=None, names=None, sparse=False, order=None)[source]¶

EXAMPLES:

Sage

sage: R = LaurentPolynomialRing(QQ, 2, 'x')
sage: R.change_ring(ZZ)
Multivariate Laurent Polynomial Ring in x0, x1 over Integer Ring

Python

>>> from sage.all import *
>>> R = LaurentPolynomialRing(QQ, Integer(2), 'x')
>>> R.change_ring(ZZ)
Multivariate Laurent Polynomial Ring in x0, x1 over Integer Ring

Sage Live

R = LaurentPolynomialRing(QQ, 2, 'x')
R.change_ring(ZZ)

Check that the distinction between a univariate ring and a multivariate ring with one generator is preserved:

Sage

sage: P.<x> = LaurentPolynomialRing(QQ, 1)
sage: P
Multivariate Laurent Polynomial Ring in x over Rational Field
sage: K.<i> = CyclotomicField(4)                                                        # needs sage.rings.number_field
sage: P.change_ring(K)                                                                  # needs sage.rings.number_field
Multivariate Laurent Polynomial Ring in x over
 Cyclotomic Field of order 4 and degree 2

Python

>>> from sage.all import *
>>> P = LaurentPolynomialRing(QQ, Integer(1), names=('x',)); (x,) = P._first_ngens(1)
>>> P
Multivariate Laurent Polynomial Ring in x over Rational Field
>>> K = CyclotomicField(Integer(4), names=('i',)); (i,) = K._first_ngens(1)# needs sage.rings.number_field
>>> P.change_ring(K)                                                                  # needs sage.rings.number_field
Multivariate Laurent Polynomial Ring in x over
 Cyclotomic Field of order 4 and degree 2

Sage Live

P.<x> = LaurentPolynomialRing(QQ, 1)
P
K.<i> = CyclotomicField(4)                                                        # needs sage.rings.number_field
P.change_ring(K)                                                                  # needs sage.rings.number_field

characteristic()[source]¶

Return the characteristic of the base ring.

EXAMPLES:

Sage

sage: LaurentPolynomialRing(QQ, 2, 'x').characteristic()
0
sage: LaurentPolynomialRing(GF(3), 2, 'x').characteristic()
3

Python

>>> from sage.all import *
>>> LaurentPolynomialRing(QQ, Integer(2), 'x').characteristic()
0
>>> LaurentPolynomialRing(GF(Integer(3)), Integer(2), 'x').characteristic()
3

Sage Live

LaurentPolynomialRing(QQ, 2, 'x').characteristic()
LaurentPolynomialRing(GF(3), 2, 'x').characteristic()

completion(p=None, prec=20, extras=None)[source]¶

Return the completion of self.

Currently only implemented for the ring of formal Laurent series. The prec variable controls the precision used in the Laurent series ring. If prec is \(\infty\), then this returns a LazyLaurentSeriesRing.

EXAMPLES:

Sage

sage: P.<x> = LaurentPolynomialRing(QQ); P
Univariate Laurent Polynomial Ring in x over Rational Field
sage: PP = P.completion(x); PP
Laurent Series Ring in x over Rational Field
sage: f = 1 - 1/x
sage: PP(f)
-x^-1 + 1
sage: g = 1 / PP(f); g
-x - x^2 - x^3 - x^4 - x^5 - x^6 - x^7 - x^8 - x^9 - x^10 - x^11
 - x^12 - x^13 - x^14 - x^15 - x^16 - x^17 - x^18 - x^19 - x^20 + O(x^21)
sage: 1 / g
-x^-1 + 1 + O(x^19)

sage: # needs sage.combinat
sage: PP = P.completion(x, prec=oo); PP
Lazy Laurent Series Ring in x over Rational Field
sage: g = 1 / PP(f); g
-x - x^2 - x^3 + O(x^4)
sage: 1 / g == f
True

Python

>>> from sage.all import *
>>> P = LaurentPolynomialRing(QQ, names=('x',)); (x,) = P._first_ngens(1); P
Univariate Laurent Polynomial Ring in x over Rational Field
>>> PP = P.completion(x); PP
Laurent Series Ring in x over Rational Field
>>> f = Integer(1) - Integer(1)/x
>>> PP(f)
-x^-1 + 1
>>> g = Integer(1) / PP(f); g
-x - x^2 - x^3 - x^4 - x^5 - x^6 - x^7 - x^8 - x^9 - x^10 - x^11
 - x^12 - x^13 - x^14 - x^15 - x^16 - x^17 - x^18 - x^19 - x^20 + O(x^21)
>>> Integer(1) / g
-x^-1 + 1 + O(x^19)

>>> # needs sage.combinat
>>> PP = P.completion(x, prec=oo); PP
Lazy Laurent Series Ring in x over Rational Field
>>> g = Integer(1) / PP(f); g
-x - x^2 - x^3 + O(x^4)
>>> Integer(1) / g == f
True

Sage Live

P.<x> = LaurentPolynomialRing(QQ); P
PP = P.completion(x); PP
f = 1 - 1/x
PP(f)
g = 1 / PP(f); g
1 / g
# needs sage.combinat
PP = P.completion(x, prec=oo); PP
g = 1 / PP(f); g
1 / g == f

construction()[source]¶

Return the construction of self.

EXAMPLES:

Sage

sage: LaurentPolynomialRing(QQ, 2, 'x,y').construction()
(LaurentPolynomialFunctor,
 Univariate Laurent Polynomial Ring in x over Rational Field)

Python

>>> from sage.all import *
>>> LaurentPolynomialRing(QQ, Integer(2), 'x,y').construction()
(LaurentPolynomialFunctor,
 Univariate Laurent Polynomial Ring in x over Rational Field)

Sage Live

LaurentPolynomialRing(QQ, 2, 'x,y').construction()

fraction_field()[source]¶

The fraction field is the same as the fraction field of the polynomial ring.

EXAMPLES:

Sage

sage: L.<x> = LaurentPolynomialRing(QQ)
sage: L.fraction_field()
Fraction Field of Univariate Polynomial Ring in x over Rational Field
sage: (x^-1 + 2) / (x - 1)
(2*x + 1)/(x^2 - x)

Python

>>> from sage.all import *
>>> L = LaurentPolynomialRing(QQ, names=('x',)); (x,) = L._first_ngens(1)
>>> L.fraction_field()
Fraction Field of Univariate Polynomial Ring in x over Rational Field
>>> (x**-Integer(1) + Integer(2)) / (x - Integer(1))
(2*x + 1)/(x^2 - x)

Sage Live

L.<x> = LaurentPolynomialRing(QQ)
L.fraction_field()
(x^-1 + 2) / (x - 1)

gen(i=0)[source]¶

Return the \(i\)-th generator of self. If \(i\) is not specified, then the first generator will be returned.

EXAMPLES:

Sage

sage: LaurentPolynomialRing(QQ, 2, 'x').gen()
x0
sage: LaurentPolynomialRing(QQ, 2, 'x').gen(0)
x0
sage: LaurentPolynomialRing(QQ, 2, 'x').gen(1)
x1

Python

>>> from sage.all import *
>>> LaurentPolynomialRing(QQ, Integer(2), 'x').gen()
x0
>>> LaurentPolynomialRing(QQ, Integer(2), 'x').gen(Integer(0))
x0
>>> LaurentPolynomialRing(QQ, Integer(2), 'x').gen(Integer(1))
x1

Sage Live

LaurentPolynomialRing(QQ, 2, 'x').gen()
LaurentPolynomialRing(QQ, 2, 'x').gen(0)
LaurentPolynomialRing(QQ, 2, 'x').gen(1)

ideal(*args, **kwds)[source]¶

EXAMPLES:

Sage

sage: LaurentPolynomialRing(QQ, 2, 'x').ideal([1])
Ideal (1) of Multivariate Laurent Polynomial Ring in x0, x1 over Rational Field

Python

>>> from sage.all import *
>>> LaurentPolynomialRing(QQ, Integer(2), 'x').ideal([Integer(1)])
Ideal (1) of Multivariate Laurent Polynomial Ring in x0, x1 over Rational Field

Sage Live

LaurentPolynomialRing(QQ, 2, 'x').ideal([1])

is_exact()[source]¶

Return True if the base ring is exact.

EXAMPLES:

Sage

sage: LaurentPolynomialRing(QQ, 2, 'x').is_exact()
True
sage: LaurentPolynomialRing(RDF, 2, 'x').is_exact()
False

Python

>>> from sage.all import *
>>> LaurentPolynomialRing(QQ, Integer(2), 'x').is_exact()
True
>>> LaurentPolynomialRing(RDF, Integer(2), 'x').is_exact()
False

Sage Live

LaurentPolynomialRing(QQ, 2, 'x').is_exact()
LaurentPolynomialRing(RDF, 2, 'x').is_exact()

is_field(proof=True)[source]¶

EXAMPLES:

Sage

sage: LaurentPolynomialRing(QQ, 2, 'x').is_field()
False

Python

>>> from sage.all import *
>>> LaurentPolynomialRing(QQ, Integer(2), 'x').is_field()
False

Sage Live

LaurentPolynomialRing(QQ, 2, 'x').is_field()

is_finite()[source]¶

EXAMPLES:

Sage

sage: LaurentPolynomialRing(QQ, 2, 'x').is_finite()
False

Python

>>> from sage.all import *
>>> LaurentPolynomialRing(QQ, Integer(2), 'x').is_finite()
False

Sage Live

LaurentPolynomialRing(QQ, 2, 'x').is_finite()

is_integral_domain(proof=True)[source]¶

Return True if self is an integral domain.

EXAMPLES:

Sage

sage: LaurentPolynomialRing(QQ, 2, 'x').is_integral_domain()
True

Python

>>> from sage.all import *
>>> LaurentPolynomialRing(QQ, Integer(2), 'x').is_integral_domain()
True

Sage Live

LaurentPolynomialRing(QQ, 2, 'x').is_integral_domain()

The following used to fail; see Issue #7530:

Sage

sage: L = LaurentPolynomialRing(ZZ, 'X')
sage: L['Y']
Univariate Polynomial Ring in Y over
 Univariate Laurent Polynomial Ring in X over Integer Ring

Python

>>> from sage.all import *
>>> L = LaurentPolynomialRing(ZZ, 'X')
>>> L['Y']
Univariate Polynomial Ring in Y over
 Univariate Laurent Polynomial Ring in X over Integer Ring

Sage Live

L = LaurentPolynomialRing(ZZ, 'X')
L['Y']

is_noetherian()[source]¶

Return True if self is Noetherian.

EXAMPLES:

Sage

sage: LaurentPolynomialRing(QQ, 2, 'x').is_noetherian()
True

Python

>>> from sage.all import *
>>> LaurentPolynomialRing(QQ, Integer(2), 'x').is_noetherian()
True

Sage Live

LaurentPolynomialRing(QQ, 2, 'x').is_noetherian()

krull_dimension()[source]¶

EXAMPLES:

Sage

sage: LaurentPolynomialRing(QQ, 2, 'x').krull_dimension()
Traceback (most recent call last):
...
NotImplementedError

Python

>>> from sage.all import *
>>> LaurentPolynomialRing(QQ, Integer(2), 'x').krull_dimension()
Traceback (most recent call last):
...
NotImplementedError

Sage Live

LaurentPolynomialRing(QQ, 2, 'x').krull_dimension()

ngens()[source]¶

Return the number of generators of self.

EXAMPLES:

Sage

sage: LaurentPolynomialRing(QQ, 2, 'x').ngens()
2
sage: LaurentPolynomialRing(QQ, 1, 'x').ngens()
1

Python

>>> from sage.all import *
>>> LaurentPolynomialRing(QQ, Integer(2), 'x').ngens()
2
>>> LaurentPolynomialRing(QQ, Integer(1), 'x').ngens()
1

Sage Live

LaurentPolynomialRing(QQ, 2, 'x').ngens()
LaurentPolynomialRing(QQ, 1, 'x').ngens()

polynomial_ring()[source]¶

Return the polynomial ring associated with self.

EXAMPLES:

Sage

sage: LaurentPolynomialRing(QQ, 2, 'x').polynomial_ring()
Multivariate Polynomial Ring in x0, x1 over Rational Field
sage: LaurentPolynomialRing(QQ, 1, 'x').polynomial_ring()
Multivariate Polynomial Ring in x over Rational Field

Python

>>> from sage.all import *
>>> LaurentPolynomialRing(QQ, Integer(2), 'x').polynomial_ring()
Multivariate Polynomial Ring in x0, x1 over Rational Field
>>> LaurentPolynomialRing(QQ, Integer(1), 'x').polynomial_ring()
Multivariate Polynomial Ring in x over Rational Field

Sage Live

LaurentPolynomialRing(QQ, 2, 'x').polynomial_ring()
LaurentPolynomialRing(QQ, 1, 'x').polynomial_ring()

random_element(min_valuation=-2, max_degree=2, *args, **kwds)[source]¶

Return a random polynomial with degree at most max_degree and lowest valuation at least min_valuation.

Uses the random sampling from the base polynomial ring then divides out by a monomial to ensure correct max_degree and min_valuation.

INPUT:

min_valuation – integer (default: \(-2\)); the minimal allowed valuation of the polynomial
max_degree – integer (default: \(2\)); the maximal allowed degree of the polynomial
*args, **kwds – passed to the random element generator of the base polynomial ring and base ring itself

EXAMPLES:

Sage

sage: L.<x> = LaurentPolynomialRing(QQ)
sage: f = L.random_element()
sage: f.degree() <= 2
True
sage: f.valuation() >= -2
True
sage: f.parent() is L
True

Python

>>> from sage.all import *
>>> L = LaurentPolynomialRing(QQ, names=('x',)); (x,) = L._first_ngens(1)
>>> f = L.random_element()
>>> f.degree() <= Integer(2)
True
>>> f.valuation() >= -Integer(2)
True
>>> f.parent() is L
True

Sage Live

L.<x> = LaurentPolynomialRing(QQ)
f = L.random_element()
f.degree() <= 2
f.valuation() >= -2
f.parent() is L

Sage

sage: L = LaurentPolynomialRing(ZZ, 2, 'x')
sage: f = L.random_element(10, 20)
sage: f.degree() <= 20
True
sage: f.valuation() >= 10
True
sage: f.parent() is L
True

Python

>>> from sage.all import *
>>> L = LaurentPolynomialRing(ZZ, Integer(2), 'x')
>>> f = L.random_element(Integer(10), Integer(20))
>>> f.degree() <= Integer(20)
True
>>> f.valuation() >= Integer(10)
True
>>> f.parent() is L
True

Sage Live

L = LaurentPolynomialRing(ZZ, 2, 'x')
f = L.random_element(10, 20)
f.degree() <= 20
f.valuation() >= 10
f.parent() is L

Python

>>> from sage.all import *
>>> L = LaurentPolynomialRing(ZZ, Integer(2), 'x')
>>> f = L.random_element(Integer(10), Integer(20))
>>> f.degree() <= Integer(20)
True
>>> f.valuation() >= Integer(10)
True
>>> f.parent() is L
True

Sage Live

L = LaurentPolynomialRing(ZZ, 2, 'x')
f = L.random_element(10, 20)
f.degree() <= 20
f.valuation() >= 10
f.parent() is L

Sage

sage: L = LaurentPolynomialRing(GF(13), 3, 'x')
sage: f = L.random_element(-10, -1)
sage: f.degree() <= -1
True
sage: f.valuation() >= -10
True
sage: f.parent() is L
True

Python

>>> from sage.all import *
>>> L = LaurentPolynomialRing(GF(Integer(13)), Integer(3), 'x')
>>> f = L.random_element(-Integer(10), -Integer(1))
>>> f.degree() <= -Integer(1)
True
>>> f.valuation() >= -Integer(10)
True
>>> f.parent() is L
True

Sage Live

L = LaurentPolynomialRing(GF(13), 3, 'x')
f = L.random_element(-10, -1)
f.degree() <= -1
f.valuation() >= -10
f.parent() is L

Python

>>> from sage.all import *
>>> L = LaurentPolynomialRing(GF(Integer(13)), Integer(3), 'x')
>>> f = L.random_element(-Integer(10), -Integer(1))
>>> f.degree() <= -Integer(1)
True
>>> f.valuation() >= -Integer(10)
True
>>> f.parent() is L
True

Sage Live

L = LaurentPolynomialRing(GF(13), 3, 'x')
f = L.random_element(-10, -1)
f.degree() <= -1
f.valuation() >= -10
f.parent() is L

Sage

sage: L.<x, y> = LaurentPolynomialRing(RR)
sage: f = L.random_element()
sage: f.degree() <= 2
True
sage: f.valuation() >= -2
True
sage: f.parent() is L
True

Python

>>> from sage.all import *
>>> L = LaurentPolynomialRing(RR, names=('x', 'y',)); (x, y,) = L._first_ngens(2)
>>> f = L.random_element()
>>> f.degree() <= Integer(2)
True
>>> f.valuation() >= -Integer(2)
True
>>> f.parent() is L
True

Sage Live

L.<x, y> = LaurentPolynomialRing(RR)
f = L.random_element()
f.degree() <= 2
f.valuation() >= -2
f.parent() is L

Python

>>> from sage.all import *
>>> L = LaurentPolynomialRing(RR, names=('x', 'y',)); (x, y,) = L._first_ngens(2)
>>> f = L.random_element()
>>> f.degree() <= Integer(2)
True
>>> f.valuation() >= -Integer(2)
True
>>> f.parent() is L
True

Sage Live

L.<x, y> = LaurentPolynomialRing(RR)
f = L.random_element()
f.degree() <= 2
f.valuation() >= -2
f.parent() is L

Sage

sage: L = LaurentPolynomialRing(QQbar, 5, 'x')
sage: f = L.random_element(-1, 1)
sage: f = L.random_element(-1, 1)
sage: f.degree() <= 1
True
sage: f.valuation() >= -1
True
sage: f.parent() is L
True

Python

>>> from sage.all import *
>>> L = LaurentPolynomialRing(QQbar, Integer(5), 'x')
>>> f = L.random_element(-Integer(1), Integer(1))
>>> f = L.random_element(-Integer(1), Integer(1))
>>> f.degree() <= Integer(1)
True
>>> f.valuation() >= -Integer(1)
True
>>> f.parent() is L
True

Sage Live

L = LaurentPolynomialRing(QQbar, 5, 'x')
f = L.random_element(-1, 1)
f = L.random_element(-1, 1)
f.degree() <= 1
f.valuation() >= -1
f.parent() is L

Python

>>> from sage.all import *
>>> L = LaurentPolynomialRing(QQbar, Integer(5), 'x')
>>> f = L.random_element(-Integer(1), Integer(1))
>>> f = L.random_element(-Integer(1), Integer(1))
>>> f.degree() <= Integer(1)
True
>>> f.valuation() >= -Integer(1)
True
>>> f.parent() is L
True

Sage Live

L = LaurentPolynomialRing(QQbar, 5, 'x')
f = L.random_element(-1, 1)
f = L.random_element(-1, 1)
f.degree() <= 1
f.valuation() >= -1
f.parent() is L

remove_var(var)[source]¶

EXAMPLES:

Sage

sage: R = LaurentPolynomialRing(QQ,'x,y,z')
sage: R.remove_var('x')
Multivariate Laurent Polynomial Ring in y, z over Rational Field
sage: R.remove_var('x').remove_var('y')
Univariate Laurent Polynomial Ring in z over Rational Field

Python

>>> from sage.all import *
>>> R = LaurentPolynomialRing(QQ,'x,y,z')
>>> R.remove_var('x')
Multivariate Laurent Polynomial Ring in y, z over Rational Field
>>> R.remove_var('x').remove_var('y')
Univariate Laurent Polynomial Ring in z over Rational Field

Sage Live

R = LaurentPolynomialRing(QQ,'x,y,z')
R.remove_var('x')
R.remove_var('x').remove_var('y')

term_order()[source]¶

Return the term order of self.

EXAMPLES:

Sage

sage: LaurentPolynomialRing(QQ, 2, 'x').term_order()
Degree reverse lexicographic term order

Python

>>> from sage.all import *
>>> LaurentPolynomialRing(QQ, Integer(2), 'x').term_order()
Degree reverse lexicographic term order

Sage Live

LaurentPolynomialRing(QQ, 2, 'x').term_order()

variable_names_recursive(depth=+Infinity)[source]¶

Return the list of variable names of this ring and its base rings, as if it were a single multi-variate Laurent polynomial.

INPUT:

depth – integer or Infinity

OUTPUT: a tuple of strings

EXAMPLES:

Sage

sage: T = LaurentPolynomialRing(QQ, 'x')
sage: S = LaurentPolynomialRing(T, 'y')
sage: R = LaurentPolynomialRing(S, 'z')
sage: R.variable_names_recursive()
('x', 'y', 'z')
sage: R.variable_names_recursive(2)
('y', 'z')

Python

>>> from sage.all import *
>>> T = LaurentPolynomialRing(QQ, 'x')
>>> S = LaurentPolynomialRing(T, 'y')
>>> R = LaurentPolynomialRing(S, 'z')
>>> R.variable_names_recursive()
('x', 'y', 'z')
>>> R.variable_names_recursive(Integer(2))
('y', 'z')

Sage Live

T = LaurentPolynomialRing(QQ, 'x')
S = LaurentPolynomialRing(T, 'y')
R = LaurentPolynomialRing(S, 'z')
R.variable_names_recursive()
R.variable_names_recursive(2)