

Contents of this page
jinvariant.lib is a
SINGULAR
library for computations needed in the
proof of the main results in
and in
which is the following:
If (Q,S) is a marked polygon with one interior point, then a
general polynomial f in K[x,y] with support S defines an
elliptic curve C on the toric surface X_{S}. If K has a
nonarchimedean valuation into the reals we can tropicalize C to get a
tropical curve Trop(C). If the Newton subdivision induced by
f is a triangulation, then Trop(C) will be a graph of genus
one and we show that the lattice length of the cycle of that graph
is the negative of the valuation of the jinvariant of C.
For the definitions and the details we refer to the above papers.
The library can be downloaded from
If you use the library in your scientific work and want to cite it, please do so as follows:
Eric Katz,
Hannah Markwig,
Thomas Markwig:
jinvariant.lib. A
SINGULAR
3.0 library for computations with
jinvariants in tropical geometry, 2007
If you encounter any problems using the library please send an email to
On this web page you will find some information on the procedures in
the library jinvariant.lib and the post script files produced by
them. Nearly no knowledge of
SINGULAR
is necessary in order to use
the procedures of the library.
The main results obtained by the procedures in this library are
contained in the post script files:
Each of the files contains an introduction which explains the
terminology and the result.
In order to use the library jinvariant.lib you need to have the
libraries tropical.lib and polymake.lib as well which can be obtained via
respectively via
This library contains a number of procedures which might be useful
when dealing with jinvariants for tropical curves, such as the
procedure tropicalJInvariant which actually computes the cycle
length of a tropical curve with cycle, or the procedure
drawTropicalCurve which draws a tropical curve given by
a polynomial over Q(t).
Even though this is a
SINGULAR
library, many of the hard computations involving
polytopes are done by calling two other programs, namely
Many procedures will not work unless polymake respectively
topcom are installed.
It is, however, not necessary to be familiar with the syntax of these programs
unless you want to compute more information about the polytopes in question
than Singular provides you by calling them internally.
Whenever one of these programs is used, we assume that there is a directory
/tmp which is accessible for the user to write and read data.
The output produced by polymake respectively
topcom can then be found in the directory /tmp and are
available for further computations.
Moreover, some procedures produce latex files and compile them to display post
script output. Again we assume the presence of /tmp, and we assume that the
programs latex, dvips and kghostview are present as well.
First we want to give some general advise for users not familiar with
SINGULAR
,
for more information see
SINGULAR
.
•

To start Singular, type the command Singular in a shell. You
must do this in the directory where
your copies of the libraries tropical.lib, polymake.lib and
jinvariant.lib reside. The program will start and give you some
information on the version and the authors. Moreover, it will produce a prompt waiting for
your commands.

•

To load the libraries type
LIB "jinvariant.lib";
at the prompt  this will automatically also load tropical.lib
and polymake.lib. Note, every command in Singular
ends with a semicolon.

•

Most of the procedures in the library need one or two strings as
input, some need no input at all, and some need integers.
It is thus not necessary
to know the concept of a ring in
SINGULAR
which usually is vital for all
computations with
SINGULAR
. To call a procedure which requires no
input, e.g. raysC, just type the name of the procedure
followed by the brackets () and the semicolon at the prompt, e.g.
raysC();
To call a procedure which takes two strings as input, e.g. fan,
type the name of the procedure followed by the input in brackets
followed by semicolon and note that a string has always starting and
ending quotes, e.g
fan("cubic","discriminant");
To call a procedure which takes integers as input, e.g. examplesC,
type the name of the procedure followed by the input in brackets
followed by semicolon, e.g
examplesC(5);

•

Every object in
SINGULAR
has its own type and this type has to be specified when defining the
object. In particular, the return value of a procedure has a type, and
if you want to store the return value then you have to assign the
result to a variable of the corresponding type, e.g
list FAN=fan("cubic","discriminant",1);
creates a variable of type list and assigns to it the output of
the procedure inequalititesC.
The types needed to work with this library are
list, which is an array of other objects, int defining
an integer, intvec defining a vector of integers, and
intmat defining an integer matrix.
Note that there are procedures which have no return value.

•

