
D.13.4.1 tropicalLifting
Procedure from library tropical.lib (see tropical_lib).
 Usage:
 tropicalLifting(i,w,ord[,opt]); i ideal, w intvec, ord int, opt string
 Assume:
  i is an ideal in Q[t,x_1,...,x_n], w=(w_0,w_1,...,w_n)
and (w_1/w_0,...,w_n/w_0) is in the tropical variety of i,
and ord is the order up to which a point in V(i) over Q{{t}}
lying over (w_1/w_0,...,w_n/w_0) shall be computed;
w_0 may NOT be ZERO
 the basering should not have any parameters on its own
and it should have a global monomial ordering,
e.g. ring r=0,(t,x(1..n)),dp;
 the first variable of the basering will be treated as the
parameter t in the Puiseux series field
 the optional parameter opt should be one or more strings among
the following:
'isZeroDimensional' : the dimension i is zero (not to be checked);
'isPrime' : the ideal is prime over Q(t)[x_1,...,x_n]
(not to be checked);
'isInTrop' : (w_1/w_0,...,w_n/w_0) is in the tropical
variety (not to be checked);
'oldGfan' : uses gfan version 0.2.1 or less
'findAll' : find all solutions of a zerodimensional
ideal over (w_1/w_0,...,w_n/w_0)
'noAbs' : do NOT use absolute primary decomposition
'puiseux' : n=1 and i is generated by one equation
'noResubst' : avoids the computation of the resubstitution
 Return:
 IF THE OPTION 'findAll' WAS NOT SET THEN:
list, containing one lifting of the given point (w_1/w_0,...,w_n/w_0)
in the tropical variety of i to a point in V(i) over Puiseux
series field up to the first ord terms; more precisely:
IF THE OPTION 'noAbs' WAS NOT SET, THEN:
l[1] = ring Q[a]/m[[t]]
l[2] = int
l[3] = intvec
l[4] = list
IF THE OPTION 'noAbs' WAS SET, THEN:
l[1] = ring Q[X(1),...,X(k)]/m[[t]]
l[2] = int
l[3] = intvec
l[4] = list
l[5] = string
IF THE OPITON 'findAll' WAS SET, THEN:
list, containing ALL liftings of the given point ((w_1/w_0,...,w_n/w_0)
in the tropical variety of i to a point in V(i) over Puiseux
series field up to the first ord terms, if the ideal is
zerodimensional over Q{{t}};
more precisely, each entry of the list is a list l as computed
if 'findAll' was NOT set
WE NOW DESCRIBE THE LIST ENTRIES IF 'findAll' WAS NOT SET:
 the ring l[1] contains an ideal LIFT, which contains
a point in V(i) lying over w up to the first ord terms;
 and if the integer l[2] is N then t has to be replaced by t^1/N
in the lift, or alternatively replace t by t^N in the defining ideal
 if the k+1st entry of l[3] is nonzero, then the kth component of
LIFT has to be multiplied t^(l[3][k]/l[3][1]) AFTER substituting t
by t^1/N
 unless the option 'noResubst' was set, the kth entry of list l[4]
is a string which represents the kth generator of
the ideal i where the coordinates have been replaced by the result
of the lift;
the torder of the kth entry should in principle be larger than the
tdegree of LIFT
 if the option 'noAbs' was set, then the string in l[5] defines
a maximal ideal in the field Q[X(1),...,X(k)], where X(1),...,X(k)
are the parameters of the ring in l[1];
the basefield of the ring in l[1] should be considered modulo this
ideal
 Remark:
  it is best to use the procedure displayTropicalLifting to
display the result
 the option 'findAll' cannot be used if 'noAbs' is set
 if the parameter 'findAll' is set AND the ideal i is zerodimensional
in Q{{t}}[x_1,...,x_n] then ALL points in V(i) lying over w are
computed up to order ord; if the ideal is notzero dimenisonal, then
only the points in the ideal after cutting down to dimension zero
will be computed
 the procedure requires that the program GFAN is installed on your
computer; if you have GFAN version less than 0.3.0 then you must
use the optional parameter 'oldGfan'
 the procedure requires the Singular procedure absPrimdecGTZ to be
present in the package primdec.lib, unless the option 'noAbs' is set;
but even if absPrimdecGTZ is present it might be necessary to set
the option 'noAbs' in order to avoid the costly absolute primary
decomposition; the side effect is that the field extension which is
computed throughout the recursion might need more than one
parameter to be described
 since Q is infinite, the procedure finishes with probability one
 you can call the procedure with Z/pZ as base field instead of Q,
but there are some problems you should be aware of:
+ the Puiseux series field over the algebraic closure of Z/pZ is
NOT algebraicall closed, and thus there may not exist a point in
V(i) over the Puiseux series field with the desired valuation;
so there is no chance that the procedure produced a sensible output
 e.g. if i=tx^ptx1
+ if the dimension of i over Z/pZ(t) is not zero the process of
reduction to zero might not work if the characteristic is small
and you are unlucky
+ the option 'noAbs' has to be used since absolute primary
decomposition in Singular only works in characteristic zero
 the basefield should either be Q or Z/pZ for some prime p;
field extensions will be computed if necessary; if you need
parameters or field extensions from the beginning they should
rather be simulated as variables possibly adding their relations to
the ideal; the weights for the additional variables should be zero
Example:
 LIB "tropical.lib";
==> Welcome to polymake version
==> Copyright (c) 19972015
==> Ewgenij Gawrilow, Michael Joswig (TU Darmstadt)
==> http://www.polymake.org
int oldprintlevel=printlevel;
printlevel=1;
////////////////////////////////////////////////////////
// 1st EXAMPLE:
////////////////////////////////////////////////////////
ring r=0,(t,x),dp;
ideal i=(1+t2)*x2+t5x+t2;
intvec w=1,1;
list LIST=tropicalLifting(i,w,4);
==> LP algorithm being used: "cddgmp".
==> Groebner basis Engine being used: "gfan".
==> 0
==> LP algorithm being used: "cddgmp".
==> Groebner basis Engine being used: "gfan".
==> 0
==> LP algorithm being used: "cddgmp".
==> Groebner basis Engine being used: "gfan".
==> 0
==> 0
==> 0
==> 0
==> 0
==> The procedure has created a list of lists. The jth entry of this list
==> contains a ring, an integer and an intvec.
==> In this ring lives an ideal representing the wanted lifting,
==> if the integer is N then in the parametrisation t has to be replaced by t\
^1/N,
==> and if the ith component of the intvec is w[i] then the ith component in \
LIFT
==> should be multiplied by t^w[i]/N in order to get the parametrisation.
==>
==> Suppose your list has the name L, then you can access the 1st ring via:
==>
==> def LIFTRing=L[1]; setring LIFTRing; LIFT;
==>
def LIFTRing=LIST[1];
setring LIFTRing;
// LIFT contains the first 4 terms of a point in the variety of i
// over the Puiseux series field C{{t}} whose order is w[1]/w[0]=1
LIFT;
==> LIFT[1]=(a)*t+(a)/2*t3+(3a4)/8*t5+(5a+8)/16*t7
// Since the computations were done over Q a field extension was necessary,
// and the parameter "a" satisfies the equation given by minpoly
minpoly;
==> 0
////////////////////////////////////////////////////////
// 2nd EXAMPLE
////////////////////////////////////////////////////////
setring r;
LIST=tropicalLifting(x12t11,intvec(12,11),2,"isPrime","isInTrop");
==> 0
==> The procedure has created a list of lists. The jth entry of this list
==> contains a ring, an integer and an intvec.
==> In this ring lives an ideal representing the wanted lifting,
==> if the integer is N then in the parametrisation t has to be replaced by t\
^1/N,
==> and if the ith component of the intvec is w[i] then the ith component in \
LIFT
==> should be multiplied by t^w[i]/N in order to get the parametrisation.
==>
==> Suppose your list has the name L, then you can access the 1st ring via:
==>
==> def LIFTRing=L[1]; setring LIFTRing; LIFT;
==>
def LIFTRing2=LIST[1];
setring LIFTRing2;
// This time, LIFT contains the lifting of the point w[1]/w[0]=11/12
// only after we replace in LIFT the variable t by t^1/N with N=LIST[3]
LIFT;
==> LIFT[1]=t11
LIST[3];
==> 12,0
///////////////////////////////////////////////////////
// 3rd EXAMPLE
////////////////////////////////////////////////////////
ring R=0,(t,x,y,z),dp;
ideal i=y2t4+x2,yt3+xz+y;
w=1,2,0,2;
LIST=tropicalLifting(i,w,3);
==> LP algorithm being used: "cddgmp".
==> Groebner basis Engine being used: "gfan".
==> 0
==> 0
==> 0
==> The procedure has created a list of lists. The jth entry of this list
==> contains a ring, an integer and an intvec.
==> In this ring lives an ideal representing the wanted lifting,
==> if the integer is N then in the parametrisation t has to be replaced by t\
^1/N,
==> and if the ith component of the intvec is w[i] then the ith component in \
LIFT
==> should be multiplied by t^w[i]/N in order to get the parametrisation.
==>
==> Suppose your list has the name L, then you can access the 1st ring via:
==>
==> def LIFTRing=L[1]; setring LIFTRing; LIFT;
==>
// This time, LIFT contains the lifting of the point v=(2,0,2)
// only after we multiply LIFT[3] by t^k with k=LIST[4][3];
// NOTE: since the last component of v is positive, the lifting
// must start with a negative power of t, which in Singular
// is not allowed for a variable.
def LIFTRing3=LIST[1];
setring LIFTRing3;
LIFT;
==> LIFT[1]=2t2
==> LIFT[2]=2
==> LIFT[3]=1+t3
LIST[4];
==> [1]:
==> 0
==> [2]:
==> 0
// An easier way to display this is via displayTropicalLifting.
setring R;
displayTropicalLifting(LIST,"subst");
==> The lifting of the point in the tropical variety lives in the ring
==> Q[[t]]
==>
==> The lifting has the form:
==> x=(2)*t^2
==> y=(2)
==> z=(1)*1/t^2 + (1)*t
==>
==> Substituting the solution into the ideal gives:
==> i[1]=0
==> i[2]=0
printlevel=oldprintlevel;

