Univariate Polynomial Rings

Sage implements sparse and dense polynomials over commutative and non-commutative rings. In the non-commutative case, the polynomial variable commutes with the elements of the base ring.

AUTHOR:

• William Stein
• Kiran Kedlaya (2006-02-13): added macaulay2 option
• Martin Albrecht (2006-08-25): removed it again as it isn’t needed anymore

EXAMPLES: Creating a polynomial ring injects the variable into the interpreter namespace:

sage: z = QQ['z'].0
sage: (z^3 + z - 1)^3
z^9 + 3*z^7 - 3*z^6 + 3*z^5 - 6*z^4 + 4*z^3 - 3*z^2 + 3*z - 1

Saving and loading of polynomial rings works:

sage: loads(dumps(QQ['x'])) == QQ['x']
True
sage: k = PolynomialRing(QQ['x'],'y'); loads(dumps(k))==k
True    
sage: k = PolynomialRing(ZZ,'y'); loads(dumps(k)) == k
True
sage: k = PolynomialRing(ZZ,'y', sparse=True); loads(dumps(k))
Sparse Univariate Polynomial Ring in y over Integer Ring

The rings of sparse and dense polynomials in the same variable are canonically isomorphic:

sage: PolynomialRing(ZZ,'y', sparse=True) == PolynomialRing(ZZ,'y')
True

sage: QQ['y'] < QQ['x']
False
sage: QQ['y'] < QQ['z']
True

We create a polynomial ring over a quaternion algebra:

sage: A.<i,j,k> = QuaternionAlgebra(QQ, -1,-1)
sage: R.<w> = PolynomialRing(A,sparse=True)
sage: f = w^3 + (i+j)*w + 1
sage: f
w^3 + (i + j)*w + 1
sage: f^2
w^6 + (2*i + 2*j)*w^4 + 2*w^3 - 2*w^2 + (2*i + 2*j)*w + 1
sage: f = w + i ; g = w + j
sage: f * g
w^2 + (i + j)*w + k
sage: g * f
w^2 + (i + j)*w - k

TESTS:

sage: K.<x>=FractionField(QQ['x'])
sage: V.<z> = K[]
sage: x+z
z + x

These may change over time:

sage: type(ZZ['x'].0)
<type 'sage.rings.polynomial.polynomial_integer_dense_flint.Polynomial_integer_dense_flint'>
sage: type(QQ['x'].0)
<class 'sage.rings.polynomial.polynomial_element_generic.Polynomial_rational_dense'>
sage: type(RR['x'].0)
<type 'sage.rings.polynomial.polynomial_real_mpfr_dense.PolynomialRealDense'>
sage: type(Integers(4)['x'].0)
<type 'sage.rings.polynomial.polynomial_zmod_flint.Polynomial_zmod_flint'>
sage: type(Integers(5*2^100)['x'].0)
<type 'sage.rings.polynomial.polynomial_modn_dense_ntl.Polynomial_dense_modn_ntl_ZZ'>
sage: type(CC['x'].0)
<class 'sage.rings.polynomial.polynomial_element_generic.Polynomial_generic_dense_field'>
sage: type(CC['t']['x'].0)
<type 'sage.rings.polynomial.polynomial_element.Polynomial_generic_dense'>

class sage.rings.polynomial.polynomial_ring.PolynomialRing_commutative(base_ring, name=None, sparse=False, element_class=None)

Univariate polynomial ring over a commutative ring.

__init__(base_ring, name=None, sparse=False, element_class=None)

quotient_by_principal_ideal(f, names=None)

Return the quotient of this polynomial ring by the principal ideal generated by .

EXAMPLES:

class sage.rings.polynomial.polynomial_ring.PolynomialRing_dense_mod_n(base_ring, name=None, element_class=None, implementation=None)

__init__(base_ring, name=None, element_class=None, implementation=None)

TESTS:

sage: from sage.rings.polynomial.polynomial_ring import PolynomialRing_dense_mod_n as PRing
sage: R = PRing(Zmod(15), 'x'); R
Univariate Polynomial Ring in x over Ring of integers modulo 15
sage: type(R.gen())
<type 'sage.rings.polynomial.polynomial_zmod_flint.Polynomial_zmod_flint'>

sage: R = PRing(Zmod(15), 'x', implementation='NTL'); R
Univariate Polynomial Ring in x over Ring of integers modulo 15 (using NTL)
sage: type(R.gen())
<type 'sage.rings.polynomial.polynomial_modn_dense_ntl.Polynomial_dense_modn_ntl_zz'>

sage: R = PRing(Zmod(2**63*3), 'x', implementation='NTL'); R
Univariate Polynomial Ring in x over Ring of integers modulo 27670116110564327424 (using NTL)
sage: type(R.gen())
<type 'sage.rings.polynomial.polynomial_modn_dense_ntl.Polynomial_dense_modn_ntl_ZZ'>