Example: 
>  LIB "jinvariant.lib"; 
>  list FAN=fan("cubic","discriminant"); 
>  print(FAN[1][1][1]); 

•

You can invoke the
SINGULAR
help on the library by the command
help jinvariant.lib;
This will give you a list of all procedures available in the library with
a very short description on what they are supposed to do. If you want information on
a particular procedure, e.g. on fan, type
help fan;
The help will be displayed in the shell window which you are running. Instead you can
open the library in a text editor and search for proc fan. There you
will find the same help string at the very beginning of the library. If you need help
on general
SINGULAR
commands or features (e.g. on intmat), just type
help intmat;
The help should then in general be displayed in a web browser. If this does not work for
some reason, then simply go the
SINGULAR
web page and look in the online manual.

The proof of the result mentioned above for all marked polygons
with exactly one interior point is reduced to the study of three
cases, namely cubics and curves of type 2x2 respectively
of type 4x2. These are given by either a cubic polynomial
f=u_{30}x^{3}+u_{21}x^{2}y+u_{12}xy^{2}+u_{03}y^{3}+u_{20}x^{2}+u_{11}xy+u_{02}y^{2}+u_{10}x+u_{01}y+u_{00},
or a type 2x2 polynomial
f=u_{22}x^{2}y^{2}+u_{21}x^{2}y+u_{12}xy^{2}+u_{20}x^{2}+u_{11}xy+u_{02}y^{2}+u_{10}x+u_{01}y+u_{00},
or a type 4x2 polynomial
f=u_{40}x^{4}+u_{30}x^{3}+u_{21}x^{2}y+u_{20}x^{2}+u_{11}xy+u_{02}y^{2}+u_{10}x+u_{01}y+u_{00},
where the coefficients u_{ij} are in a field K with
nonarchimedean valuation into the real numbers. Whenever we want to
compute examples we use as base field the quotient field Q(t) of the
polynomial ring Q[t] and consider it as a subfield of the field C{{t}} of
Puiseux series over the complex numbers. The field C{{t}} is in a
natural way equipped with a
valuation associating to a Puiseux series its order.
We extend the valuation on K by componentwise application to the torus
(K^{*})^{2} in which the elliptic curve
C given as the zero set of f lives, giving a map to
R^{2}. The topological closure of its image is by
Kapranov's Theorem the tropical curve Trop(C) defined the tropical
polynomial
Trop(f)=min{u_{30}+3x,u_{21}+2x+y,u_{12}+x+2y,u_{03}+3y,u_{20}+2x,u_{11}+x+y,u_{02}+2y,u_{10}+x,u_{01}+y,u_{00}},
respectively
Trop(f)=min{u_{22}+2x+2y,u_{21}+2x+y,u_{12}+x+2y,u_{20}+2x,u_{11}+x+y,u_{02}+2y,u_{10}+x,u_{01}+y,u_{00}},
respectively
Trop(f)=min{u_{40}+4x,u_{30}+3x,u_{21}+2x+y,u_{20}+2x,u_{11}+x+y,u_{02}+2y,u_{10}+x,u_{01}+y,u_{00}},
where by abuse of notation we denote her by u_{ij} the
valuations of the coefficients u_{ij}. This should not lead to
any confusion, and we will use this convention in the
procedures as well.
We are mainly studying the jinvariant of the elliptic curve defined
by f. It can be expressed as a quotient of two homogeneous polynomials
of degree 12 where the variables are just the coeffients of f, and
again we use just the notation u_{ij}. We
consider them ordered as follows:
u_{11},u_{30},u_{20},u_{10},u_{00},u_{21},u_{01},u_{12},u_{02},u_{03},
respectively
u_{11},u_{20},u_{10},u_{00},u_{21},u_{01},u_{22},u_{12},u_{02},
respectively
u_{11},u_{40},u_{30},u_{20},u_{10},u_{00},u_{21},u_{01},u_{02}.
The denominator of the jinvariant is for cubics and type 2x2 curves
the discriminant of f and for type 4x2 curves it is
u_{02}^{2} times the discriminant of f. This denominator
is the object with which most of the procedures are concerned,
computing its Newton polytope and its Gröbner fan, and studying
certain cones in the latter which correspond to tropical polynomials
whose tropical curve has a cycle.
Among other things we show that all these cones lie in a single cone
of the Gröbner fan of the numerator of the jinvariant.
We also compute on each of these cones the generic valuation of the
jinvariant and the cycle length of the tropical curve and compare
them. This is done by the procedure displayfan and the
resulting post script file is available via
respectively
respectively
Alternatively we can consider the secondary fan of the set S
of markings
which is a refinement of the Gröbner fan of the denominator, and
we have done so, since this lists for each cone of the Gröbner
fan of the denominator all corresponding triangulations.
We again compute on each of these cones the generic valuation of the
jinvariant and the cycle length of the tropical curve and compare
them. This is done by the procedure displayfan and the
resulting post script file is available via
respectively
respectively
Finally in the first of the above mentioned papers the rays of the secondary fan
associated to a plane cubic are classified, and we compute for each of
these rays the generalised cycle length as well as the generic
valuation of the jinvariant. This is done by the procedure raysC and the
resulting post script file is available via
displayFan  produces a post script file showing the information computed with 'fan' 
fan  computes the Groebner fan of the discriminant or the secondary fan 
polytope  computes Newton polytopes respectively secondary polytopes 
testInteriorInequalities  compares a cone for the numerator of the jinvariant
to another cone 
Detailed description of the main procedures of the library
Warning: 
The procedure requires the program
polymake
to be installed on your computer.
Moreover, it assumes that the directory /tmp exists and that
the programs latex, dvips and kghostview are
available.

