# Singular

#### 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 zero-dimensional 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 zero-dimensional 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 non-zero, 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 t-order of the kth entry should in principle be larger than the t-degree 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 zero-dimensional 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 not-zero 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^p-tx-1
+ 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) 1997-2015 ==> 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+(3a-4)/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(x12-t11,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; ```