Newton Polygons¶

This module implements finite Newton polygons and infinite Newton polygons having a finite number of slopes (and hence a last infinite slope).

class sage.geometry.newton_polygon.NewtonPolygon_element(polyhedron, parent)[source]¶

Bases: Element

Class for infinite Newton polygons with last slope.

last_slope()[source]¶

Return the last (infinite) slope of this Newton polygon if it is infinite and +Infinity otherwise.

EXAMPLES:

Sage

sage: from sage.geometry.newton_polygon import NewtonPolygon
sage: NP1 = NewtonPolygon([ (0,0), (1,1), (2,8), (3,5) ], last_slope=3)
sage: NP1.last_slope()
3

sage: NP2 = NewtonPolygon([ (0,0), (1,1), (2,5) ])
sage: NP2.last_slope()
+Infinity

Python

>>> from sage.all import *
>>> from sage.geometry.newton_polygon import NewtonPolygon
>>> NP1 = NewtonPolygon([ (Integer(0),Integer(0)), (Integer(1),Integer(1)), (Integer(2),Integer(8)), (Integer(3),Integer(5)) ], last_slope=Integer(3))
>>> NP1.last_slope()
3

>>> NP2 = NewtonPolygon([ (Integer(0),Integer(0)), (Integer(1),Integer(1)), (Integer(2),Integer(5)) ])
>>> NP2.last_slope()
+Infinity

Sage Live

from sage.geometry.newton_polygon import NewtonPolygon
NP1 = NewtonPolygon([ (0,0), (1,1), (2,8), (3,5) ], last_slope=3)
NP1.last_slope()
NP2 = NewtonPolygon([ (0,0), (1,1), (2,5) ])
NP2.last_slope()

We check that the last slope of a sum (resp. a product) is the minimum of the last slopes of the summands (resp. the factors):

Sage

sage: (NP1 + NP2).last_slope()
3
sage: (NP1 * NP2).last_slope()
3

Python

>>> from sage.all import *
>>> (NP1 + NP2).last_slope()
3
>>> (NP1 * NP2).last_slope()
3

Sage Live

(NP1 + NP2).last_slope()
(NP1 * NP2).last_slope()

plot(**kwargs)[source]¶

Plot this Newton polygon.

Note

All usual rendering options (color, thickness, etc.) are available.

EXAMPLES:

Sage

sage: from sage.geometry.newton_polygon import NewtonPolygon
sage: NP = NewtonPolygon([ (0,0), (1,1), (2,6) ])
sage: polygon = NP.plot()                                                   # needs sage.plot

Python

>>> from sage.all import *
>>> from sage.geometry.newton_polygon import NewtonPolygon
>>> NP = NewtonPolygon([ (Integer(0),Integer(0)), (Integer(1),Integer(1)), (Integer(2),Integer(6)) ])
>>> polygon = NP.plot()                                                   # needs sage.plot

Sage Live

from sage.geometry.newton_polygon import NewtonPolygon
NP = NewtonPolygon([ (0,0), (1,1), (2,6) ])
polygon = NP.plot()                                                   # needs sage.plot

reverse(degree=None)[source]¶

Return the symmetric of self.

INPUT:

degree – integer (default: the top right abscissa of this Newton polygon)

OUTPUT:

The image this Newton polygon under the symmetry ‘(x,y) mapsto (degree-x, y)`.

EXAMPLES:

Sage

sage: from sage.geometry.newton_polygon import NewtonPolygon
sage: NP = NewtonPolygon([ (0,0), (1,1), (2,5) ])
sage: NP2 = NP.reverse(); NP2
Finite Newton polygon with 3 vertices: (0, 5), (1, 1), (2, 0)

Python

>>> from sage.all import *
>>> from sage.geometry.newton_polygon import NewtonPolygon
>>> NP = NewtonPolygon([ (Integer(0),Integer(0)), (Integer(1),Integer(1)), (Integer(2),Integer(5)) ])
>>> NP2 = NP.reverse(); NP2
Finite Newton polygon with 3 vertices: (0, 5), (1, 1), (2, 0)

Sage Live

from sage.geometry.newton_polygon import NewtonPolygon
NP = NewtonPolygon([ (0,0), (1,1), (2,5) ])
NP2 = NP.reverse(); NP2

We check that the slopes of the symmetric Newton polygon are the opposites of the slopes of the original Newton polygon:

Sage

sage: NP.slopes()
[1, 4]
sage: NP2.slopes()
[-4, -1]

Python

>>> from sage.all import *
>>> NP.slopes()
[1, 4]
>>> NP2.slopes()
[-4, -1]

Sage Live

NP.slopes()
NP2.slopes()

slopes(repetition=True)[source]¶

Return the slopes of this Newton polygon.

INPUT:

repetition – boolean (default: True)

OUTPUT:

The consecutive slopes (not including the last slope if the polygon is infinity) of this Newton polygon.

If repetition is True, each slope is repeated a number of times equal to its length. Otherwise, it appears only one time.

EXAMPLES:

Sage

sage: from sage.geometry.newton_polygon import NewtonPolygon
sage: NP = NewtonPolygon([ (0,0), (1,1), (3,6) ]); NP
Finite Newton polygon with 3 vertices: (0, 0), (1, 1), (3, 6)

sage: NP.slopes()
[1, 5/2, 5/2]

sage: NP.slopes(repetition=False)
[1, 5/2]

Python

>>> from sage.all import *
>>> from sage.geometry.newton_polygon import NewtonPolygon
>>> NP = NewtonPolygon([ (Integer(0),Integer(0)), (Integer(1),Integer(1)), (Integer(3),Integer(6)) ]); NP
Finite Newton polygon with 3 vertices: (0, 0), (1, 1), (3, 6)

>>> NP.slopes()
[1, 5/2, 5/2]

>>> NP.slopes(repetition=False)
[1, 5/2]

Sage Live

from sage.geometry.newton_polygon import NewtonPolygon
NP = NewtonPolygon([ (0,0), (1,1), (3,6) ]); NP
NP.slopes()
NP.slopes(repetition=False)

vertices(copy=True)[source]¶

Return the list of vertices of this Newton polygon.

INPUT:

copy – boolean (default: True)

OUTPUT: the list of vertices of this Newton polygon (or a copy of it if copy is set to True)

EXAMPLES:

Sage

sage: from sage.geometry.newton_polygon import NewtonPolygon
sage: NP = NewtonPolygon([ (0,0), (1,1), (2,5) ]); NP
Finite Newton polygon with 3 vertices: (0, 0), (1, 1), (2, 5)

sage: v = NP.vertices(); v
[(0, 0), (1, 1), (2, 5)]

Python

>>> from sage.all import *
>>> from sage.geometry.newton_polygon import NewtonPolygon
>>> NP = NewtonPolygon([ (Integer(0),Integer(0)), (Integer(1),Integer(1)), (Integer(2),Integer(5)) ]); NP
Finite Newton polygon with 3 vertices: (0, 0), (1, 1), (2, 5)

>>> v = NP.vertices(); v
[(0, 0), (1, 1), (2, 5)]

Sage Live

from sage.geometry.newton_polygon import NewtonPolygon
NP = NewtonPolygon([ (0,0), (1,1), (2,5) ]); NP
v = NP.vertices(); v

class sage.geometry.newton_polygon.ParentNewtonPolygon[source]¶

Bases: Parent, UniqueRepresentation

Construct a Newton polygon.

INPUT:

arg – list/tuple/iterable of vertices or of slopes. Currently, slopes must be rational numbers
sort_slopes – boolean (default: True); whether slopes must be first sorted
last_slope – rational or infinity (default: Infinity); the last slope of the Newton polygon

OUTPUT: the corresponding Newton polygon

Note

By convention, a Newton polygon always contains the point at infinity \((0, \infty)\). These polygons are attached to polynomials or series over discrete valuation rings (e.g. padics).

EXAMPLES:

We specify here a Newton polygon by its vertices:

Sage

sage: from sage.geometry.newton_polygon import NewtonPolygon
sage: NewtonPolygon([ (0,0), (1,1), (3,5) ])
Finite Newton polygon with 3 vertices: (0, 0), (1, 1), (3, 5)

Python

>>> from sage.all import *
>>> from sage.geometry.newton_polygon import NewtonPolygon
>>> NewtonPolygon([ (Integer(0),Integer(0)), (Integer(1),Integer(1)), (Integer(3),Integer(5)) ])
Finite Newton polygon with 3 vertices: (0, 0), (1, 1), (3, 5)

Sage Live

from sage.geometry.newton_polygon import NewtonPolygon
NewtonPolygon([ (0,0), (1,1), (3,5) ])

We note that the convex hull of the vertices is automatically computed:

Sage

sage: NewtonPolygon([ (0,0), (1,1), (2,8), (3,5) ])
Finite Newton polygon with 3 vertices: (0, 0), (1, 1), (3, 5)

Python

>>> from sage.all import *
>>> NewtonPolygon([ (Integer(0),Integer(0)), (Integer(1),Integer(1)), (Integer(2),Integer(8)), (Integer(3),Integer(5)) ])
Finite Newton polygon with 3 vertices: (0, 0), (1, 1), (3, 5)

Sage Live

NewtonPolygon([ (0,0), (1,1), (2,8), (3,5) ])

Note that the value +Infinity is allowed as the second coordinate of a vertex:

Sage

sage: NewtonPolygon([ (0,0), (1,Infinity), (2,8), (3,5) ])
Finite Newton polygon with 2 vertices: (0, 0), (3, 5)

Python

>>> from sage.all import *
>>> NewtonPolygon([ (Integer(0),Integer(0)), (Integer(1),Infinity), (Integer(2),Integer(8)), (Integer(3),Integer(5)) ])
Finite Newton polygon with 2 vertices: (0, 0), (3, 5)

Sage Live

NewtonPolygon([ (0,0), (1,Infinity), (2,8), (3,5) ])

If last_slope is set, the returned Newton polygon is infinite and ends with an infinite line having the specified slope:

Sage

sage: NewtonPolygon([ (0,0), (1,1), (2,8), (3,5) ], last_slope=3)
Infinite Newton polygon with 3 vertices: (0, 0), (1, 1), (3, 5) ending by an infinite line of slope 3

Python

>>> from sage.all import *
>>> NewtonPolygon([ (Integer(0),Integer(0)), (Integer(1),Integer(1)), (Integer(2),Integer(8)), (Integer(3),Integer(5)) ], last_slope=Integer(3))
Infinite Newton polygon with 3 vertices: (0, 0), (1, 1), (3, 5) ending by an infinite line of slope 3

Sage Live

NewtonPolygon([ (0,0), (1,1), (2,8), (3,5) ], last_slope=3)

Specifying a last slope may discard some vertices:

Sage

sage: NewtonPolygon([ (0,0), (1,1), (2,8), (3,5) ], last_slope=3/2)
Infinite Newton polygon with 2 vertices: (0, 0), (1, 1) ending by an infinite line of slope 3/2

Python

>>> from sage.all import *
>>> NewtonPolygon([ (Integer(0),Integer(0)), (Integer(1),Integer(1)), (Integer(2),Integer(8)), (Integer(3),Integer(5)) ], last_slope=Integer(3)/Integer(2))
Infinite Newton polygon with 2 vertices: (0, 0), (1, 1) ending by an infinite line of slope 3/2

Sage Live

NewtonPolygon([ (0,0), (1,1), (2,8), (3,5) ], last_slope=3/2)

Next, we define a Newton polygon by its slopes:

Sage

sage: NP = NewtonPolygon([0, 1/2, 1/2, 2/3, 2/3, 2/3, 1, 1])
sage: NP
Finite Newton polygon with 5 vertices: (0, 0), (1, 0), (3, 1), (6, 3), (8, 5)
sage: NP.slopes()
[0, 1/2, 1/2, 2/3, 2/3, 2/3, 1, 1]

Python

>>> from sage.all import *
>>> NP = NewtonPolygon([Integer(0), Integer(1)/Integer(2), Integer(1)/Integer(2), Integer(2)/Integer(3), Integer(2)/Integer(3), Integer(2)/Integer(3), Integer(1), Integer(1)])
>>> NP
Finite Newton polygon with 5 vertices: (0, 0), (1, 0), (3, 1), (6, 3), (8, 5)
>>> NP.slopes()
[0, 1/2, 1/2, 2/3, 2/3, 2/3, 1, 1]

Sage Live

NP = NewtonPolygon([0, 1/2, 1/2, 2/3, 2/3, 2/3, 1, 1])
NP
NP.slopes()

By default, slopes are automatically sorted:

Sage

sage: NP2 = NewtonPolygon([0, 1, 1/2, 2/3, 1/2, 2/3, 1, 2/3])
sage: NP2
Finite Newton polygon with 5 vertices: (0, 0), (1, 0), (3, 1), (6, 3), (8, 5)
sage: NP == NP2
True

Python

>>> from sage.all import *
>>> NP2 = NewtonPolygon([Integer(0), Integer(1), Integer(1)/Integer(2), Integer(2)/Integer(3), Integer(1)/Integer(2), Integer(2)/Integer(3), Integer(1), Integer(2)/Integer(3)])
>>> NP2
Finite Newton polygon with 5 vertices: (0, 0), (1, 0), (3, 1), (6, 3), (8, 5)
>>> NP == NP2
True

Sage Live

NP2 = NewtonPolygon([0, 1, 1/2, 2/3, 1/2, 2/3, 1, 2/3])
NP2
NP == NP2

except if the contrary is explicitly mentioned:

Sage

sage: NewtonPolygon([0, 1, 1/2, 2/3, 1/2, 2/3, 1, 2/3], sort_slopes=False)
Finite Newton polygon with 4 vertices: (0, 0), (1, 0), (6, 10/3), (8, 5)

Python

>>> from sage.all import *
>>> NewtonPolygon([Integer(0), Integer(1), Integer(1)/Integer(2), Integer(2)/Integer(3), Integer(1)/Integer(2), Integer(2)/Integer(3), Integer(1), Integer(2)/Integer(3)], sort_slopes=False)
Finite Newton polygon with 4 vertices: (0, 0), (1, 0), (6, 10/3), (8, 5)

Sage Live

NewtonPolygon([0, 1, 1/2, 2/3, 1/2, 2/3, 1, 2/3], sort_slopes=False)

Slopes greater that or equal last_slope (if specified) are discarded:

Sage

sage: NP = NewtonPolygon([0, 1/2, 1/2, 2/3, 2/3, 2/3, 1, 1], last_slope=2/3)
sage: NP
Infinite Newton polygon with 3 vertices: (0, 0), (1, 0), (3, 1) ending by an infinite line of slope 2/3
sage: NP.slopes()
[0, 1/2, 1/2]

Python

>>> from sage.all import *
>>> NP = NewtonPolygon([Integer(0), Integer(1)/Integer(2), Integer(1)/Integer(2), Integer(2)/Integer(3), Integer(2)/Integer(3), Integer(2)/Integer(3), Integer(1), Integer(1)], last_slope=Integer(2)/Integer(3))
>>> NP
Infinite Newton polygon with 3 vertices: (0, 0), (1, 0), (3, 1) ending by an infinite line of slope 2/3
>>> NP.slopes()
[0, 1/2, 1/2]

Sage Live

NP = NewtonPolygon([0, 1/2, 1/2, 2/3, 2/3, 2/3, 1, 1], last_slope=2/3)
NP
NP.slopes()

Be careful, do not confuse Newton polygons provided by this class with Newton polytopes. Compare:

Sage

sage: NP = NewtonPolygon([ (0,0), (1,45), (3,6) ]); NP
Finite Newton polygon with 2 vertices: (0, 0), (3, 6)

sage: x, y = polygen(QQ,'x, y')
sage: p = 1 + x*y**45 + x**3*y**6
sage: p.newton_polytope()
A 2-dimensional polyhedron in ZZ^2 defined as the convex hull of 3 vertices
sage: p.newton_polytope().vertices()
(A vertex at (0, 0), A vertex at (1, 45), A vertex at (3, 6))

Python

>>> from sage.all import *
>>> NP = NewtonPolygon([ (Integer(0),Integer(0)), (Integer(1),Integer(45)), (Integer(3),Integer(6)) ]); NP
Finite Newton polygon with 2 vertices: (0, 0), (3, 6)

>>> x, y = polygen(QQ,'x, y')
>>> p = Integer(1) + x*y**Integer(45) + x**Integer(3)*y**Integer(6)
>>> p.newton_polytope()
A 2-dimensional polyhedron in ZZ^2 defined as the convex hull of 3 vertices
>>> p.newton_polytope().vertices()
(A vertex at (0, 0), A vertex at (1, 45), A vertex at (3, 6))

Sage Live

NP = NewtonPolygon([ (0,0), (1,45), (3,6) ]); NP
x, y = polygen(QQ,'x, y')
p = 1 + x*y**45 + x**3*y**6
p.newton_polytope()
p.newton_polytope().vertices()

Element[source]¶: alias of NewtonPolygon_element