sage: R = PRing(Zmod(2**63*3), 'x', implementation='FLINT')
...
ValueError: FLINT does not support modulus 27670116110564327424

sage: R = PRing(Zmod(2**63*3), 'x'); R
Univariate Polynomial Ring in x over Ring of integers modulo 27670116110564327424 (using NTL)
sage: type(R.gen())
<type 'sage.rings.polynomial.polynomial_modn_dense_ntl.Polynomial_dense_modn_ntl_ZZ'>

_repr_()

TESTS:

sage: from sage.rings.polynomial.polynomial_ring import PolynomialRing_integral_domain as PRing
sage: R = PRing(ZZ, 'x', implementation='NTL'); R
Univariate Polynomial Ring in x over Integer Ring (using NTL)

modulus()

EXAMPLES:

sage: R.<x> = Zmod(15)[]
sage: R.modulus()
15

class sage.rings.polynomial.polynomial_ring.PolynomialRing_dense_mod_p(base_ring, name='x', implementation=None)

__init__(base_ring, name='x', implementation=None)

TESTS:

sage: P = GF(2)['x']; P
Univariate Polynomial Ring in x over Finite Field of size 2 (using NTL)
sage: type(P.gen())
<type 'sage.rings.polynomial.polynomial_gf2x.Polynomial_GF2X'>

sage: from sage.rings.polynomial.polynomial_ring import PolynomialRing_dense_mod_p
sage: P = PolynomialRing_dense_mod_p(GF(5), 'x'); P
Univariate Polynomial Ring in x over Finite Field of size 5
sage: type(P.gen())
<type 'sage.rings.polynomial.polynomial_zmod_flint.Polynomial_zmod_flint'>

sage: P = PolynomialRing_dense_mod_p(GF(5), 'x', implementation='NTL'); P
Univariate Polynomial Ring in x over Finite Field of size 5 (using NTL)
sage: type(P.gen())
<type 'sage.rings.polynomial.polynomial_modn_dense_ntl.Polynomial_dense_mod_p'>

sage: P = PolynomialRing_dense_mod_p(GF(9223372036854775837), 'x')
sage: P
Univariate Polynomial Ring in x over Finite Field of size 9223372036854775837 (using NTL)
sage: type(P.gen())
<type 'sage.rings.polynomial.polynomial_modn_dense_ntl.Polynomial_dense_mod_p'>

class sage.rings.polynomial.polynomial_ring.PolynomialRing_dense_padic_field_capped_relative(base_ring, name=None, element_class=None)

__init__(base_ring, name=None, element_class=None)

TESTS:

sage: from sage.rings.polynomial.polynomial_ring import PolynomialRing_dense_padic_field_capped_relative as PRing
sage: R = PRing(Qp(13), name='t'); R
Univariate Polynomial Ring in t over 13-adic Field with capped relative precision 20
sage: type(R.gen())
<class 'sage.rings.polynomial.padics.polynomial_padic_capped_relative_dense.Polynomial_padic_capped_relative_dense'>

class sage.rings.polynomial.polynomial_ring.PolynomialRing_dense_padic_field_generic(base_ring, name='x', sparse=False, element_class=None)

class sage.rings.polynomial.polynomial_ring.PolynomialRing_dense_padic_field_lazy(base_ring, name=None, element_class=None)

__init__(base_ring, name=None, element_class=None)

TESTS:

sage: from sage.rings.polynomial.polynomial_ring import PolynomialRing_dense_padic_field_lazy as PRing
sage: R = PRing(Qp(13, type='lazy'), name='t')
...
NotImplementedError: lazy p-adics need more work.  Sorry.

#sage: type(R.gen())

class sage.rings.polynomial.polynomial_ring.PolynomialRing_dense_padic_ring_capped_absolute(base_ring, name=None, element_class=None)

__init__(base_ring, name=None, element_class=None)

TESTS:

sage: from sage.rings.polynomial.polynomial_ring import PolynomialRing_dense_padic_ring_capped_absolute as PRing
sage: R = PRing(Zp(13, type='capped-abs'), name='t'); R
Univariate Polynomial Ring in t over 13-adic Ring with capped absolute precision 20
sage: type(R.gen())
<class 'sage.rings.polynomial.padics.polynomial_padic_flat.Polynomial_padic_flat'>

class sage.rings.polynomial.polynomial_ring.PolynomialRing_dense_padic_ring_capped_relative(base_ring, name=None, element_class=None)

__init__(base_ring, name=None, element_class=None)

TESTS:

sage: from sage.rings.polynomial.polynomial_ring import PolynomialRing_dense_padic_ring_capped_relative as PRing
sage: R = PRing(Zp(13), name='t'); R
Univariate Polynomial Ring in t over 13-adic Ring with capped relative precision 20
sage: type(R.gen())
<class 'sage.rings.polynomial.padics.polynomial_padic_capped_relative_dense.Polynomial_padic_capped_relative_dense'>

