GitHub

Tropical hypersurfaces

Introduction

A tropical hypersurface is a balanced polyhedral complex of codimension one. It is dual to a regular subdivision of a Newton polytope. For more on tropical hypersurfaces, see

Note:

  • Objects of type TropicalHypersurface need to be embedded, abstract tropical hypersurfaces are currently not supported.
  • The type TropicalHypersurface can be thought of as subtype of TropicalVariety in the sense that it should have all properties and features of the latter.

Constructors

In addition to converting from TropicalVariety, objects of type TropicalHypersurface can be constructed from:

  • polynomials over a tropical semiring,
  • polynomials over a field and a tropical semiring map,
  • subdivision of points and a choice of min- or max-convention.
tropical_hypersurface — Function
tropical_hypersurface(f::MPolyRingElem{<:TropicalSemiringElem}, weighted_polyhedral_complex_only::Bool=false)

Return the tropical hypersurface of the tropical polynomial f. If weighted_polyhedral_complex==true, will not cache any extra information.

Examples

julia> T = tropical_semiring()
Min tropical semiring

julia> R,(x,y) = T[:x, :y];

julia> f = x+y+1
x + y + (1)

julia> tropical_hypersurface(f)
Min tropical hypersurface
source
tropical_hypersurface(f::MPolyRingElem, val::TropicalSemiringMap; weighted_polyhedral_complex_only::Bool=false)

Return the tropical hypersurface of the tropical polynomial that is the image of f under coefficient-wise val. If weighted_polyhedral_complex==true, will not cache any extra information.

Examples

julia> R,(x,y) = QQ[:x, :y];

julia> val = tropical_semiring_map(QQ,2)
Map into Min tropical semiring encoding the 2-adic valuation on Rational field

julia> f = x+y+2
x + y + 2

julia> tropical_hypersurface(f,val)
Min tropical hypersurface
source
tropical_hypersurface(Delta::SubdivisionOfPoints, minOrMax::Union{typeof(min),typeof(max)}=min; weighted_polyhedral_complex_only::Bool=false)

Construct the tropical hypersurface dual to a regular subdivision Delta in convention minOrMax. To be precise, the tropical hypersurface of the tropical polynomial with exponent vectors points(Delta) and coefficients min_weight(Delta) (min-convention) or -min_weight(Delta) (max-convention). If weighted_polyhedral_complex==true, will not cache any extra information.

Examples

julia> Delta = subdivision_of_points([0 0; 1 0; 0 1; 2 0],[0,0,0,1])
Subdivision of points in ambient dimension 2

julia> tropical_hypersurface(Delta)
Min tropical hypersurface
source

Properties

In addition to the properties inherited from TropicalVariety, objects of type TropicalHypersurface have the following exclusive properties:

algebraic_polynomial — Method
algebraic_polynomial(TropH::TropicalHypersurface)

Return the polynomial over a valued field used to construct TropH. Raises an error if it is not cached.

source
tropical_polynomial — Method
tropical_polynomial(TropH::TropicalHypersurface)

Return the tropical polynomial used to construct TropH. Raises an error if it is not cached.

source
dual_subdivision — Method
dual_subdivision(TropH::TropicalHypersurface)

Return the dual subdivision used to construct TropH. Raises an error if it is not cached.

Examples

julia> Delta = subdivision_of_points([0 0; 1 0; 0 1; 2 0],[0,0,0,1])
Subdivision of points in ambient dimension 2

julia> th = tropical_hypersurface(Delta)
Min tropical hypersurface

julia> sop = dual_subdivision(th)
Subdivision of points in ambient dimension 2

julia> points(sop)
4-element SubObjectIterator{PointVector{QQFieldElem}}:
 [0, 0]
 [1, 0]
 [0, 1]
 [2, 0]

julia> maximal_cells(sop)
2-element SubObjectIterator{Vector{Int64}}:
 [1, 2, 3]
 [2, 3, 4]
source

Example

The following code sets up an example and prints the vertices and rays of the tropical hypersurface (in no particular order).

julia> T = tropical_semiring();

julia> Tx,(x1,x2) = polynomial_ring(T, 2);

julia> g = 1 + 2*x1^2 + 2*x2^2 + 1*x1*x2;

julia> TropH = tropical_hypersurface(g);

julia> vertRays = vertices_and_rays(TropH)
5-element SubObjectIterator{Union{PointVector{QQFieldElem}, RayVector{QQFieldElem}}}:
 [-1, -1]
 [1, 0]
 [0, 1]
 [-1//2, 1//2]
 [1//2, -1//2]

By broadcasting the typeof() command, we can see, which are vertices, and which are rays.

julia> typeof.(vertRays)
5-element Vector{DataType}:
 RayVector{QQFieldElem}
 RayVector{QQFieldElem}
 RayVector{QQFieldElem}
 PointVector{QQFieldElem}
 PointVector{QQFieldElem}

The maximal polyhedra of our tropical hypersurface is simply the edges (both bounded and unbounded). The command maximal_polyhedra() gives us a list of these edges (in no particular order).

julia> maxPol = maximal_polyhedra(TropH)
5-element SubObjectIterator{Polyhedron{QQFieldElem}}:
 Polyhedron in ambient dimension 2
 Polyhedron in ambient dimension 2
 Polyhedron in ambient dimension 2
 Polytope in ambient dimension 2
 Polyhedron in ambient dimension 2

The polyhedrons are the unbounded edges, and the polytopes are the bounded edges.

The incidence matrix of the maximal polyhedra is a list of the relations between the elements of vertices_and_rays(TropH). From these relations, we can draw the hypersurface. However, one should be careful, as there is no distinction between vertices and rays in the incidence matrix.

julia> IncidenceMatrix(maxPol)
5×5 IncidenceMatrix
[1, 4]
[1, 5]
[3, 4]
[4, 5]
[2, 5]

This is made clearer if we ask for the vertices of each of the maximal polyhedra (the bounded edges have a vertex at each end, while the unbounded only have one vertex).

julia> vertices.(maxPol)
5-element Vector{SubObjectIterator{PointVector{QQFieldElem}}}:
 [[-1//2, 1//2]]
 [[1//2, -1//2]]
 [[-1//2, 1//2]]
 [[-1//2, 1//2], [1//2, -1//2]]
 [[1//2, -1//2]]

Instead of being between two vertices, the unbounded edges are defined by a vertex and a ray. These rays can be seen in the following way.

julia> rays.(maxPol)
5-element Vector{SubObjectIterator{RayVector{QQFieldElem}}}:
 [[-1, -1]]
 [[-1, -1]]
 [[0, 1]]
 0-element SubObjectIterator{RayVector{QQFieldElem}}
 [[1, 0]]