Short: 
The procedure produces a post script file showing the information
computed with fan.

Long: 
In order to prove the above mentioned statement that for elliptic
curves over the Puiseux series the generic valuation of the
jinvariant coincides with the negative of the cycle length of the
tropical curve associated to that curve provided it has a cycle, we
work through all cones of the Gröbner fan of the discriminant of
the curve which correspond to tropical curves with cycle. We check the
statement on each cone. The post script file produced by this procedure compares
the two functions on each of the cones of interest and gives some
information for the remaining cones as well.

Usage: 
displayFan(polygon,type);

Assume: 
'polygon' is one of the following strings discribing the type of curve
to be considered:
"cubic"  :  describing a cubic 
"2x2"  :  describing a curve of type (2,2) 
"4x2"  :  describing a curve of type (4,2) 
'type' is one of the following strings:
"discriminant"  :  referring to the discriminant of the curve 
"secondary"  :  referring to the secondary fan of the curve 

Result: 
The procedure has no return value. However, it produces the files
/tmp/'filename'.tex and /tmp/'filename'.ps, and it
displays the latter using kghostview, where 'filename' is the
string 'polygon'_fan_of_'type' with 'polygon' and 'type' being the
input data.

Warning: 
The procedure requires the program
polymake
to be installed on your computer.
Moreover, it assumes that the directory /tmp exists.

Short: 
The input data refer either to the Gröbner fan of the
discriminant of an elliptic curve
defined by 'polygon' or the secondary fan of that polygon. The
procedure computes the fan in question.

Usage: 
fan(polygon,type);

Assume: 
'polygon' is one of the following strings discribing the type of curve
to be considered:
"cubic"  :  describing a cubic 
"2x2"  :  describing a curve of type (2,2) 
"4x2"  :  describing a curve of type (4,2) 
'type' is one of the following strings:
"discriminant"  :  referring to the discriminant of the curve 
"secondary"  :  referring to the secondary fan of the curve 

Result: 
The procedure returns a list, say L, whose first entry is again a list
such that
L[1][i][1]  =  integer matrix representing the inequalities of the ith
cone of the fan, where the rows correspond to
the coefficients ordered as follows as the output
of polygonDB called with input
'polygon' 
L[1][i][2]  =  a list which contains the inequalities represented by L[1][i][1]
as a list of strings 
L[1][i][3]  =  only present if an optional argument was given, then it is
an integer matrix whose rows are the extreme rays of the ith
cone on the fan 
The second entry L[2] is an integer matrix describing the linearity space
of the fan, i.e. its rows span a vector space which is contained in
each cone of the fan.