class sage.rings.polynomial.polynomial_ring.PolynomialRing_dense_padic_ring_fixed_mod(base_ring, name=None, element_class=None)

__init__(base_ring, name=None, element_class=None)

TESTS:

sage: from sage.rings.polynomial.polynomial_ring import PolynomialRing_dense_padic_ring_fixed_mod as PRing
sage: R = PRing(Zp(13, type='fixed-mod'), name='t'); R
Univariate Polynomial Ring in t over 13-adic Ring of fixed modulus 13^20

sage: type(R.gen())
<class 'sage.rings.polynomial.padics.polynomial_padic_flat.Polynomial_padic_flat'>

class sage.rings.polynomial.polynomial_ring.PolynomialRing_dense_padic_ring_generic(base_ring, name='x', sparse=False, implementation=None, element_class=None)

class sage.rings.polynomial.polynomial_ring.PolynomialRing_dense_padic_ring_lazy(base_ring, name=None, element_class=None)

__init__(base_ring, name=None, element_class=None)

TESTS:

sage: from sage.rings.polynomial.polynomial_ring import PolynomialRing_dense_padic_ring_lazy as PRing
sage: R = PRing(Zp(13, type='lazy'), name='t')
...
NotImplementedError: lazy p-adics need more work.  Sorry.

#sage: type(R.gen())

class sage.rings.polynomial.polynomial_ring.PolynomialRing_field(base_ring, name='x', sparse=False, element_class=None)

__init__(base_ring, name='x', sparse=False, element_class=None)

TESTS:

sage: from sage.rings.polynomial.polynomial_ring import PolynomialRing_field as PRing sage: R = PRing(QQ, ‘x’); R Univariate Polynomial Ring in x over Rational Field sage: type(R.gen()) <class ‘sage.rings.polynomial.polynomial_element_generic.Polynomial_rational_dense’> sage: R = PRing(QQ, ‘x’, sparse=True); R Sparse Univariate Polynomial Ring in x over Rational Field sage: type(R.gen()) <class ‘sage.rings.polynomial.polynomial_element_generic.Polynomial_generic_sparse_field’> sage: R = PRing(CC, ‘x’); R Univariate Polynomial Ring in x over Complex Field with 53 bits of precision sage: type(R.gen()) <class ‘sage.rings.polynomial.polynomial_element_generic.Polynomial_generic_dense_field’>

divided_difference(points, full_table=False)

Return the Newton divided-difference coefficients of the -th Lagrange interpolation polynomial of points.

If points are distinct points , then is the -th Lagrange interpolation polynomial of that passes through the points . This method returns the coefficients such that

INPUT:

• points – a list of tuples where each for
• full_table – (default: False) if True then return the full divided-difference table; if False then only return entries along the main diagonal. The entries along the main diagonal are the Newton divided-difference coefficients .

OUTPUT:

• The Newton divided-difference coefficients of the -th Lagrange interpolation polynomial that passes through the points in points.

EXAMPLES:

Only return the divided-difference coefficients . This example is taken from Example 1, p.121 of [BF05]:

sage: points = [(1.0, 0.7651977), (1.3, 0.6200860), (1.6, 0.4554022), (1.9, 0.2818186), (2.2, 0.1103623)]
sage: R = PolynomialRing(QQ, "x")
sage: R.divided_difference(points)
<BLANKLINE>
[0.765197700000000,
-0.483705666666666,
-0.108733888888889,
0.0658783950617283,
0.00182510288066044]

Now return the full divided-difference table:

sage: points = [(1.0, 0.7651977), (1.3, 0.6200860), (1.6, 0.4554022), (1.9, 0.2818186), (2.2, 0.1103623)]
sage: R = PolynomialRing(QQ, "x")
sage: R.divided_difference(points, full_table=True)
<BLANKLINE>
[[0.765197700000000],
[0.620086000000000, -0.483705666666666],
[0.455402200000000, -0.548946000000000, -0.108733888888889],
[0.281818600000000,
-0.578612000000000,
-0.0494433333333339,
0.0658783950617283],
[0.110362300000000,
-0.571520999999999,
0.0118183333333349,
0.0680685185185209,
0.00182510288066044]]

The following example is taken from Example 4.12, p.225 of [MF99]:

sage: points = [(1, -3), (2, 0), (3, 15), (4, 48), (5, 105), (6, 192)]
sage: R = PolynomialRing(RR, "x")
sage: R.divided_difference(points)
[-3, 3, 6, 1, 0, 0]
sage: R.divided_difference(points, full_table=True)
<BLANKLINE>
[[-3],
[0, 3],
[15, 15, 6],
[48, 33, 9, 1],
[105, 57, 12, 1, 0],
[192, 87, 15, 1, 0, 0]]

REFERENCES:

[MF99]

J.H. Mathews and K.D. Fink. Numerical Methods Using MATLAB. 3rd edition, Prentice-Hall, 1999.

