Singular

D.13.4.1 tropicalLifting

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

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;