Warning: 
The procedure requires the program
polymake
to be installed on your computer, and if the input 'type' described
below is "secondary" then it needs the program
topcom as well. Moreover, depending on your computer the
computation might take more than a day in the latter case!

Short: 
The input data refer either to the Newton polytope of the
discriminant of an elliptic curve
defined by 'polygon', or the the Newton polytope of the numerator of
the jinvariant of that curve, or to the secondary polytope of that polygon. The
procedure computes the polytope in question.

Usage: 
polytope(polygon,type);

Assume: 
'polygon' is one of the following strings discribing the type of curve
to be considered:
"cubic"  :  describing a cubic 
"2x2"  :  describing a curve of type (2,2) 
"4x2"  :  describing a curve of type (4,2) 
'type' is one of the following strings:
"discriminant"  :  referring to the discriminant of the curve 
"numerator"  :  referring to the numerator of
the jinvariant of the curve 
"secondary"  :  referring to the secondary fan of the curve 

Result: 
The return value, say L, of the procedure is of type list with four
entries, namely:
L[1] 
is an integer matrix whose rows are the coordinates of vertices
of the polytope.

L[2] 
is the dimension of the polytope.

L[3] 
a list whose ith entry explains to which vertices the ith vertex
of the Newton polytope is connected.

L[4] 
an integer matrix which gives the linear system of equations describing
the affine hull of the polytope, i.e. the smallest affine space it.


Remark: 
polygonToCoordinates()[2] returns a list and the ith entry is the
variable to which the ith coordinate in the polytope refers  here 'polygon' is
the same as the input polygon in the procedure;
in particular, if u_1,...,u_n are the variables then multiply L[4] by the matrix
(1,u_1,...,u_n) and set the result to zero in order to get the mentioned linear
system of equations for the affine hull.

Warning: 
The procedure requires the program
polymake
to be installed on your computer.

Short: 
The procedure checks if the cone U (the union of all cones of the
secondary fan corresponding to marked subdivisions for which the
interior point is visible) is completely contained in the one particular cone, say C,
of the Gröbner fan of the numerator of the jinvariant of the
curve specified by the input.

Usage: 
testInteriorInequalities(polygon);

Assume: 
'polygon' is one of the following strings discribing the type of curve
to be considered:
"cubic"  :  describing a cubic 
"2x2"  :  describing a curve of type (2,2) 
"4x2"  :  describing a curve of type (4,2) 

Result: 
The return value of the procedure is of type list with three
integer matricies as entries.
The first integer matrix represents the inequalities of C,
the second matrix contains the extreme rays of D,
and the third integer matrix is their product.

Remark: 
The fact that the third matrix contains only nonnegative entries shows that D is contained in C.

nonRefinementC()  shows that the secondary fan is no refinement for the numerator of the jinvariant 
raysC()  compares cycle length and generic jinvariant on rays 
examplesC(int)  computes examples of elliptic cubics 
Warning: 
The procedure requires the program
polymake
to be installed on your computer.

Long: 
The procedure intersects the cone of the Groebner fan of the numerator of the
jinvariant of a cubic which is dual to the vertex 12u_11 in the Newton polytope
with the cone number 851 in the secondary fan of the cubic; it computes the dimension
of the cone and its extreme rays; it then computes the same information just for
the cone numer 851 in the secondary fan; it turns out that both cones have the same
dimension but the extreme rays do not coincide (i.e. they intersect in a
full dimensional cone which is strictly contained in the cone number 851 of
the secondary fan); in particular, this proves that the secondary fan is not a refinement of the
Gröbner fan of the numerator of the jinvariant of a cubic.

Usage: 
The procedure is called without any argument, just type
nonRefinementC(); at the prompt.

Result: 
The procedure returns a list of three integer matrices and two integers. The rows of
the first matrix are the extreme rays of the intersection of the above
mentioned cones, and the rows of the second matrix are the extreme
rays of the cone 851 in the secondary fan. The two integers are the
dimensions of these two cones.
The fact that the extreme rays do not conincide while the dimensions do, shows
that the intersection is full dimensional but not the equal to the
cone in the secondary fan.