lagrange_polynomial(points, algorithm='divided_difference', previous_row=None)

Return the Lagrange interpolation polynomial in self associated to the given list of points.

Given a list of points, i.e. tuples of elements of self‘s base ring, this function returns the interpolation polynomial in the Lagrange form.

INPUT:

• points – a list of tuples representing points through which the polynomial returned by this function must pass.
• algorithm – (default: 'divided_difference') the available values for this option are 'divided_difference' and neville.
  • If algorithm='divided_difference' then use the method of divided difference.
  • If algorithm='neville' then adapt Neville’s method as described on page 144 of [BF05] to recursively generate the Lagrange interpolation polynomial. Neville’s method generates a table of approximating polynomials, where the last row of that table contains the -th Lagrange interpolation polynomial. The adaptation implemented by this method is to only generate the last row of this table, instead of the full table itself. Generating the full table can be memory inefficient.
• previous_row – (default: None) This option is only relevant if used together with algorithm='neville'. If provided, this should be the last row of the table resulting from a previous use of Neville’s method. If such a row is passed in, then points should consist of both previous and new interpolating points. Neville’s method will then use that last row and the interpolating points to generate a new row which contains a better Lagrange interpolation polynomial.

EXAMPLES:

By default, we use the method of divided-difference:

sage: R = PolynomialRing(QQ, 'x')
sage: f = R.lagrange_polynomial([(0,1),(2,2),(3,-2),(-4,9)]); f
-23/84*x^3 - 11/84*x^2 + 13/7*x + 1
sage: f(0)
1
sage: f(2)
2
sage: f(3)
-2
sage: f(-4)
9
sage: R = PolynomialRing(GF(2**3,'a'), 'x')
sage: a = R.base_ring().gen()
sage: f = R.lagrange_polynomial([(a^2+a,a),(a,1),(a^2,a^2+a+1)]); f
a^2*x^2 + a^2*x + a^2
sage: f(a^2+a)
a
sage: f(a)
1
sage: f(a^2)
a^2 + a + 1

Now use a memory efficient version of Neville’s method:

sage: R = PolynomialRing(QQ, 'x')
sage: R.lagrange_polynomial([(0,1),(2,2),(3,-2),(-4,9)], algorithm="neville")
<BLANKLINE>
[9,
-11/7*x + 19/7,
-17/42*x^2 - 83/42*x + 53/7,
-23/84*x^3 - 11/84*x^2 + 13/7*x + 1]
sage: R = PolynomialRing(GF(2**3,'a'), 'x')
sage: a = R.base_ring().gen()
sage: R.lagrange_polynomial([(a^2+a,a),(a,1),(a^2,a^2+a+1)], algorithm="neville")                                                                         
[a^2 + a + 1, x + a + 1, a^2*x^2 + a^2*x + a^2]

Repeated use of Neville’s method to get better Lagrange interpolation polynomials:

sage: R = PolynomialRing(QQ, 'x')
sage: p = R.lagrange_polynomial([(0,1),(2,2)], algorithm="neville")
sage: R.lagrange_polynomial([(0,1),(2,2),(3,-2),(-4,9)], algorithm="neville", previous_row=p)[-1]
-23/84*x^3 - 11/84*x^2 + 13/7*x + 1
sage: R = PolynomialRing(GF(2**3,'a'), 'x')
sage: a = R.base_ring().gen()
sage: p = R.lagrange_polynomial([(a^2+a,a),(a,1)], algorithm="neville")
sage: R.lagrange_polynomial([(a^2+a,a),(a,1),(a^2,a^2+a+1)], algorithm="neville", previous_row=p)[-1]
a^2*x^2 + a^2*x + a^2

TESTS:

The value for algorithm must be either 'divided_difference' (by default it is), or 'neville':

sage: R = PolynomialRing(QQ, "x")
sage: R.lagrange_polynomial([(0,1),(2,2),(3,-2),(-4,9)], algorithm="abc")
...
ValueError: algorithm must be one of 'divided_difference' or 'neville'
sage: R.lagrange_polynomial([(0,1),(2,2),(3,-2),(-4,9)], algorithm="divided difference")
...
ValueError: algorithm must be one of 'divided_difference' or 'neville'
sage: R.lagrange_polynomial([(0,1),(2,2),(3,-2),(-4,9)], algorithm="")
...
ValueError: algorithm must be one of 'divided_difference' or 'neville'

REFERENCES:

[BF05]

(1, 2) R.L. Burden and J.D. Faires. Numerical Analysis. Thomson Brooks/Cole, 8th edition, 2005.

class sage.rings.polynomial.polynomial_ring.PolynomialRing_general(base_ring, name=None, sparse=False, element_class=None)

Univariate polynomial ring over a ring.

__cmp__(left, right)

__init__(base_ring, name=None, sparse=False, element_class=None)

EXAMPLES:

sage: R.<x> = QQ['x']
sage: R(-1) + R(1)
0
sage: (x - 2/3)*(x^2 - 8*x + 16)
x^3 - 26/3*x^2 + 64/3*x - 32/3

__reduce__()

_coerce_map_from_(P)

The rings that canonically coerce to this polynomial ring are:

• this ring itself
• any ring that canonically coerces to the base ring of this ring.
• polynomial rings in the same variable over any base ring that canonically coerces to the base ring of this ring

EXAMPLES:

sage: R = QQ['x']
sage: R.has_coerce_map_from(QQ)
True
sage: R.has_coerce_map_from(ZZ)
True
sage: R.has_coerce_map_from(GF(7))
False
sage: R.has_coerce_map_from(ZZ['x'])
True
sage: R.has_coerce_map_from(ZZ['y'])
False

sage: R.coerce_map_from(ZZ)
Composite map:
  From: Integer Ring
  To:   Univariate Polynomial Ring in x over Rational Field
  Defn:   Natural morphism:
          From: Integer Ring
          To:   Rational Field
        then
          Polynomial base injection morphism:
          From: Rational Field
          To:   Univariate Polynomial Ring in x over Rational Field

_element_constructor_(x=None, check=True, is_gen=False, construct=False, **kwds)

Coerce x into this univariate polynomial ring, possibly non-canonically.

Stacked polynomial rings coerce into constants if possible. First, the univariate case:

sage: R.<x> = QQ[]
sage: S.<u> = R[]
sage: S(u + 2)
u + 2
sage: S(x + 3)
x + 3
sage: S(x + 3).degree()
0

Second, the multivariate case:

sage: R.<x,y> = QQ[]
sage: S.<u> = R[]
sage: S(x + 2*y)
x + 2*y
sage: S(x + 2*y).degree()
0
sage: S(u + 2*x)
u + 2*x
sage: S(u + 2*x).degree()
1

Foreign polynomial rings coerce into the highest ring; the point here is that an element of T could coerce to an element of R or an element of S; it is anticipated that an element of T is more likely to be “the right thing” and is historically consistent.

sage: R.<x> = QQ[]
sage: S.<u> = R[]
sage: T.<a> = QQ[]
sage: S(a)
u

Coercing in pari elements:

sage: QQ['x'](pari('[1,2,3/5]'))
3/5*x^2 + 2*x + 1
sage: QQ['x'](pari('(-1/3)*x^10 + (2/3)*x - 1/5'))
-1/3*x^10 + 2/3*x - 1/5

Coercing strings:

sage: QQ['y']('-y')
-y

TESTS: This shows that the issue at trac #4106 is fixed:

sage: x = var('x')
sage: R = IntegerModRing(4)
sage: S = PolynomialRing(R, x)
sage: S(x)
x

_gap_(G=None)

Used in converting this ring to the corresponding ring in GAP.

EXAMPLES:

sage: R.<z> = ZZ[]
sage: gap(R)
PolynomialRing( Integers, ["z"] )
sage: gap(z^2 + z)
z^2+z

_gap_init_()

_is_valid_homomorphism_(codomain, im_gens)

_latex_()

EXAMPLES:

sage: S.<alpha12>=ZZ[]
sage: latex(S)
\Bold{Z}[\alpha_{12}]

_macaulay2_(m2=None)

EXAMPLES:

sage: R = QQ['x']
sage: macaulay2(R) # optional - macaulay2
QQ [x]

_magma_init_(magma)

Used in converting this ring to the corresponding ring in MAGMA.

EXAMPLES:

sage: R = QQ['y']
sage: R._magma_init_(magma)                     # optional - magma
'SageCreateWithNames(PolynomialRing(_sage_ref...),["y"])'
sage: S = magma(R)                              # optional - magma
sage: print S                                   # optional - magma
Univariate Polynomial Ring in y over Rational Field
sage: S.1                                       # optional - magma
y
sage: magma(PolynomialRing(GF(7), 'x'))         # optional - magma
Univariate Polynomial Ring in x over GF(7)
sage: magma(PolynomialRing(GF(49,'a'), 'x'))    # optional - magma
Univariate Polynomial Ring in x over GF(7^2)
sage: magma(PolynomialRing(PolynomialRing(ZZ,'w'), 'x')) # optional - magma
Univariate Polynomial Ring in x over Univariate Polynomial Ring in w over Integer Ring

Watch out, Magma has different semantics from Sage, i.e., in Magma there is a unique univariate polynomial ring, and the variable name has no intrinsic meaning (it only impacts printing), so can’t be reliably set because of caching.

sage: m = Magma()            # new magma session; optional - magma
sage: m(QQ['w'])                                # optional - magma
Univariate Polynomial Ring in w over Rational Field
sage: m(QQ['x'])                                # optional - magma
Univariate Polynomial Ring in x over Rational Field
sage: m(QQ['w'])   # same magma object, now prints as x; optional - magma
Univariate Polynomial Ring in x over Rational Field

A nested example over a Givaro finite field:

sage: k.<a> = GF(9)
sage: R.<x> = k[]
sage: magma(a^2*x^3 + (a+1)*x + a)              # optional - magma    
a^2*x^3 + a^2*x + a

_monics_degree(of_degree)

Refer to monics() for full documentation.

_monics_max(max_degree)

Refer to monics() for full documentation.

_mpoly_base_ring(variables=None)

Returns the base ring if this is viewed as a polynomial ring over variables. See also Polynomial._mpoly_dict_recursive

_polys_degree(of_degree)

Refer to polynomials() for full documentation.

_polys_max(max_degree)

Refer to polynomials() for full documentation.

_repr_()

_sage_input_(sib, coerced)

Produce an expression which will reproduce this value when evaluated.

EXAMPLES:

sage: sage_input(GF(5)['x']['y'], verify=True)
# Verified
GF(5)['x']['y']
sage: from sage.misc.sage_input import SageInputBuilder
sage: ZZ['z']._sage_input_(SageInputBuilder(), False)
{constr_parent: {subscr: {atomic:ZZ}[{atomic:'z'}]} with gens: ('z',)}

base_extend(R)

Return the base extension of this polynomial ring to R.

EXAMPLES:

sage: R.<x> = RR[]; R
Univariate Polynomial Ring in x over Real Field with 53 bits of precision
sage: R.base_extend(CC)
Univariate Polynomial Ring in x over Complex Field with 53 bits of precision
sage: R.base_extend(QQ)
...
TypeError: no such base extension
sage: R.change_ring(QQ)
Univariate Polynomial Ring in x over Rational Field

change_ring(R)

Return the polynomial ring in the same variable as self over R.

EXAMPLES:

sage: R.<ZZZ> = RealIntervalField() []; R
Univariate Polynomial Ring in ZZZ over Real Interval Field with 53 bits of precision
sage: R.change_ring(GF(19^2,'b'))
Univariate Polynomial Ring in ZZZ over Finite Field in b of size 19^2

change_var(var)

Return the polynomial ring in variable var over the same base ring.

EXAMPLES:

sage: R.<x> = ZZ[]; R
Univariate Polynomial Ring in x over Integer Ring
sage: R.change_var('y')
Univariate Polynomial Ring in y over Integer Ring

characteristic()

Return the characteristic of this polynomial ring, which is the same as that of its base ring.

EXAMPLES:

sage: R.<ZZZ> = RealIntervalField() []; R
Univariate Polynomial Ring in ZZZ over Real Interval Field with 53 bits of precision
sage: R.characteristic()
0
sage: S = R.change_ring(GF(19^2,'b')); S
Univariate Polynomial Ring in ZZZ over Finite Field in b of size 19^2
sage: S.characteristic()
19

completion(p, prec=20, extras=None)

Return the completion of self with respect to the irreducible polynomial p. Currently only implemented for p=self.gen(), i.e. you can only complete R[x] with respect to x, the result being a ring of power series in x. The prec variable controls the precision used in the power series ring.

EXAMPLES:

sage: P.<x>=PolynomialRing(QQ)
sage: P
Univariate Polynomial Ring in x over Rational Field
sage: PP=P.completion(x)
sage: PP
Power Series Ring in x over Rational Field
sage: f=1-x
sage: PP(f)
1 - x
sage: 1/f
1/(-x + 1)
sage: 1/PP(f)
1 + 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 + O(x^20)

construction()

cyclotomic_polynomial(n)

Return the nth cyclotomic polynomial as a polynomial in this polynomial ring. For details of the implementation, see the documentation for sage.rings.polynomial.cyclotomic.cyclotomic_coeffs().

EXAMPLES:

sage: R = ZZ['x']
sage: R.cyclotomic_polynomial(8)
x^4 + 1
sage: R.cyclotomic_polynomial(12)
x^4 - x^2 + 1
sage: S = PolynomialRing(FiniteField(7), 'x')
sage: S.cyclotomic_polynomial(12)
x^4 + 6*x^2 + 1
sage: S.cyclotomic_polynomial(1)
x + 6

TESTS:

Make sure it agrees with other systems for the trivial case:

sage: ZZ['x'].cyclotomic_polynomial(1)
x - 1
sage: gp('polcyclo(1)')
x - 1

extend_variables(added_names, order='degrevlex')

Returns a multivariate polynomial ring with the same base ring but with added_names as additional variables.

EXAMPLES:

sage: R.<x> = ZZ[]; R
Univariate Polynomial Ring in x over Integer Ring
sage: R.extend_variables('y, z')
Multivariate Polynomial Ring in x, y, z over Integer Ring
sage: R.extend_variables(('y', 'z'))
Multivariate Polynomial Ring in x, y, z over Integer Ring

gen(n=0)

Return the indeterminate generator of this polynomial ring.

EXAMPLES:

sage: R.<abc> = Integers(8)[]; R
Univariate Polynomial Ring in abc over Ring of integers modulo 8
sage: t = R.gen(); t
abc
sage: t.is_gen()
True

An identical generator is always returned.

sage: t is R.gen()
True

gens_dict()

Returns a dictionary whose keys are the variable names of this ring as strings and whose values are the corresponding generators.

EXAMPLES:

sage: R.<x> = RR[]
sage: R.gens_dict()
{'x': 1.00000000000000*x}

is_exact()

is_field()

Return False, since polynomial rings are never fields.

EXAMPLES:

sage: R.<z> = Integers(2)[]; R
Univariate Polynomial Ring in z over Ring of integers modulo 2 (using NTL)
sage: R.is_field()
False

is_finite()

Return False since polynomial rings are not finite (unless the base ring is 0.)

EXAMPLES:

sage: R = Integers(1)['x']
sage: R.is_finite()
True
sage: R = GF(7)['x']
sage: R.is_finite()
False
sage: R['x']['y'].is_finite()
False

is_integral_domain()

EXAMPLES:

sage: ZZ['x'].is_integral_domain()
True
sage: Integers(8)['x'].is_integral_domain()
False

is_noetherian()

is_sparse()

Return true if elements of this polynomial ring have a sparse representation.

EXAMPLES:

sage: R.<z> = Integers(8)[]; R
Univariate Polynomial Ring in z over Ring of integers modulo 8
sage: R.is_sparse()
False
sage: R.<W> = PolynomialRing(QQ, sparse=True); R
Sparse Univariate Polynomial Ring in W over Rational Field
sage: R.is_sparse()
True

krull_dimension()

Return the Krull dimension of this polynomial ring, which is one more than the Krull dimension of the base ring.

EXAMPLES:

sage: R.<x> = QQ[]
sage: R.krull_dimension()
1
sage: R.<z> = GF(9,'a')[]; R
Univariate Polynomial Ring in z over Finite Field in a of size 3^2
sage: R.krull_dimension()
1
sage: S.<t> = R[]
sage: S.krull_dimension()
2
sage: for n in range(10):
...    S = PolynomialRing(S,'w')
sage: S.krull_dimension()
12

monics(of_degree=None, max_degree=None)

Return an iterator over the monic polynomials of specified degree.

INPUT: Pass exactly one of:

• max_degree - an int; the iterator will generate all monic polynomials which have degree less than or equal to max_degree
• of_degree - an int; the iterator will generate all monic polynomials which have degree of_degree

OUTPUT: an iterator

EXAMPLES:

sage: P = PolynomialRing(GF(4,'a'),'y')
sage: for p in P.monics( of_degree = 2 ): print p
y^2
y^2 + a
y^2 + a + 1
y^2 + 1
y^2 + a*y
y^2 + a*y + a
y^2 + a*y + a + 1
y^2 + a*y + 1
y^2 + (a + 1)*y
y^2 + (a + 1)*y + a
y^2 + (a + 1)*y + a + 1
y^2 + (a + 1)*y + 1
y^2 + y
y^2 + y + a
y^2 + y + a + 1
y^2 + y + 1
sage: for p in P.monics( max_degree = 1 ): print p
1
y
y + a
y + a + 1
y + 1
sage: for p in P.monics( max_degree = 1, of_degree = 3 ): print p
...
ValueError: you should pass exactly one of of_degree and max_degree

AUTHORS:

• Joel B. Mohler

ngens()

Return the number of generators of this polynomial ring, which is 1 since it is a univariate polynomial ring.

EXAMPLES:

sage: R.<z> = Integers(8)[]; R
Univariate Polynomial Ring in z over Ring of integers modulo 8
sage: R.ngens()
1

parameter()

Return the generator of this polynomial ring.

This is the same as self.gen().

polynomials(of_degree=None, max_degree=None)

Return an iterator over the polynomials of specified degree.

INPUT: Pass exactly one of:

• max_degree - an int; the iterator will generate all polynomials which have degree less than or equal to max_degree
• of_degree - an int; the iterator will generate all polynomials which have degree of_degree

OUTPUT: an iterator

EXAMPLES:

sage: P = PolynomialRing(GF(3),'y')
sage: for p in P.polynomials( of_degree = 2 ): print p
y^2
y^2 + 1
y^2 + 2
y^2 + y
y^2 + y + 1
y^2 + y + 2
y^2 + 2*y
y^2 + 2*y + 1
y^2 + 2*y + 2
2*y^2
2*y^2 + 1
2*y^2 + 2
2*y^2 + y
2*y^2 + y + 1
2*y^2 + y + 2
2*y^2 + 2*y
2*y^2 + 2*y + 1
2*y^2 + 2*y + 2
sage: for p in P.polynomials( max_degree = 1 ): print p
0
1
2
y
y + 1
y + 2
2*y
2*y + 1
2*y + 2
sage: for p in P.polynomials( max_degree = 1, of_degree = 3 ): print p
...
ValueError: you should pass exactly one of of_degree and max_degree