Warning: 
The procedure requires the program
polymake
to be installed on your computer.
Moreover, it assumes that the directory /tmp exists and that
the programs latex, dvips and kghostview are
available.

Short: 
The procedure produces the post script file raysC.ps.

Usage: 
The procedure is called without any argument, just type
raysC(); at the prompt.

Result: 
The procedure has no return value. However, it produces the files
/tmp/raysC.tex and /tmp/raysC.ps, and it
displays the latter using kghostview.

Remark: 
In the above mentioned paper among others the rays of the secondary
fan associated to a cubic have been classified up to symmetry. For
each such class of rays we have chosen one special representative and
we compute the generalised cycle length and the generic valuation of
its jinvariant.

Short: 
The procedure computes n random examples of plane cubic curves over the
Puiseux series and it computes the valuation of the jinvariant as
well as the cycle length of the corresponding tropical curve.

Usage: 
The procedure is called with one integer n as only argument, e.g.
examplesC(5);.

Result: 
The procedure has no return value.

Remark: 
For each example which it
computes it produces files /tmp/examplef'number'.tex,
/tmp/examplewf'number'.tex and
/tmp/exampleswf'number'.tex, which show the tropicalisation
of the example respectively of its Weierstrass form respectively of
its reduced Weierstrass form. Moreover, it produces the file
/tmp/examplesC.txt which contains the information on the cycle
length and the valuation of the jinvariant for each of the examples
as well as their equations.

examples2x2(int)
 computes examples of elliptic curves of type (2,2) on
P^{1}xP^{1} 
Short: 
The procedure computes n random examples of elliptic curves of type (2,2) over the
Puiseux series and it computes the valuation of the jinvariant as
well as the cycle length of the corresponding tropical curve.

Usage: 
The procedure is called with one integer n as only argument, e.g.
examples2x2(5);.

Result: 
The procedure has no return value.

Remark: 
For each example which it
computes it produces files /tmp/example2x2f'number'.tex and
/tmp/example2x2wf'number'.tex, which show the tropicalisation
of the example respectively of its Weierstrass form. Moreover, it produces the file
/tmp/examples2x2.txt which contains the information on the cycle
length and the valuation of the jinvariant for each of the examples
as well as their equations.

Short: 
The procedure returns the lattice points of the polygon in question,
starting with the only interior point.

Usage: 
polygonDB(polygon);

Assume: 
'polygon' is one of the following strings discribing the type of curve
to be considered:
"cubic"  :  describing a cubic 
"2x2"  :  describing a curve of type (2,2) 
"4x2"  :  describing a curve of type (4,2) 

Result: 
The return value of the procedure is a list of integer vectors,
i.e. the lattice points of the polygon.

Short: 
The procedure reproduces the discriminant, the invariant c4
respecively the numerator of the jinvariant of the type of elliptic curve
specified by the input.

Usage: 
invariantsDB(polygon,invar);

Assume: 
'polygon' is one of the following strings discribing the type of curve
to be considered:
"cubic"  :  describing a cubic 
"2x2"  :  describing a curve of type (2,2) 
"4x2"  :  describing a curve of type (4,2) 
'invar' is one of the following strings:
"discriminant"  :  referring to the discriminant of the curve 
"c4"  :  referring to the invariant c4 of the
elliptic curve 
"numerator"  :  referring to the numerator of
the jinvariant of the curve, i.e. c4^3 

Result: 
The return value of the procedure is a string, representing the
invariant that was requested.

Remark: 
The invariant is a polynomial in the unknowns u_{ij}, with i,j integers, where
the u_{ij} can be thought of as coefficients of a defining affine equation.
The invariants are not computed here, they are just stored.
Note that j=c4^3/Delta=A/Delta is the jinvariant of the corresponding
elliptic curve.

Short: 
The procedure returns the affine hull of the Newton polytope of the
discriminant respectively the secondary polytope.

Usage: 
affineHullDB(polygon,type);

Assume: 
'polygon' is one of the following strings discribing the type of curve
to be considered:
"cubic"  :  describing a cubic 
"2x2"  :  describing a curve of type (2,2) 
"4x2"  :  describing a curve of type (4,2) 
'type' is one of the following strings:
"discriminant"  :  referring to the discriminant of the curve 
"secondary"  :  referring to the secondary fan of the curve 