AUTHORS:

• Joel B. Mohler

random_element(degree=2, *args, **kwds)

Return a random polynomial.

INPUT:

• degree - an integer
• *args, **kwds - passed on to the random_element method for the base ring.

OUTPUT:

• Polynomial - A polynomial such that the coefficient of , for up to degree, are coercions to the base ring of random integers between -bound and bound.

EXAMPLES:

sage: R.<x> = ZZ[]
sage: R.random_element(10, 5,10)
9*x^10 + 8*x^9 + 6*x^8 + 8*x^7 + 8*x^6 + 9*x^5 + 8*x^4 + 8*x^3 + 6*x^2 + 8*x + 8
sage: R.random_element(6)
x^6 - 3*x^5 - x^4 + x^3 - x^2 + x + 1
sage: R.random_element(6)
-2*x^5 + 2*x^4 - 3*x^3 + 1
sage: R.random_element(6)
x^4 - x^3 + x - 2

variable_names_recursive(depth=+Infinity)

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

EXAMPLES:

sage: R = QQ['x']['y']['z']
sage: R.variable_names_recursive()
('x', 'y', 'z')
sage: R.variable_names_recursive(2)
('y', 'z')

class sage.rings.polynomial.polynomial_ring.PolynomialRing_integral_domain(base_ring, name='x', sparse=False, implementation=None, element_class=None)

__init__(base_ring, name='x', sparse=False, implementation=None, element_class=None)

TESTS:

sage: from sage.rings.polynomial.polynomial_ring import PolynomialRing_integral_domain as PRing sage: R = PRing(ZZ, ‘x’); R Univariate Polynomial Ring in x over Integer Ring sage: type(R.gen()) <type ‘sage.rings.polynomial.polynomial_integer_dense_flint.Polynomial_integer_dense_flint’>

sage: R = PRing(ZZ, ‘x’, implementation=’NTL’); R Univariate Polynomial Ring in x over Integer Ring (using NTL) sage: type(R.gen()) <type ‘sage.rings.polynomial.polynomial_integer_dense_ntl.Polynomial_integer_dense_ntl’>

_repr_()

TESTS:

sage: from sage.rings.polynomial.polynomial_ring import PolynomialRing_integral_domain as PRing sage: R = PRing(ZZ, ‘x’, implementation=’NTL’); R Univariate Polynomial Ring in x over Integer Ring (using NTL)

sage.rings.polynomial.polynomial_ring.is_PolynomialRing(x)

Return True if x is a univariate polynomial ring (and not a sparse multivariate polynomial ring in one variable).

EXAMPLES:

sage: from sage.rings.polynomial.polynomial_ring import is_PolynomialRing
sage: from sage.rings.polynomial.multi_polynomial_ring import is_MPolynomialRing
sage: is_PolynomialRing(2)
False

This polynomial ring is not univariate.

sage: is_PolynomialRing(ZZ['x,y,z'])
False
sage: is_MPolynomialRing(ZZ['x,y,z']) 
True

sage: is_PolynomialRing(ZZ['w']) 
True

Univariate means not only in one variable, but is a specific data type. There is a multivariate (sparse) polynomial ring data type, which supports a single variable as a special case.

sage: is_PolynomialRing(PolynomialRing(ZZ,1,'w'))
False
sage: R = PolynomialRing(ZZ,1,'w'); R
Multivariate Polynomial Ring in w over Integer Ring
sage: is_PolynomialRing(R)
False    
sage: type(R)
<type 'sage.rings.polynomial.multi_polynomial_libsingular.MPolynomialRing_libsingular'>

sage.rings.polynomial.polynomial_ring.polygen(ring_or_element, name='x')

Return a polynomial indeterminate.

INPUT:

• polygen(base_ring, name=”x”)
• polygen(ring_element, name=”x”)

If the first input is a ring, return a polynomial generator over that ring. If it is a ring element, return a polynomial generator over the parent of the element.

EXAMPLES:

sage: z = polygen(QQ,'z')
sage: z^3 + z +1
z^3 + z + 1
sage: parent(z)
Univariate Polynomial Ring in z over Rational Field

Note

If you give a list or comma separated string to polygen, you’ll get a tuple of indeterminates, exactly as if you called polygens.

sage.rings.polynomial.polynomial_ring.polygens(base_ring, names='x')

Return indeterminates over the given base ring with the given names.

EXAMPLES:

sage: x,y,z = polygens(QQ,'x,y,z')
sage: (x+y+z)^2
x^2 + 2*x*y + y^2 + 2*x*z + 2*y*z + z^2
sage: parent(x)
Multivariate Polynomial Ring in x, y, z over Rational Field
sage: t = polygens(QQ,['x','yz','abc'])
sage: t
(x, yz, abc)