Result: 
The return value of the procedure is an integer matrix representing
the affine hull of the polytope in question as a linear system of
inequalities where the first column is the inhomogeneity.

Short: 
The procedure returns the vertices of the Newton polytope of the
discriminant respectively the secondary polytope.

Usage: 
verticesDB(polygon,type);

Assume: 
'polygon' is one of the following strings discribing the type of curve
to be considered:
"cubic"  :  describing a cubic 
"2x2"  :  describing a curve of type (2,2) 
"4x2"  :  describing a curve of type (4,2) 
'type' is one of the following strings:
"discriminant"  :  referring to the discriminant of the curve 
"secondary"  :  referring to the secondary fan of the curve 

Result: 
The return value of the procedure is an integer matrix whose rows are
the vertices of the polytope in question.

Short: 
The procedure returns the vertex edge graph of the Newton polytope of the
discriminant respectively the secondary polytope.

Usage: 
vertexEdgeGraphDB(polygon,type);

Assume: 
'polygon' is one of the following strings discribing the type of curve
to be considered:
"cubic"  :  describing a cubic 
"2x2"  :  describing a curve of type (2,2) 
"4x2"  :  describing a curve of type (4,2) 
'type' is one of the following strings:
"discriminant"  :  referring to the discriminant of the curve 
"secondary"  :  referring to the secondary fan of the curve 

Result: 
The return value of the procedure is a list of integer vectors. The
ith integer vector records to which vertices the ith vertex of the
polytope in question is connected.

Short: 
The procedure returns the extreme rays of the nth cone in the
Gröbner fan of the discriminant respectively the secondary fan.

Usage: 
extremeRaysDB(n,polygon,type);

Assume: 
'n' is an integer.
'polygon' is one of the following strings discribing the type of curve
to be considered:
"cubic"  :  describing a cubic 
"2x2"  :  describing a curve of type (2,2) 
"4x2"  :  describing a curve of type (4,2) 
'type' is one of the following strings:
"discriminant"  :  referring to the discriminant of the curve 
"secondary"  :  referring to the secondary fan of the curve 

Result: 
The return value of the procedure is an integer matrix whose rows are
the extreme rays of the nth cone in the fan in question.

Short: 
The procedure returns a triangulation of the polygon described by
the input.

Usage: 
triangulationsDB(n,polygon,type);

Assume: 
'n' is an integer.
'polygon' is one of the following strings discribing the type of curve
to be considered:
"cubic"  :  describing a cubic 
"2x2"  :  describing a curve of type (2,2) 
"4x2"  :  describing a curve of type (4,2) 

Result: 
The return value of the procedure is a list of integer vectors
representing the nth triangulation of the polygon in question.

Short: 
The procedure returns the inequalities needed to see a certain edge in
a marked subdivision of the polygon in question.

Usage: 
edgeInequalitiesDB(polygon);

Assume: 
'polygon' is one of the following strings discribing the type of curve
to be considered:
"cubic"  :  describing a cubic 
"2x2"  :  describing a curve of type (2,2) 
"4x2"  :  describing a curve of type (4,2) 

Result: 
The return value of the procedure is a list whose first entry is a
list of integer matrices such that the ith matrix describes the inequalities which are
necessary for the presence of the ith inner edge in a subdivision of
the polygon. The second entry is a list where the ith entry consists
of the two end points of the ith inner edge.

Short: 
The procedure returns the inequalities needed to see the inner lattice
point in a marked subdivision of the polygon in question.

Usage: 
interiorInequalitiesDB(polygon);

Assume: 
'polygon' is one of the following strings discribing the type of curve
to be considered:
"cubic"  :  describing a cubic 
"2x2"  :  describing a curve of type (2,2) 
"4x2"  :  describing a curve of type (4,2) 

Result: 
The return value of the procedure is an integer matrix whose rows
represent the inequalities describing the cone such that the interior point
of the polygon is a vertex of some polygon in the corresponding
marked subdivision of the polygon.

