Changeset ae9fd9 in git

Timestamp:

Jul 28, 2009, 12:26:27 PM (14 years ago)

Author:

Hans Schönemann <hannes@…>

Branches:

(u'spielwiese', '828514cf6e480e4bafc26df99217bf2a1ed1ef45')

Children:

3f4e526e3cc452dc07c10ec2049456a441cf11d8

Parents:

1c5fa50a543d43c7bb0c21bc2e1c9a5f9849e140

Message:

*hannes: format


git-svn-id: file:///usr/local/Singular/svn/trunk@12023 2c84dea3-7e68-4137-9b89-c4e89433aadc

Location:

Singular/LIB

Files:

• tropical.lib (modified) (327 diffs)
• zeroset.lib (modified) (2 diffs)

Singular/LIB/tropical.lib

@@ -1 @@
-version="$Id: tropical.lib,v 1.18 2009-07-09 12:20:30 keilen Exp $";
+version="$Id: tropical.lib,v 1.19 2009-07-28 10:26:27 Singular Exp $";
 category="Tropical Geometry";
 info="
@@ -8 +8 @@
 @*               Thomas Markwig,  email: keilen@mathematik.uni-kl.de
 
-WARNING: 
+WARNING:
 - tropicalLifting will only work with LINUX and if in addition gfan is installed.
-@*- drawTropicalCurve and drawTropicalNewtonSubdivision will only display the 
-@*  tropical curve with LINUX and if in addition latex and kghostview 
+@*- drawTropicalCurve and drawTropicalNewtonSubdivision will only display the
+@*  tropical curve with LINUX and if in addition latex and kghostview
 @*  are installed.
-@*- For tropicalLifting in the definition of the basering the parameter t 
+@*- For tropicalLifting in the definition of the basering the parameter t
 @*  from the Puiseux series field C{{t}} must be defined as a variable,
 @*  while for all other procedures it must be defined as a parameter.
 
 THEORY:
-  Fix some base field K and a bunch of lattice points v0,...,vm in the integer 
-  lattice Z^n, then this defines a toric variety as the closure of (K*)^n in 
-  the projective space P^m, where the torus is embedded via the map sending a 
+  Fix some base field K and a bunch of lattice points v0,...,vm in the integer
+  lattice Z^n, then this defines a toric variety as the closure of (K*)^n in
+  the projective space P^m, where the torus is embedded via the map sending a
   point x in (K*)^n to the point (x^v0,...,x^vm).
-  The generic hyperplane sections are just the images of the hypersurfaces 
+  The generic hyperplane sections are just the images of the hypersurfaces
   in (K*)^n defined by the polynomials f=a0*x^v0+...+am*x^vm=0. Some properties
-  of these hypersurfaces can be studied via tropicalisation. 
-
-  For this we suppose that K=C{{t}} is the field of Puiseux series over the 
+  of these hypersurfaces can be studied via tropicalisation.
+
+  For this we suppose that K=C{{t}} is the field of Puiseux series over the
   field of complex numbers (or any other field with a valuation into the real
-  numbers). One associates to the hypersurface given by f=a0*x^v0+...+am*x^vm 
+  numbers). One associates to the hypersurface given by f=a0*x^v0+...+am*x^vm
   the tropical hypersurface defined by the tropicalisation
-  trop(f)=min{val(a0)+<v0,x>,...,val(am)+<vm,x>}. 
+  trop(f)=min{val(a0)+<v0,x>,...,val(am)+<vm,x>}.
   Here, <v,x> denotes the standard scalar product of the integer vector v in Z^n
   with the vector x=(x1,...,xn) of variables, so that trop(f) is a piecewise
-  linear function on R^n. The corner locus of this function (i.e. the points 
-  at which the minimum is attained a least twice) is the tropical hypersurface 
-  defined by trop(f). 
-  The theorem of Newton-Kapranov states that this tropical hypersurface is 
-  the same as if one computes pointwise the valuation of the hypersurface 
-  given by f. The analogue holds true if one replaces one equation f by an 
-  ideal I. A constructive proof of the theorem is given by an adapted 
-  version of the Newton-Puiseux algorithm. The hard part is to find a point 
-  in the variety over C{{t}} which corresponds to a given point in the 
+  linear function on R^n. The corner locus of this function (i.e. the points
+  at which the minimum is attained a least twice) is the tropical hypersurface
+  defined by trop(f).
+  The theorem of Newton-Kapranov states that this tropical hypersurface is
+  the same as if one computes pointwise the valuation of the hypersurface
+  given by f. The analogue holds true if one replaces one equation f by an
+  ideal I. A constructive proof of the theorem is given by an adapted
+  version of the Newton-Puiseux algorithm. The hard part is to find a point
+  in the variety over C{{t}} which corresponds to a given point in the
   tropical variety.
 
-  It is the purpose of this library to provide basic means to deal with 
-  tropical varieties. Of course we cannot represent the field of Puiseux 
-  series over C in its full strength, however, in order to compute interesting 
-  examples it will be sufficient to replace the complex numbers C by the 
-  rational numbers Q and to replace Puiseux series in t by rational functions 
-  in t, i.e. we replace C{{t}} by Q(t), or sometimes even by Q[t]. 
+  It is the purpose of this library to provide basic means to deal with
+  tropical varieties. Of course we cannot represent the field of Puiseux
+  series over C in its full strength, however, in order to compute interesting
+  examples it will be sufficient to replace the complex numbers C by the
+  rational numbers Q and to replace Puiseux series in t by rational functions
+  in t, i.e. we replace C{{t}} by Q(t), or sometimes even by Q[t].
   Note, that this in particular forbids rational exponents for the t's.
 
   Moreover, in @sc{Singular} no negative exponents of monomials are allowed, so
-  that the integer vectors vi will have to have non-negative entries. 
-  Shifting all exponents by a fixed integer vector does not change the 
-  tropicalisation nor does it change the toric variety. Thus this does not 
+  that the integer vectors vi will have to have non-negative entries.
+  Shifting all exponents by a fixed integer vector does not change the
+  tropicalisation nor does it change the toric variety. Thus this does not
   cause any restriction.
-  If, however, for some reason you prefer to work with general vi, then you 
-  have to pass right away to the tropicalisation of the equations, whereever 
+  If, however, for some reason you prefer to work with general vi, then you
+  have to pass right away to the tropicalisation of the equations, whereever
   this is allowed -- these are linear polynomials where the constant coefficient
-  corresponds to the valuation of the original coefficient and where 
-  the non-constant coefficient correspond to the exponents of the monomials, 
-  thus they may be rational numbers respectively negative numbers: 
+  corresponds to the valuation of the original coefficient and where
+  the non-constant coefficient correspond to the exponents of the monomials,
+  thus they may be rational numbers respectively negative numbers:
   e.g. if f=t^{1/2}*x^{-2}*y^3+2t*x*y+4  then  trop(f)=min{1/2-2x+3y,1+x+y,0}.
 
   The main tools provided in this library are as follows:
-@*  - tropicalLifting    implements the constructive proof of the Theorem of 
-                         Newton-Kapranov and constructs a point in the variety 
-                         over C{{t}} corresponding to a given point in the 
-                         corresponding tropical variety associated to an 
-                         ideal I; the generators of I have to be in the 
-                         polynomial ring Q[t,x1,...,xn] considered as a 
-                         subring of C{{t}}[x1,...,xn]; a solution will be 
-                         constructed up to given order; note that several 
+@*  - tropicalLifting    implements the constructive proof of the Theorem of
+                         Newton-Kapranov and constructs a point in the variety
+                         over C{{t}} corresponding to a given point in the
+                         corresponding tropical variety associated to an
+                         ideal I; the generators of I have to be in the
+                         polynomial ring Q[t,x1,...,xn] considered as a
+                         subring of C{{t}}[x1,...,xn]; a solution will be
+                         constructed up to given order; note that several
                          field extensions of Q might be necessary throughout
                          the intermediate computations; the procedures use
                          the external program gfan
-@*  - drawTropicalCurve  visualises a tropical plane curve either given by a 
-                         polynomial in Q(t)[x,y] or by a list of linear 
-                         polynomials of the form ax+by+c with a,b in Z and c 
+@*  - drawTropicalCurve  visualises a tropical plane curve either given by a
+                         polynomial in Q(t)[x,y] or by a list of linear
+                         polynomials of the form ax+by+c with a,b in Z and c
                          in Q; latex must be installed on your computer
-@*  - tropicalJInvariant computes the tropical j-invaiant of a tropical 
+@*  - tropicalJInvariant computes the tropical j-invaiant of a tropical
                          elliptic curve
 @*  - jInvariant         computes the j-invariant of an elliptic curve
-@*  - weierstrassForm     computes the Weierstrass form of an elliptic curve 
+@*  - weierstrassForm     computes the Weierstrass form of an elliptic curve
 
 PROCEDURES FOR TROPICAL LIFTING:
-  tropicalLifting()          computes a point in the tropical variety 
+  tropicalLifting()          computes a point in the tropical variety
   displayTropicalLifting()   displays the output of tropicalLifting
 
@@ -107 +107 @@
   tInitialIdeal()      computes the tInitial ideal of an ideal in Q[t,x_1,...,x_n]
   initialForm()        computes the initial form of poly in Q[x_1,...,x_n]
-  initialIdeal()       computes the initial ideal of an ideal in Q[x_1,...,x_n] 
+  initialIdeal()       computes the initial ideal of an ideal in Q[x_1,...,x_n]
 
 PROCEDURES FOR LATEX CONVERSION:
@@ -115 +115 @@
   texDrawBasic()       embeds output of texDrawTropical in a texdraw environment
   texDrawTropical()    computes the texdraw commands for a tropical curve
-  texDrawNewtonSubdivision()   computes texdraw commands for a Newton subdivision 
+  texDrawNewtonSubdivision()   computes texdraw commands for a Newton subdivision
   texDrawTriangulation()       computes texdraw commands for a triangulation
 
@@ -121 +121 @@
   radicalMemberShip()     checks radical membership
   tInitialFormPar()       computes the t-initial form of poly in Q(t)[x_1,...,x_n]
-  tInitialFormParMax()    same as tInitialFormPar, but uses maximum 
+  tInitialFormParMax()    same as tInitialFormPar, but uses maximum
   solveTInitialFormPar()  displays approximated solution of a 0-dim ideal
   detropicalise()         computes the detropicalisation of a linear form
-  dualConic()             computes the dual of an affine plane conic 
+  dualConic()             computes the dual of an affine plane conic
   parameterSubstitute()   substitutes in the polynomial the parameter t by t^N
   tropicalSubst()         makes certain substitutions in a tropical polynomial
@@ -155 +155 @@
 /// - eliminatecomponents
 /// - findzerosAndBasictransform
-/// - ordermaximalideals 
+/// - ordermaximalideals
 /// - verticesTropicalCurve
 /// - bunchOfLines
@@ -204 +204 @@
 
 ///////////////////////////////////////////////////////////////////////////////
-/// Procedures concerned with tropical parametrisation 
+/// Procedures concerned with tropical parametrisation
 ///////////////////////////////////////////////////////////////////////////////
 
 proc tropicalLifting (ideal i,intvec w,int ordnung,list #)
 "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; 
+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, 
+@*       - 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 
+@*       - 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 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]  
+@*         '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 
+@*         '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 
+@*         '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
@@ -233 +233 @@
 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 
+               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:
@@ -248 +248 @@
 @*       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 
+               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 
+               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 
+@*       - 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 
+@*       - 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 
+@*       - 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] 
+@*       - 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 
+           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 
+           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) 
+@*       - 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 
+           the basefield of the ring in l[1] should be considered modulo this
            ideal
-REMARK:  - it is best to use the procedure displayTropicalLifting to 
+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 
+           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 
+           computer; if you have GFAN version less than 0.3.0 then you must
            use the optional parameter 'oldGfan'
 @*       - the procedure requires the @sc{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 
+           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, 
+@*       - 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; 
+@*         + 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 
+             - 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 
+@*         + the option 'noAbs' has to be used since absolute primary
              decomposition in @sc{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 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: example tropicalLifting;   shows an example"
@@ -357 +357 @@
       noabs=1;
     }
-    // this option is not documented -- it prevents the execution of gfan and 
-    // just asks for wneu to be inserted -- it can be used to check problems 
-    // with the precedure without calling gfan, if wneu is know from previous 
+    // this option is not documented -- it prevents the execution of gfan and
+    // just asks for wneu to be inserted -- it can be used to check problems
+    // with the precedure without calling gfan, if wneu is know from previous
     // computations
     if (#[j]=="noGfan")
@@ -370 +370 @@
     }
   }
-  // if the basering has characteristic not equal to zero, 
+  // if the basering has characteristic not equal to zero,
   // then absolute factorisation
   // is not available, and thus we need the option noAbs
@@ -384 +384 @@
   {
     Error("The first coordinate of your input w must be NON-ZERO, since it is a DENOMINATOR!");
-  } 
+  }
   // if w_0<0, then replace w by -w, so that the "denominator" w_0 is positive
   if (w[1]<0)
@@ -391 +391 @@
   }
   intvec prew=w; // stores w for later reference
-  // for our computations, w[1] represents the weight of t and this 
+  // for our computations, w[1] represents the weight of t and this
   // should be -w_0 !!!
   w[1]=-w[1];
@@ -401 +401 @@
     w[1]=-1;
   }
-  // if some entry of w is positive, we have to make a transformation, 
+  // if some entry of w is positive, we have to make a transformation,
   // which moves it to something non-positive
   for (j=2;j<=nvars(basering);j++)
@@ -427 +427 @@
   {
     variablen=variablen+var(j);
-  }    
+  }
   map GRUNDPHI=BASERING,t,variablen;
   ideal i=GRUNDPHI(i);
-  // compute the initial ideal of i and test if w is in the tropical 
-  // variety of i 
+  // compute the initial ideal of i and test if w is in the tropical
+  // variety of i
   // - the last entry 1 only means that t is the last variable in the ring
   ideal ini=tInitialIdeal(i,w,1);
   if (isintrop==0) // test if w is in trop(i) only if isInTrop has not been set
-  {    
+  {
     poly product=1;
     for (j=1;j<=nvars(basering)-1;j++)
@@ -453 +453 @@
     int dd=dim(i);
     setring GRUNDRING;
-    // if the dimension is not zero, we cut the ideal down to dimension zero 
+    // if the dimension is not zero, we cut the ideal down to dimension zero
     // and compute the
     // t-initial ideal of the new ideal at the same time
     if(dd!=0)
     {
-      // the procedurce cutdown computes a new ring, in which there lives a 
+      // the procedurce cutdown computes a new ring, in which there lives a
       // zero-dimensional
-      // ideal which has been computed by cutting down the input with 
+      // ideal which has been computed by cutting down the input with
       // generic linear forms
-      // of the type x_i1-p_1,...,x_id-p_d for some polynomials 
-      // p_1,...,p_d not depending 
-      // on the variables x_i1,...,x_id; that way we have reduced 
+      // of the type x_i1-p_1,...,x_id-p_d for some polynomials
+      // p_1,...,p_d not depending
+      // on the variables x_i1,...,x_id; that way we have reduced
       // the number of variables by dd !!!
-      // the new zero-dimensional ideal is called i, its t-initial 
+      // the new zero-dimensional ideal is called i, its t-initial
       // ideal (with respect to
-      // the new w=CUTDOWN[2]) is ini, and finally there is a list 
-      // repl in the ring 
+      // the new w=CUTDOWN[2]) is ini, and finally there is a list
+      // repl in the ring
       // which contains at the polynomial p_j at position i_j and
       //a zero otherwise;
@@ -492 +492 @@
   list liftrings; // will contain the final result
   // if the procedure is called without 'findAll' then it may happen, that no
-  // proper solution is found when dd>0; in that case we have 
+  // proper solution is found when dd>0; in that case we have
   // to start all over again;
   // this is controlled by the while-loop
@@ -508 +508 @@
     // compute the liftrings by resubstitution
     kk=1;  // counts the liftrings
-    int isgood;  // test in the non-zerodimensional case 
+    int isgood;  // test in the non-zerodimensional case
                  // if the result has the correct valuation
     for (jj=1;jj<=size(TP);jj++)
     {
-      // the list TP contains as a first entry the ring over which the 
-      // tropical parametrisation 
+      // the list TP contains as a first entry the ring over which the
+      // tropical parametrisation
       // of the (possibly cutdown ideal) i lives
       def LIFTRING=TP[jj][1];
-      // if the dimension of i originally was not zero, 
+      // if the dimension of i originally was not zero,
       // then we have to fill in the missing
       // parts of the parametrisation
       if (dd!=0)
       {
-        // we need a ring where the parameters X_1,...,X_k 
+        // we need a ring where the parameters X_1,...,X_k
         // from LIFTRING are present,
         // and where also the variables of CUTDOWNRING live
         execute("ring REPLACEMENTRING=("+charstr(LIFTRING)+"),("+varstr(CUTDOWNRING)+"),dp;");
-        list repl=imap(CUTDOWNRING,repl); // get the replacement rules 
+        list repl=imap(CUTDOWNRING,repl); // get the replacement rules
                                           // from CUTDOWNRING
-        ideal PARA=imap(LIFTRING,PARA);   // get the zero-dim. parametrisatio 
+        ideal PARA=imap(LIFTRING,PARA);   // get the zero-dim. parametrisatio
                                           // from LIFTRING
         // compute the lift of the solution of the original ideal i
@@ -533 +533 @@
         k=1;
         // the lift has as many components as GRUNDRING has variables!=t
-        for (j=1;j<=nvars(GRUNDRING)-1;j++) 
+        for (j=1;j<=nvars(GRUNDRING)-1;j++)
         {
           // if repl[j]=0, then the corresponding variable was not eliminated
-          if (repl[j]==0) 
+          if (repl[j]==0)
           {
-            LIFT[j]=PARA[k]; // thus the lift has been 
+            LIFT[j]=PARA[k]; // thus the lift has been
                              // computed by tropicalparametrise
             k++; // k checks how many entries of PARA have already been used
@@ -544 +544 @@
           else  // if repl[j]!=0, repl[j] contains replacement rule for the lift
           {
-            LIFT[j]=repl[j]; // we still have to replace the vars 
+            LIFT[j]=repl[j]; // we still have to replace the vars
                              // in repl[j] by the corresp. entries of PARA
             // replace all variables!=t (from CUTDOWNRING)
-            for (l=1;l<=nvars(CUTDOWNRING)-1;l++) 
+            for (l=1;l<=nvars(CUTDOWNRING)-1;l++)
             {
               // substitute the kth variable by PARA[k]
-              LIFT[j]=subst(LIFT[j],var(l),PARA[l]); 
+              LIFT[j]=subst(LIFT[j],var(l),PARA[l]);
             }
           }
         }
         setring LIFTRING;
-        ideal LIFT=imap(REPLACEMENTRING,LIFT);    
-        // test now if the LIFT has the correct valuation !!!     
-        // note: it may happen, that when resubstituting PARA into 
+        ideal LIFT=imap(REPLACEMENTRING,LIFT);
+        // test now if the LIFT has the correct valuation !!!
+        // note: it may happen, that when resubstituting PARA into
         //       the replacement rules
-        //       there occured some unexpected cancellation; 
+        //       there occured some unexpected cancellation;
         //       we only know that for SOME
-        //       solution of the zero-dimensional reduction NO 
-        //       canellation will occur, 
-        //       but for others this may very well happen; 
+        //       solution of the zero-dimensional reduction NO
+        //       canellation will occur,
+        //       but for others this may very well happen;
         //       this in particular means that
-        //       we possibly MUST compute all zero-dimensional 
+        //       we possibly MUST compute all zero-dimensional
         //       solutions when cutting down!
         intvec testw=precutdownw[1];
@@ -589 +589 @@
       kill PARA;
       // only if LIFT has the right valuation we have to do something
-      if (isgood==1) 
-      {
-        // it remains to reverse the original substitutions, 
+      if (isgood==1)
+      {
+        // it remains to reverse the original substitutions,
         // where appropriate !!!
-        // if some entry of the original w was positive, 
+        // if some entry of the original w was positive,
         // we replace the corresponding
         // variable x_i by t^-w[i]*x_i, so we must now replace
@@ -610 +610 @@
         */
         // if LIFTRING contains a parameter @a, change it to a
-        if ((noabs==0) and (defined(@a)==-1)) 
+        if ((noabs==0) and (defined(@a)==-1))
         {
-          // pass first to a ring where a and @a 
+          // pass first to a ring where a and @a
           // are variables in order to use maps
           poly mp=minpoly;
@@ -621 +621 @@
           // replace @a by a in minpoly and in LIFT
           map phi=INTERRING,t,a,a;
-          mp=phi(mp);      
+          mp=phi(mp);
           LIFT=phi(LIFT);
           // pass now to a ring whithout @a and with a as parameter
@@ -628 +628 @@
           ideal LIFT=imap(INTERRING,LIFT);
           kill INTERRING;
-        }    
+        }
         // then export LIFT
-        export(LIFT); 
+        export(LIFT);
         // test the  result by resubstitution
-        setring GRUNDRING;  
+        setring GRUNDRING;
         list resubst;
         if (noresubst==0)
@@ -641 +641 @@
           }
           else
-          {      
+          {
             resubst=tropicalliftingresubstitute(substitute(i,t,t^(TP[jj][2])),list(LIFTRING),N*TP[jj][2]);
           }
         }
         setring BASERING;
-        // Finally, if t has been replaced by t^N, then we have to change the 
+        // Finally, if t has been replaced by t^N, then we have to change the
         // third entry of TP by multiplying by N.
         if (noabs==1)
@@ -662 +662 @@
       kill LIFTRING;
     }
-    // if dd!=0 and the procedure was called without the 
+    // if dd!=0 and the procedure was called without the
     // option findAll, then it might very well
-    // be the case that no solution is found, since 
+    // be the case that no solution is found, since
     // only one solution for the zero-dimensional
-    // reduction was computed and this one might have 
+    // reduction was computed and this one might have
     // had cancellations when resubstituting;
     // if so we have to restart the process with the option findAll
@@ -674 +674 @@
       "The procedure will be restarted with the option 'findAll'.";
       "Go on by hitting RETURN!";
-      findall=1;    
+      findall=1;
       noabs=0;
       setring CUTDOWNRING;
@@ -680 +680 @@
       "i";i;
       "ini";tInitialIdeal(i,w,1);
-      
+
 /*
       setring GRUNDRING;
@@ -698 +698 @@
     }
   }
-  // if internally the option findall was set, then return 
+  // if internally the option findall was set, then return
   // only the first solution
   if (defined(hadproblems)!=0)
@@ -707 +707 @@
   if (voice+printlevel>=2)
   {
-      
+
       "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 
+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:
 ";
     if (findall==1)
     {
-      "def LIFTRing=L[1][1]; setring LIFTRing; LIFT; 
+      "def LIFTRing=L[1][1]; setring LIFTRing; LIFT;
 ";
     }
     else
     {
-      "def LIFTRing=L[1]; setring LIFTRing; LIFT; 
+      "def LIFTRing=L[1]; setring LIFTRing; LIFT;
 ";
-    }  
+    }
   }
   if (findall==1) // if all solutions have been computed, return a list of lists
@@ -751 +751 @@
    def LIFTRing=LIST[1];
    setring LIFTRing;
-   // LIFT contains the first 4 terms of a point in the variety of i 
+   // 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;
@@ -779 +779 @@
    // 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. 
+   //       is not allowed for a variable.
    def LIFTRing3=LIST[1];
    setring LIFTRing3;
@@ -834 +834 @@
       string Kstring="Z/"+string(char(LIFTRing))+"Z";
     }
-    // this means that tropicalLifting was called with 
+    // this means that tropicalLifting was called with
     // absolute primary decomposition
-    if (size(troplift)==4) 
-    {      
+    if (size(troplift)==4)
+    {
       setring LIFTRing;
       "The lifting of the point in the tropical variety lives in the ring";
       if ((size(LIFTpar)==0) and (N==1))
       {
-        Kstring+"[[t]]"; 
+        Kstring+"[[t]]";
       }
       if ((size(LIFTpar)==0) and (N!=1))
       {
-        Kstring+"[[t^(1/"+string(N)+")]]"; 
+        Kstring+"[[t^(1/"+string(N)+")]]";
       }
       if ((size(LIFTpar)!=0) and (N!=1))
-      {    
-        Kstring+"["+LIFTpar+"]/"+string(minpoly)+"[[t^(1/"+string(N)+")]]";  
+      {
+        Kstring+"["+LIFTpar+"]/"+string(minpoly)+"[[t^(1/"+string(N)+")]]";
       }
       if ((size(LIFTpar)!=0) and (N==1))
-      {    
-        Kstring+"["+LIFTpar+"]/"+string(minpoly)+"[[t]]";  
+      {
+        Kstring+"["+LIFTpar+"]/"+string(minpoly)+"[[t]]";
       }
     }
@@ -871 +871 @@
       }
       if ((size(LIFTpar)!=0) and (N!=1))
-      {    
-        Kstring+"["+LIFTpar+"]/M[[t^(1/"+string(N)+")]]";  
+      {
+        Kstring+"["+LIFTpar+"]/M[[t^(1/"+string(N)+")]]";
         "where M is the maximal ideal";
         "M=<"+m+">";
       }
       if ((size(LIFTpar)!=0) and (N==1))
-      {    
-        Kstring+"["+LIFTpar+"]/M[[t]]";  
+      {
+        Kstring+"["+LIFTpar+"]/M[[t]]";
         "where M is the maximal ideal";
         "M=<"+m+">";
-      }      
+      }
     }
     "";
@@ -908 +908 @@
       }
     }
-  }      
+  }
 }
 example
@@ -922 +922 @@
 
 ///////////////////////////////////////////////////////////////////////////////
-/// Procedures concerned with drawing a tropical curve or a Newton subdivision 
+/// Procedures concerned with drawing a tropical curve or a Newton subdivision
 ///////////////////////////////////////////////////////////////////////////////
 
 proc tropicalCurve (def tp,list #)
 "USAGE:      tropicalCurve(tp[,#]); tp list, # optional list
-ASSUME:      tp is list of linear polynomials of the form ax+by+c 
-             with integers a, b and a rational number c representing 
+ASSUME:      tp is list of linear polynomials of the form ax+by+c
+             with integers a, b and a rational number c representing
              a tropical Laurent polynomial defining a tropical plane curve;
-             alternatively tp can be a polynomial in Q(t)[x,y] defining a 
-             tropical plane curve via the valuation map; 
-             the basering must have a global monomial ordering, 
+             alternatively tp can be a polynomial in Q(t)[x,y] defining a
+             tropical plane curve via the valuation map;
+             the basering must have a global monomial ordering,
              two variables and up to one parameter!
-RETURN:      list, each entry i=1,...,size(l)-1 corresponds to a vertex 
+RETURN:      list, each entry i=1,...,size(l)-1 corresponds to a vertex
                    in the tropical plane curve defined by tp
                    l[i][1] = x-coordinate of the ith vertex
                    l[i][2] = y-coordinate of the ith vertex
-                   l[i][3] = intmat, if j is an entry in the first row 
+                   l[i][3] = intmat, if j is an entry in the first row
                              of intmat then the ith vertex of
-                             the tropical curve is connected to the 
+                             the tropical curve is connected to the
                              jth vertex with multiplicity given
                              by the corresponding entry in the second row
-                   l[i][4] = list of lists, the first entry of a list is 
-                             a primitive integer vector defining the direction 
-                             of an unbounded edge emerging from the ith vertex 
-                             of the graph, the corresponding second entry in 
+                   l[i][4] = list of lists, the first entry of a list is
+                             a primitive integer vector defining the direction
+                             of an unbounded edge emerging from the ith vertex
+                             of the graph, the corresponding second entry in
                              the list is the multiplicity of the unbounded edge
-                   l[i][5] = a polynomial whose monomials mark the vertices 
+                   l[i][5] = a polynomial whose monomials mark the vertices
                              in the Newton polygon corresponding to the entries
-                             in tp which take the common minimum at the ith 
-                             vertex -- if some coefficient a or b of the 
-                             linear polynomials in the input was negative, 
+                             in tp which take the common minimum at the ith
+                             vertex -- if some coefficient a or b of the
+                             linear polynomials in the input was negative,
                              then each monomial has to be shifted by
                              the values in l[size(l)][3]
-                   l[size(l)][1] = list, the entries describe the boundary 
+                   l[size(l)][1] = list, the entries describe the boundary
                                          points of the Newton subdivision
-                   l[size(l)][2] = list, the entries are pairs of integer 
+                   l[size(l)][2] = list, the entries are pairs of integer
                                          vectors defining an interior
                                          edge of the Newton subdivision
-                   l[size(l)][3] = intvec, the monmials occuring in l[i][5] 
-                                           have to be shifted by this vector 
-                                           in order to represent marked 
+                   l[size(l)][3] = intvec, the monmials occuring in l[i][5]
+                                           have to be shifted by this vector
+                                           in order to represent marked
                                            vertices in the Newton polygon
-NOTE:        here the tropical polynomial is supposed to be the MINIMUM 
-             of the linear forms in tp, unless the optional input #[1] 
+NOTE:        here the tropical polynomial is supposed to be the MINIMUM
+             of the linear forms in tp, unless the optional input #[1]
              is the string 'max'
 EXAMPLE:     example tropicalCurve;   shows an example"
@@ -978 +978 @@
     ERROR("The basering should have a global monomial ordering, e.g. ring r=(0,t),(x,y),dp;");
   }
-  // if you insert a single polynomial instead of an ideal 
+  // if you insert a single polynomial instead of an ideal
   // representing a tropicalised polynomial,
-  // then we compute first the tropicalisation of this polynomial 
+  // then we compute first the tropicalisation of this polynomial
   // -- this feature is not documented in the above help string
   if (typeof(tp)=="poly")
   {
-    // exclude the case that the basering has not precisely 
+    // exclude the case that the basering has not precisely
     // one parameter and two indeterminates
     if ((npars(basering)!=1) or (nvars(basering)!=2))
     {
-      ERROR("The basering should have precisely one parameter and two indeterminates!");      
+      ERROR("The basering should have precisely one parameter and two indeterminates!");
     }
     poly f=tp;
@@ -997 +997 @@
   if (nvars(basering) != 2)
   {
-    ERROR("The basering should have precisely two indeterminates!");      
-  }
-  // -1) Exclude the pathological case that the defining 
+    ERROR("The basering should have precisely two indeterminates!");
+  }
+  // -1) Exclude the pathological case that the defining
   //     tropical polynomial has only one term,
   //     so that the tropical variety is not defined.
@@ -1007 +1007 @@
     intmat M[2][1]=0,0;
     return(list(list(0,0,M,list(),detropicalise(tp[1])),list(list(leadexp(detropicalise(tp[1]))),list())));
-  }    
-  // 0) If the input was a list of linear polynomials, 
+  }
+  // 0) If the input was a list of linear polynomials,
   //    then some coefficient of x or y can be negative,
-  //    i.e. the input corresponds to the tropical curve 
+  //    i.e. the input corresponds to the tropical curve
   //    of a Laurent polynomial. In that case we should
-  //    add some ax+by, so that all coefficients are positive. 
+  //    add some ax+by, so that all coefficients are positive.
   //    This does not change the tropical curve.
-  //    however, we have to save (a,b), since the Newton 
+  //    however, we have to save (a,b), since the Newton
   //    polygone has to be shifted by (-a,-b).
   poly aa,bb; // koeffizienten
@@ -1026 +1026 @@
     {
       bb=koeffizienten(tp[i],2);
-    }    
+    }
   }
   if ((aa!=0) or (bb!=0))
@@ -1035 +1035 @@
     }
   }
-  // 1) compute the vertices of the tropical curve 
+  // 1) compute the vertices of the tropical curve
   //    defined by tp and the Newton subdivision
   list vtp=verticesTropicalCurve(tp,#);
-  //    if vtp is empty, then the Newton polygone is just 
+  //    if vtp is empty, then the Newton polygone is just
   //    a line segment and constitutes a bunch of lines
   //    which can be computed by bunchOfLines
@@ -1045 +1045 @@
     return(bunchOfLines(tp));
   }
-  // 2) store all vertices belonging to the ith part of the 
+  // 2) store all vertices belonging to the ith part of the
   //    Newton subdivision in the list vtp[i] as 4th entry,
   //    and store those, which are not corners of the ith subdivision polygon
   //    in vtp[i][6]
-  poly nwt; 
+  poly nwt;
   list boundaryNSD;  // stores the boundary of a Newton subdivision
-  intmat zwsp[2][1]; // used for intermediate storage    
+  intmat zwsp[2][1]; // used for intermediate storage
   for (i=1;i<=size(vtp);i++)
   {
     k=1;
-    nwt=vtp[i][3]; // the polynomial representing the 
+    nwt=vtp[i][3]; // the polynomial representing the
     // ith part of the Newton subdivision
-    // store the vertices of the ith part of the 
+    // store the vertices of the ith part of the
     // Newton subdivision in the list newton
-    list newton;  
+    list newton;
     while (nwt!=0)
     {
@@ -1066 +1066 @@
       k++;
     }
-    boundaryNSD=findOrientedBoundary(newton);// a list of the vertices 
-                                             // of the Newton subdivision 
-                                             // as integer vectors (only those 
-                                             // on the boundary, and oriented 
+    boundaryNSD=findOrientedBoundary(newton);// a list of the vertices
+                                             // of the Newton subdivision
+                                             // as integer vectors (only those
+                                             // on the boundary, and oriented
                                              // clockwise)
     vtp[i][4]=boundaryNSD[1];
     vtp[i][5]=boundaryNSD[2];
-    vtp[i][6]=zwsp; // the entries of the first row will denote to which 
-                    // vertex the ith one is connected 
-                    // and the entries of the second row will denote 
+    vtp[i][6]=zwsp; // the entries of the first row will denote to which
+                    // vertex the ith one is connected
+                    // and the entries of the second row will denote
                     //with which multiplicity
     kill newton; // we kill the superflous list
   }
-  // 3) Next we build for each part of the Newton 
+  // 3) Next we build for each part of the Newton
   //    subdivision the list of all pairs of vertices on the
   //    boundary, which are involved, including those which are not corners
@@ -1096 +1096 @@
     kill ipairs;
   }
-  // 4) Check for all pairs of verticies in the Newton diagram if they 
+  // 4) Check for all pairs of verticies in the Newton diagram if they
   //    occur in two different parts of the Newton subdivision
-  int deleted; // if a pair occurs in two NSD, it can be removed 
+  int deleted; // if a pair occurs in two NSD, it can be removed
                // from both - deleted is then set to 1
-  list inneredges; // contains the list of all pairs contained in two NSD 
+  list inneredges; // contains the list of all pairs contained in two NSD
                    // - these are inner the edges of NSD
   int ggt;
   d=1;  // counts the inner edges
   for (i=1;i<=size(pairs)-1;i++)
-  {  
+  {
     for (j=i+1;j<=size(pairs);j++)
     {
@@ -1112 +1112 @@
         deleted=0;
         for (l=size(pairs[j]);l>=1 and deleted==0;l--)
-        {  
+        {
           if (((pairs[i][k][1]==pairs[j][l][1]) and (pairs[i][k][2]==pairs[j][l][2])) or ((pairs[i][k][1]==pairs[j][l][2]) and (pairs[i][k][2]==pairs[j][l][1])))
           {
@@ -1118 +1118 @@
             d++;
             ggt=abs(gcd(pairs[i][k][1][1]-pairs[i][k][2][1],pairs[i][k][1][2]-pairs[i][k][2][2]));
-            zwsp=j,ggt;   // and it is recorded that the ith and jth 
+            zwsp=j,ggt;   // and it is recorded that the ith and jth
                           // vertex should be connected with mult ggt
             vtp[i][6]=intmatconcat(vtp[i][6],zwsp);
             zwsp=i,ggt;
             vtp[j][6]=intmatconcat(vtp[j][6],zwsp);
-            pairs[i]=delete(pairs[i],k);  // finally the pair is deleted 
+            pairs[i]=delete(pairs[i],k);  // finally the pair is deleted
                                           // from both sets of pairs
             pairs[j]=delete(pairs[j],l);
@@ -1163 +1163 @@
     }
   }
-  // 6.3) Order the vertices such that passing from one to the next we 
+  // 6.3) Order the vertices such that passing from one to the next we
   //      travel along the boundary of the Newton polytope clock wise.
   boundaryNSD=findOrientedBoundary(vertices);
   list orderedvertices=boundaryNSD[1];
   // 7) Find the unbounded edges emerging from a vertex in the tropical curve.
-  //    For this we check the remaining pairs for the ith NSD. 
+  //    For this we check the remaining pairs for the ith NSD.
   //    Each pair is ordered according
-  //    to the order in which the vertices occur in orderedvertices. 
+  //    to the order in which the vertices occur in orderedvertices.
   //    The direction of the
-  //    unbounded edge is then the outward pointing primitive normal 
+  //    unbounded edge is then the outward pointing primitive normal
   //    vector to the vector
   //    pointing from the first vertex in a pair to the second one.
@@ -1182 +1182 @@
   for (i=1;i<=size(pairs);i++)
   {
-    list ubedges; // stores the unbounded edges 
+    list ubedges; // stores the unbounded edges
     k=1; // counts the unbounded edges
     for (j=1;j<=size(pairs[i]);j++)
     {
       // computes the position of the vertices in the
-      pos1=positionInList(orderedvertices,pairs[i][j][1]); 
+      pos1=positionInList(orderedvertices,pairs[i][j][1]);
       // pair in the list orderedvertices
-      pos2=positionInList(orderedvertices,pairs[i][j][2]); 
+      pos2=positionInList(orderedvertices,pairs[i][j][2]);
       if (((pos1>pos2) and !((pos1==size(orderedvertices)) and (pos2==1))) or ((pos2==size(orderedvertices)) and (pos1==1)))  // reorders them if necessary
       {
@@ -1197 +1197 @@
       }
       // the vector pointing from vertex 1 in the pair to vertex2
-      normalvector=pairs[i][j][2]-pairs[i][j][1]; 
+      normalvector=pairs[i][j][2]-pairs[i][j][1];
       ggt=gcd(normalvector[1],normalvector[2]);   // the gcd of the entries
       zw=normalvector[2];    // create the outward pointing normal vector
@@ -1229 +1229 @@
     kill ubedges;
   }
-  // 8) Store the computed information for the ith part 
+  // 8) Store the computed information for the ith part
   //    of the NSD in the list graph[i].
   list graph,gr;
@@ -1235 +1235 @@
   {
     // the first coordinate of the ith vertex of the tropical curve
-    gr[1]=vtp[i][1];  
+    gr[1]=vtp[i][1];
     // the second coordinate of the ith vertex of the tropical curve
-    gr[2]=vtp[i][2];  
+    gr[2]=vtp[i][2];
     // to which vertices is the ith vertex of the tropical curve connected
-    gr[3]=vtp[i][6];  
-    // the directions unbounded edges emerging from the ith 
+    gr[3]=vtp[i][6];
+    // the directions unbounded edges emerging from the ith
     // vertex of the trop. curve
-    gr[4]=vtp[i][7];  
-    // the vertices of the boundary of the ith part of the NSD 
-    gr[5]=vtp[i][3];  
+    gr[4]=vtp[i][7];
+    // the vertices of the boundary of the ith part of the NSD
+    gr[5]=vtp[i][3];
     graph[i]=gr;
   }
@@ -1263 +1263 @@
     }
   }
-  // 10) Finally store the boundary vertices and 
+  // 10) Finally store the boundary vertices and
   //     the inner edges as last entry in the list graph.
   //     This represents the NSD.
@@ -1280 +1280 @@
 // the coordinates of the first vertex are graph[1][1],graph[1][2];
    graph[1][1],graph[1][2];
-// the first vertex is connected to the vertices 
+// the first vertex is connected to the vertices
 //     graph[1][3][1,1..ncols(graph[1][3])]
    intmat M=graph[1][3];
    M[1,1..ncols(graph[1][3])];
-// the weights of the edges to these vertices are 
+// the weights of the edges to these vertices are
 //     graph[1][3][2,1..ncols(graph[1][3])]
    M[2,1..ncols(graph[1][3])];
 // from the first vertex emerge size(graph[1][4]) unbounded edges
    size(graph[1][4]);
-// the primitive integral direction vector of the first unbounded edge 
+// the primitive integral direction vector of the first unbounded edge
 //     of the first vertex
    graph[1][4][1][1];
 // the weight of the first unbounded edge of the first vertex
    graph[1][4][1][2];
-// the monomials which are part of the Newton subdivision of the first vertex 
+// the monomials which are part of the Newton subdivision of the first vertex
    graph[1][5];
-// connecting the points in graph[size(graph)][1] we get 
+// connecting the points in graph[size(graph)][1] we get
 //     the boundary of the Newton polytope
    graph[size(graph)][1];
-// an entry in graph[size(graph)][2] is a pair of points 
+// an entry in graph[size(graph)][2] is a pair of points
 //     in the Newton polytope bounding an inner edge
    graph[size(graph)][2][1];
@@ -1308 +1308 @@
 proc drawTropicalCurve (def f,list #)
 "USAGE:      drawTropicalCurve(f[,#]); f poly or list, # optional list
-ASSUME:      f is list of linear polynomials of the form ax+by+c with 
-             integers a, b and a rational number c representing a tropical 
+ASSUME:      f is list of linear polynomials of the form ax+by+c with
+             integers a, b and a rational number c representing a tropical
              Laurent polynomial defining a tropical plane curve;
-             alternatively f can be a polynomial in Q(t)[x,y] defining 
-             a tropical plane curve via the valuation map; 
-             the basering must have a global monomial ordering, two 
+             alternatively f can be a polynomial in Q(t)[x,y] defining
+             a tropical plane curve via the valuation map;
+             the basering must have a global monomial ordering, two
              variables and up to one parameter!
 RETURN:      NONE
-NOTE:        - the procedure creates the files /tmp/tropicalcurveNUMBER.tex and 
-               /tmp/tropicalcurveNUMBER.ps, where NUMBER is a random four 
-               digit integer; 
+NOTE:        - the procedure creates the files /tmp/tropicalcurveNUMBER.tex and
+               /tmp/tropicalcurveNUMBER.ps, where NUMBER is a random four
+               digit integer;
                moreover it displays the tropical curve via kghostview;
-               if you wish to remove all these files from /tmp, 
+               if you wish to remove all these files from /tmp,
                call the procedure cleanTmp
 @*           - edges with multiplicity greater than one carry this multiplicity
 @*           - if # is empty, then the tropical curve is computed w.r.t. minimum,
-               if #[1] is the string 'max', then it is computed w.r.t. maximum 
-@*           - if the last optional argument is 'onlytexfile' then only the 
-               latex file is produced; this option should be used if kghostview 
+               if #[1] is the string 'max', then it is computed w.r.t. maximum
+@*           - if the last optional argument is 'onlytexfile' then only the
+               latex file is produced; this option should be used if kghostview
                is not installed on your system
-@*           - note that lattice points in the Newton subdivision which are 
-               black correspond to markings of the marked subdivision, 
+@*           - note that lattice points in the Newton subdivision which are
+               black correspond to markings of the marked subdivision,
                while lattice points in grey are not marked
 EXAMPLE:     example drawTropicalCurve  shows an example"
@@ -1347 +1347 @@
   if (typeof(f)=="poly")
   {
-    // exclude the case that the basering has not precisely 
+    // exclude the case that the basering has not precisely
     // one parameter and two indeterminates
     if ((npars(basering)!=1) or (nvars(basering)!=2))
     {
-      ERROR("The basering should have precisely one parameter and two indeterminates!");      
+      ERROR("The basering should have precisely one parameter and two indeterminates!");
     }
     texf=texPolynomial(f); // write the polynomial over Q(t)
@@ -1362 +1362 @@
       texf="\\mbox{\\tt The defining equation was not handed over!}";
       list graph=f;
-    }   
+    }
     else
     { // write the tropical polynomial defined by f
       if (size(#)==0)
-      {      
+      {
         texf="\\min\\{";
       }
@@ -1375 +1375 @@
       for (j=1;j<=size(f);j++)
       {
-        texf=texf+texPolynomial(f[j]);    
+        texf=texf+texPolynomial(f[j]);
         if (j<size(f))
         {
@@ -1384 +1384 @@
           texf=texf+"\\}";
         }
-      }    
+      }
       list graph=tropicalCurve(f,#); // the graph of the tropical polynomial f
     }
@@ -1402 +1402 @@
 \\addtolength{\\topmargin}{-\\headheight}
 \\addtolength{\\topmargin}{-\\topskip}
-\\setlength{\\textheight}{267mm} 
+\\setlength{\\textheight}{267mm}
 \\addtolength{\\textheight}{\\topskip}
 \\addtolength{\\textheight}{-\\footskip}
 \\addtolength{\\textheight}{-30pt}
-\\setlength{\\oddsidemargin}{-1in} 
+\\setlength{\\oddsidemargin}{-1in}
 \\addtolength{\\oddsidemargin}{20mm}
 \\setlength{\\evensidemargin}{\\oddsidemargin}
-\\setlength{\\textwidth}{170mm} 
+\\setlength{\\textwidth}{170mm}
 
 \\begin{document}
    \\parindent0cm
    \\begin{center}
-      \\large\\bf The Tropicalisation of 
+      \\large\\bf The Tropicalisation of
 
       \\bigskip
@@ -1438 +1438 @@
 
    \\begin{center}
-       "+texDrawNewtonSubdivision(graph,#)+" 
+       "+texDrawNewtonSubdivision(graph,#)+"
    \\end{center}
 \\end{document}";
@@ -1445 +1445 @@
     int rdnum=random(1000,9999);
     write(":w /tmp/tropicalcurve"+string(rdnum)+".tex",TEXBILD);
-    system("sh","cd /tmp; latex /tmp/tropicalcurve"+string(rdnum)+".tex; dvips /tmp/tropicalcurve"+string(rdnum)+".dvi -o; /bin/rm tropicalcurve"+string(rdnum)+".log;  /bin/rm tropicalcurve"+string(rdnum)+".aux;  /bin/rm tropicalcurve"+string(rdnum)+".ps?;  /bin/rm tropicalcurve"+string(rdnum)+".dvi; kghostview tropicalcurve"+string(rdnum)+".ps &");  
+    system("sh","cd /tmp; latex /tmp/tropicalcurve"+string(rdnum)+".tex; dvips /tmp/tropicalcurve"+string(rdnum)+".dvi -o; /bin/rm tropicalcurve"+string(rdnum)+".log;  /bin/rm tropicalcurve"+string(rdnum)+".aux;  /bin/rm tropicalcurve"+string(rdnum)+".ps?;  /bin/rm tropicalcurve"+string(rdnum)+".dvi; kghostview tropicalcurve"+string(rdnum)+".ps &");
   }
   else
@@ -1472 +1472 @@
 proc drawNewtonSubdivision (def f,list #)
 "USAGE:   drawTropicalCurve(f[,#]); f poly, # optional list
-ASSUME:   f is list of linear polynomials of the form ax+by+c with integers 
-          a, b and a rational number c representing a tropical Laurent 
+ASSUME:   f is list of linear polynomials of the form ax+by+c with integers
+          a, b and a rational number c representing a tropical Laurent
           polynomial defining a tropical plane curve;
-          alternatively f can be a polynomial in Q(t)[x,y] defining a tropical 
-          plane curve via the valuation map; 
-          the basering must have a global monomial ordering, two variables 
+          alternatively f can be a polynomial in Q(t)[x,y] defining a tropical
+          plane curve via the valuation map;
+          the basering must have a global monomial ordering, two variables
           and up to one parameter!
 RETURN:   NONE
-NOTE:     - the procedure creates the files /tmp/newtonsubdivisionNUMBER.tex, 
-            and /tmp/newtonsubdivisionNUMBER.ps, where NUMBER is a random 
-            four digit integer; 
+NOTE:     - the procedure creates the files /tmp/newtonsubdivisionNUMBER.tex,
+            and /tmp/newtonsubdivisionNUMBER.ps, where NUMBER is a random
+            four digit integer;
             moreover it desplays the tropical curve defined by f via kghostview;
-            if you wish to remove all these files from /tmp, call the procedure 
+            if you wish to remove all these files from /tmp, call the procedure
             cleanTmp;
-@*          if # is empty, then the tropical curve is computed w.r.t. minimum, 
-            if #[1] is the string 'max', then it is computed w.r.t. maximum 
-@*        - note that lattice points in the Newton subdivision which are black 
-            correspond to markings of the marked subdivision, while lattice 
+@*          if # is empty, then the tropical curve is computed w.r.t. minimum,
+            if #[1] is the string 'max', then it is computed w.r.t. maximum
+@*        - note that lattice points in the Newton subdivision which are black
+            correspond to markings of the marked subdivision, while lattice
             points in grey are not marked
 EXAMPLE:     example drawNewtonSubdivision;   shows an example"
@@ -1503 +1503 @@
   { // write the tropical polynomial defined by f
     if (size(#)==0)
-    {      
+    {
       texf="\\min\\{";
     }
@@ -1512 +1512 @@
     for (j=1;j<=size(f);j++)
     {
-      texf=texf+texPolynomial(f[j]);    
+      texf=texf+texPolynomial(f[j]);
       if (j<size(f))
       {
@@ -1521 +1521 @@
         texf=texf+"\\}";
       }
-    }    
+    }
     list graph=tropicalCurve(f,#); // the graph of the tropical polynomial f
   }
@@ -1529 +1529 @@
    \\parindent0cm
    \\begin{center}
-      \\large\\bf The Newtonsubdivison of 
+      \\large\\bf The Newtonsubdivison of
       \\begin{displaymath}
           f="+texf+"
@@ -1537 +1537 @@
 
    \\begin{center}
-"+texDrawNewtonSubdivision(graph)+  
+"+texDrawNewtonSubdivision(graph)+
 "   \\end{center}
 
@@ -1543 +1543 @@
   int rdnum=random(1000,9999);
   write(":w /tmp/newtonsubdivision"+string(rdnum)+".tex",TEXBILD);
-  system("sh","cd /tmp; latex /tmp/newtonsubdivision"+string(rdnum)+".tex; dvips /tmp/newtonsubdivision"+string(rdnum)+".dvi -o; /bin/rm newtonsubdivision"+string(rdnum)+".log;  /bin/rm newtonsubdivision"+string(rdnum)+".aux;  /bin/rm newtonsubdivision"+string(rdnum)+".ps?;  /bin/rm newtonsubdivision"+string(rdnum)+".dvi; kghostview newtonsubdivision"+string(rdnum)+".ps &");  
+  system("sh","cd /tmp; latex /tmp/newtonsubdivision"+string(rdnum)+".tex; dvips /tmp/newtonsubdivision"+string(rdnum)+".dvi -o; /bin/rm newtonsubdivision"+string(rdnum)+".log;  /bin/rm newtonsubdivision"+string(rdnum)+".aux;  /bin/rm newtonsubdivision"+string(rdnum)+".ps?;  /bin/rm newtonsubdivision"+string(rdnum)+".dvi; kghostview newtonsubdivision"+string(rdnum)+".ps &");
 //  return(TEXBILD);
 }
@@ -1568 +1568 @@
 proc tropicalJInvariant (def f,list #)
 "USAGE:      tropicalJInvariant(f[,#]); f poly or list, # optional list
-ASSUME:      f is list of linear polynomials of the form ax+by+c with integers 
-             a, b and a rational number c representing a tropical Laurent 
+ASSUME:      f is list of linear polynomials of the form ax+by+c with integers
+             a, b and a rational number c representing a tropical Laurent
              polynomial defining a tropical plane curve;
-             alternatively f can be a polynomial in Q(t)[x,y] defining a 
-             tropical plane curve via the valuation map; 
-@*           the basering must have a global monomial ordering, two variables 
+             alternatively f can be a polynomial in Q(t)[x,y] defining a
+             tropical plane curve via the valuation map;
+@*           the basering must have a global monomial ordering, two variables
              and up to one parameter!
-RETURN:      number, if the graph underlying the tropical curve has precisely 
-                     one loop then its weighted lattice length is returned, 
+RETURN:      number, if the graph underlying the tropical curve has precisely
+                     one loop then its weighted lattice length is returned,
                      otherwise the result will be -1
-NOTE:        - if the tropical curve is elliptic and its embedded graph has 
-               precisely one loop, then the weigthed lattice length of 
+NOTE:        - if the tropical curve is elliptic and its embedded graph has
+               precisely one loop, then the weigthed lattice length of
                the loop is its tropical j-invariant
-@*           - the procedure checks if the embedded graph of the tropical 
-               curve has genus one, but it does NOT check if the loop can 
-               be resolved, so that the curve is not a proper tropical 
-               elliptic curve 
-@*           - if the embedded graph of a tropical elliptic curve has more 
-               than one loop, then all but one can be resolved, but this is 
-               not observed by this procedure, so it will not compute 
+@*           - the procedure checks if the embedded graph of the tropical
+               curve has genus one, but it does NOT check if the loop can
+               be resolved, so that the curve is not a proper tropical
+               elliptic curve
+@*           - if the embedded graph of a tropical elliptic curve has more
+               than one loop, then all but one can be resolved, but this is
+               not observed by this procedure, so it will not compute
                the j-invariant
 @*           - if # is empty, then the tropical curve is computed w.r.t. minimum,
-               if #[1] is the string 'max', then it is computed w.r.t. maximum 
-@*           - the tropicalJInvariant of a plane tropical cubic is the 
-               'cycle length' of the cubic as introduced in the paper: 
-               Eric Katz, Hannah Markwig, Thomas Markwig: The j-invariant 
+               if #[1] is the string 'max', then it is computed w.r.t. maximum
+@*           - the tropicalJInvariant of a plane tropical cubic is the
+               'cycle length' of the cubic as introduced in the paper:
+               Eric Katz, Hannah Markwig, Thomas Markwig: The j-invariant
                of a cubic tropical plane curve.
 EXAMPLE:     example tropicalJInvariant;   shows an example"
@@ -1607 +1607 @@
     {
       if (typeof(f[1])=="list")
-      {        
+      {
         list graph=f;
       }
@@ -1619 +1619 @@
         {
           ERROR("This is no valid input.");
-        }        
+        }
       }
     }
@@ -1636 +1636 @@
   genus=-genus/2; // we have counted each bounded edge twice
   genus=genus+size(graph); // the genus is 1-#bounded_edges+#vertices
-  // 3) if the embedded graph has not genus one, 
+  // 3) if the embedded graph has not genus one,
   //    we cannot compute the j-invariant
   if(genus!=1)
@@ -1648 +1648 @@
   else
   {
-    intmat nullmat[2][1];  // used to set 
-    // 4) find a vertex which has only one bounded edge, 
-    //    if none exists zero is returned, 
+    intmat nullmat[2][1];  // used to set
+    // 4) find a vertex which has only one bounded edge,
+    //    if none exists zero is returned,
     //    otherwise the number of the vertex in the list graph
-    int nonloopvertex=findNonLoopVertex(graph);    
+    int nonloopvertex=findNonLoopVertex(graph);
     int dv; //checks if vert. has been found to which nonloopvertex is connected
-    intmat delvert; // takes for a moment graph[i][3] of the vertex 
+    intmat delvert; // takes for a moment graph[i][3] of the vertex
                     // to which nonloopvertex is connected
-    // 5) delete successively vertices in the graph which 
+    // 5) delete successively vertices in the graph which
     //    have only one bounded edge
     while (nonloopvertex>0)
     {
-      // find the only vertex to which the nonloopvertex 
+      // find the only vertex to which the nonloopvertex
       // is connected, when it is found
       // delete the connection in graph[i][3] and set dv=1
@@ -1673 +1673 @@
             {
               delvert=graph[i][3];
-              delvert=intmatcoldelete(delvert,j); // delete the connection (note 
+              delvert=intmatcoldelete(delvert,j); // delete the connection (note
                                                   // there must have been two!)
               dv=1;
@@ -1681 +1681 @@
         }
       }
-      graph[nonloopvertex][3]=nullmat; // the only connection of nonloopvertex 
+      graph[nonloopvertex][3]=nullmat; // the only connection of nonloopvertex
                                        // is killed
-      nonloopvertex=findNonLoopVertex(graph); // find the next vertex 
+      nonloopvertex=findNonLoopVertex(graph); // find the next vertex
                                               // which has only one edge
     }
@@ -1689 +1689 @@
     intvec loop,weights; // encodes the loop and the edges
     i=1;
-    //    start by finding some vertex which belongs to the loop 
-    while (loop==0) 
+    //    start by finding some vertex which belongs to the loop
+    while (loop==0)
     {
       // if graph[i][3] of a vertex in the loop has 2 columns, all others have 1
-      if (ncols(graph[i][3])==1) 
+      if (ncols(graph[i][3])==1)
       {
         i++;
@@ -1699 +1699 @@
       else
       {
-        loop[1]=i; // a starting vertex is found 
-        loop[2]=graph[i][3][1,1]; // it is connected to vertex with this number 
+        loop[1]=i; // a starting vertex is found
+        loop[2]=graph[i][3][1,1]; // it is connected to vertex with this number
         weights[2]=graph[i][3][2,1]; // and the edge has this weight
       }
@@ -1708 +1708 @@
     while (j!=i)  // the loop ends with the same vertex with which it starts
     {
-      // the first row of graph[j][3] has two entries 
+      // the first row of graph[j][3] has two entries
       // corresponding to the two vertices
-      // to which the active vertex j is connected; 
+      // to which the active vertex j is connected;
       // one is loop[k-1], i.e. the one which
       // precedes j in the loop; we have to choose the other one
-      if (graph[j][3][1,1]==loop[k-1]) 
+      if (graph[j][3][1,1]==loop[k-1])
       {
         loop[k+1]=graph[j][3][1,2];
@@ -1724 +1724 @@
       }
       j=loop[k+1]; // set loop[k+1] the new active vertex
-      k++; 
-    }    
+      k++;
+    }
     // 7) compute for each edge in the loop the lattice length
-    poly xcomp,ycomp; // the x- and y-components of the vectors 
+    poly xcomp,ycomp; // the x- and y-components of the vectors
                       // connecting two vertices of the loop
-    number nenner;    // the product of the denominators of 
+    number nenner;    // the product of the denominators of
                       // the x- and y-components
     number jinvariant;  // the j-invariant
-    int eins,zwei,ggt;  
+    int eins,zwei,ggt;
     for (i=1;i<=size(loop)-1;i++) // compute the lattice length for each edge
     {
-      xcomp=graph[loop[i]][1]-graph[loop[i+1]][1]; 
-      ycomp=graph[loop[i]][2]-graph[loop[i+1]][2]; 
+      xcomp=graph[loop[i]][1]-graph[loop[i+1]][1];
+      ycomp=graph[loop[i]][2]-graph[loop[i+1]][2];
       nenner=denominator(leadcoef(xcomp))*denominator(leadcoef(ycomp));
-      execute("eins="+string(numerator(leadcoef(nenner*xcomp)))+";"); 
-      execute("zwei="+string(numerator(leadcoef(nenner*ycomp)))+";"); 
+      execute("eins="+string(numerator(leadcoef(nenner*xcomp)))+";");
+      execute("zwei="+string(numerator(leadcoef(nenner*ycomp)))+";");
       ggt=gcd(eins,zwei); // the lattice length is the "gcd"
                           // of the x-component and the y-component
-      jinvariant=jinvariant+ggt/(nenner*weights[i+1]); // divided by the 
+      jinvariant=jinvariant+ggt/(nenner*weights[i+1]); // divided by the
                                                        // weight of the edge
     }
-    return(jinvariant);   
+    return(jinvariant);
   }
 }
@@ -1759 +1759 @@
 // the curve can have arbitrary degree
    tropicalJInvariant(t*(x7+y7+1)+1/t*(x4+y4+x2+y2+x3y+xy3)+1/t7*x2y2);
-// the procedure does not realise, if the embedded graph of the tropical 
+// the procedure does not realise, if the embedded graph of the tropical
 //     curve has a loop that can be resolved
    tropicalJInvariant(1+x+y+xy+tx2y+txy2);
 // but it does realise, if the curve has no loop at all ...
    tropicalJInvariant(x+y+1);
-// or if the embedded graph has more than one loop - even if only one 
+// or if the embedded graph has more than one loop - even if only one
 //     cannot be resolved
    tropicalJInvariant(1+x+y+xy+tx2y+txy2+t3x5+t3y5+tx2y2+t2xy4+t2yx4);
@@ -1773 +1773 @@
 proc weierstrassForm (poly f,list #)
 "USAGE:      weierstrassForm(wf[,#]); wf poly, # list
-ASSUME:      wf is a a polynomial whose Newton polygon has precisely one 
-             interior lattice point, so that it defines an elliptic curve 
+ASSUME:      wf is a a polynomial whose Newton polygon has precisely one
+             interior lattice point, so that it defines an elliptic curve
              on the toric surface corresponding to the Newton polygon
 RETURN:      poly, the Weierstrass normal form of the polynomial
@@ -1780 +1780 @@
                to Fernando Rodriguez Villegas, villegas@math.utexas.edu
 @*           - the characteristic of the base field should not be 2 or 3
-@*           - if an additional argument # is given, a simplified Weierstrass 
+@*           - if an additional argument # is given, a simplified Weierstrass
                form is computed
 EXAMPLE:     example weierstrassForm;   shows an example"
@@ -1841 +1841 @@
 
 proc jInvariant (poly f,list #)
-"USAGE:      jInvariant(f[,#]); f poly, # list 
-ASSUME:      - f is a a polynomial whose Newton polygon has precisely one 
-               interior lattice point, so that it defines an elliptic curve 
+"USAGE:      jInvariant(f[,#]); f poly, # list
+ASSUME:      - f is a a polynomial whose Newton polygon has precisely one
+               interior lattice point, so that it defines an elliptic curve
                on the toric surface corresponding to the Newton polygon
-@*           - it the optional argument # is present the base field should be 
-               Q(t) and the optional argument should be one of the following 
+@*           - it the optional argument # is present the base field should be
+               Q(t) and the optional argument should be one of the following
                strings:
-@*             'ord'   : then the return value is of type integer, 
+@*             'ord'   : then the return value is of type integer,
                          namely the order of the j-invariant
-@*             'split' : then the return value is a list of two polynomials, 
+@*             'split' : then the return value is a list of two polynomials,
                          such that the quotient of these two is the j-invariant
 RETURN:      poly, the j-invariant of the elliptic curve defined by poly
-NOTE:        the characteristic of the base field should not be 2 or 3, 
+NOTE:        the characteristic of the base field should not be 2 or 3,
              unless the input is a plane cubic
 EXAMPLE:     example jInvariant;   shows an example"
@@ -1879 +1879 @@
    echo=2;
    ring r=(0,t),(x,y),dp;
-// jInvariant computes the j-invariant of a cubic 
+// jInvariant computes the j-invariant of a cubic
    jInvariant(x+y+x2y+y3+1/t*xy);
-// if the ground field has one parameter t, then we can instead 
+// if the ground field has one parameter t, then we can instead
 //    compute the order of the j-invariant
    jInvariant(x+y+x2y+y3+1/t*xy,"ord");
@@ -1889 +1889 @@
    poly h=x22y11+x19y10+x17y9+x16y9+x12y7+x9y6+x7y5+x2y3+x14y8;
 // its j-invariant is
-   jInvariant(h);  
+   jInvariant(h);
 }
 
@@ -1908 +1908 @@
 @*                 l[6] = a list containing the vertices of the tropical conic f
 @*                 l[7] = a list containing lists with vertices of the tangents
-@*                 l[8] = a string which contains the latex-code to draw the 
+@*                 l[8] = a string which contains the latex-code to draw the
                           tropical conic and its tropicalised tangents
 @*                 l[9] = if # is non-empty, this is the same data for the dual
@@ -1932 +1932 @@
   ring LINRING=(0,t),(x,y,a(1..6)),lp;
   list points=imap(BASERING,points);
-  ideal I; // the ideal will contain the linear equations given by the conic 
+  ideal I; // the ideal will contain the linear equations given by the conic
            // and the points
   for (i=1;i<=5;i++)
@@ -1953 +1953 @@
   ring tRING=0,t,ls;
   list pointdenom=imap(BASERING,pointdenom);
-  list pointnum=imap(BASERING,pointnum);  
+  list pointnum=imap(BASERING,pointnum);
   intvec pointcoordinates;
   for (i=1;i<=size(pointdenom);i++)
@@ -2029 +2029 @@
    We consider the concic through the following five points:
    \\begin{displaymath}
-";  
+";
   string texf=texDrawTropical(graphf,list("",scalefactor));
   for (i=1;i<=size(points);i++)
@@ -2067 +2067 @@
 \\end{document}";
   setring BASERING;
-  // If # non-empty, compute the dual conic and the tangents 
-  // through the dual points 
+  // If # non-empty, compute the dual conic and the tangents
+  // through the dual points
   // corresponding to the tangents of the given conic.
   if (size(#)>0)
   {
     list dualpoints;
-    for (i=1;i<=size(points);i++) 
+    for (i=1;i<=size(points);i++)
     {
       dualpoints[i]=list(leadcoef(tangents[i])/substitute(tangents[i],x,0,y,0),leadcoef(tangents[i]-lead(tangents[i]))/substitute(tangents[i],x,0,y,0));
@@ -2097 +2097 @@
 // conic[2] is the equation of the conic f passing through the five points
    conic[2];
-// conic[3] is a list containing the equations of the tangents 
+// conic[3] is a list containing the equations of the tangents
 //          through the five points
    conic[3];
 // conic[4] is an ideal representing the tropicalisation of the conic f
    conic[4];
-// conic[5] is a list containing the tropicalisation 
+// conic[5] is a list containing the tropicalisation
 //          of the five tangents in conic[3]
    conic[5];
-// conic[6] is a list containing the vertices of the tropical conic 
+// conic[6] is a list containing the vertices of the tropical conic
    conic[6];
 // conic[7] is a list containing the vertices of the five tangents
    conic[7];
-// conic[8] contains the latex code to draw the tropical conic and 
-//          its tropicalised tangents; it can written in a file, processed and 
-//          displayed via kghostview 
-   write(":w /tmp/conic.tex",conic[8]);   
-   system("sh","cd /tmp; latex /tmp/conic.tex; dvips /tmp/conic.dvi -o; 
+// conic[8] contains the latex code to draw the tropical conic and
+//          its tropicalised tangents; it can written in a file, processed and
+//          displayed via kghostview
+   write(":w /tmp/conic.tex",conic[8]);
+   system("sh","cd /tmp; latex /tmp/conic.tex; dvips /tmp/conic.dvi -o;
             kghostview conic.ps &");
-// with an optional argument the same information for the dual conic is computed 
+// with an optional argument the same information for the dual conic is computed
 //         and saved in conic[9]
    conic=conicWithTangents(points,1);
    conic[9][2]; // the equation of the dual conic
 }
- 
+
 ///////////////////////////////////////////////////////////////////////////////
 /// Procedures concerned with tropicalisation
@@ -2129 +2129 @@
 ASSUME:      f is a polynomial in Q(t)[x_1,...,x_n]
 RETURN:      list, the linear forms of the tropicalisation of f
-NOTE:        if # is empty, then the valuation of t will be 1, 
-@*           if # is the string 'max' it will be -1; 
-@*           the latter supposes that we consider the maximum of the 
+NOTE:        if # is empty, then the valuation of t will be 1,
+@*           if # is the string 'max' it will be -1;
+@*           the latter supposes that we consider the maximum of the
              computed linear forms, the former that we consider their minimum
 EXAMPLE:     example tropicalise;   shows an example"
@@ -2154 +2154 @@
     {
       tropicalf[i]=tropicalf[i]+exp[j]*var(j);
-    }    
+    }
     f=f-lead(f);
   }
@@ -2194 +2194 @@
 /////////////////////////////////////////////////////////////////////////
 
-proc tInitialForm (poly f, intvec w) 
+proc tInitialForm (poly f, intvec w)
 "USAGE:      tInitialForm(f,w); f a polynomial, w an integer vector
 ASSUME:      f is a polynomial in Q[t,x_1,...,x_n] and w=(w_0,w_1,...,w_n)
 RETURN:      poly, the t-initialform of f(t,x) w.r.t. w evaluated at t=1
-NOTE:        the t-initialform is the sum of the terms with MAXIMAL 
+NOTE:        the t-initialform is the sum of the terms with MAXIMAL
              weighted order w.r.t. w
 EXAMPLE:     example tInitialForm;   shows an example"
@@ -2208 +2208 @@
   // do the same for the remaining part of f and compare the results
   // keep only the smallest ones
-  int vglgewicht;  
-  f=f-lead(f); 
+  int vglgewicht;
+  f=f-lead(f);
   while (f!=0)
   {
@@ -2224 +2224 @@
         initialf=initialf+lead(f);
       }
-    }    
+    }
     f=f-lead(f);
   }
@@ -2244 +2244 @@
 proc tInitialIdeal (ideal i,intvec w,list #)
 "USAGE:      tInitialIdeal(i,w); i ideal, w intvec
-ASSUME:      i is an ideal in Q[t,x_1,...,x_n] and w=(w_0,...,w_n) 
+ASSUME:      i is an ideal in Q[t,x_1,...,x_n] and w=(w_0,...,w_n)
 RETURN:      ideal ini, the t-initial ideal of i with respect to w"
 {
   // THE PROCEDURE WILL BE CALLED FROM OTHER PROCEDURES INSIDE THIS LIBRARY;
-  // IN THIS CASE THE VARIABLE t WILL INDEED BE THE LAST VARIABLE INSTEAD OF 
+  // IN THIS CASE THE VARIABLE t WILL INDEED BE THE LAST VARIABLE INSTEAD OF
   // THE FIRST,
   // AND WE THEREFORE HAVE TO MOVE IT BACK TO THE FRONT!
@@ -2272 +2272 @@
   // ... and compute a standard basis with
   // respect to the homogenised ordering defined by w. Since the generators
-  // of i will be homogeneous it we can instead take the ordering wp 
-  // with the weightvector (0,w) replaced by (M,...,M)+(0,w) for some 
-  // large M, so that all entries are positive 
-  int M=-minInIntvec(w)[1]+1; // find M such that w[j]+M is 
+  // of i will be homogeneous it we can instead take the ordering wp
+  // with the weightvector (0,w) replaced by (M,...,M)+(0,w) for some
+  // large M, so that all entries are positive
+  int M=-minInIntvec(w)[1]+1; // find M such that w[j]+M is
                               // strictly positive for all j
   intvec whomog=M;
@@ -2283 +2283 @@
   }
   execute("ring WEIGHTRING=("+charstr(basering)+"),("+varstr(basering)+"),(wp("+string(whomog)+"));");
-  // map i to the new ring and compute a GB of i, then dehomogenise i, 
-  // so that we can be sure, that the 
+  // map i to the new ring and compute a GB of i, then dehomogenise i,
+  // so that we can be sure, that the
   // initial forms of the generators generate the initial ideal
   ideal i=subst(groebner(imap(HOMOGRING,i)),@s,1);
@@ -2538 +2538 @@
 proc texDrawBasic (list texdraw)
 "USAGE:      texDrawBasic(texdraw); list texdraw
-ASSUME:      texdraw is a list of strings representing texdraw commands 
-             (as produced by texDrawTropical) which should be embedded into 
+ASSUME:      texdraw is a list of strings representing texdraw commands
+             (as produced by texDrawTropical) which should be embedded into
              a texdraw environment
 RETURN:      string, a texdraw environment enclosing the input
@@ -2559 +2559 @@
     \\end{texdraw}";
   return(texdrawtp);
-}  
+}
 example
 {
@@ -2576 +2576 @@
 ASSUME:  graph is the output of tropicalCurve
 RETURN:  string, the texdraw code of the tropical plane curve encoded by graph
-NOTE:    - if the list # is non-empty, the first entry should be a string; 
-           if this string is 'max', then the tropical curve is considered 
-           with respect to the maximum; otherwise the curve is considered 
-           with respect to the minimum and the string can be used to insert 
+NOTE:    - if the list # is non-empty, the first entry should be a string;
+           if this string is 'max', then the tropical curve is considered
+           with respect to the maximum; otherwise the curve is considered
+           with respect to the minimum and the string can be used to insert
            further texdraw commands (e.g. to have a lighter image as when called
-           from inside conicWithTangents); 
-@*       - the procedure computes a scalefactor for the texdraw command which 
-           should help to display the curve in the right way; this may, 
-           however, be a bad idea if several texDrawTropical outputs are 
-           put together to form one image; the scalefactor can be prescribed 
+           from inside conicWithTangents);
+@*       - the procedure computes a scalefactor for the texdraw command which
+           should help to display the curve in the right way; this may,
+           however, be a bad idea if several texDrawTropical outputs are
+           put together to form one image; the scalefactor can be prescribed
            by a second optional entry of type poly
 @*       - the list # is optional and may as well be empty
@@ -2591 +2591 @@
 {
   int i,j;
-  // deal first with the pathological case that 
+  // deal first with the pathological case that
   // the input polynomial was a monomial
-  // and does therefore not define a tropical curve, 
-  // and check if the Newton polytope is 
+  // and does therefore not define a tropical curve,
+  // and check if the Newton polytope is
   // a line segment so that the curve defines a bunch of lines
   int bunchoflines;
   // if the boundary of the Newton polytope consists of a single point
-  if (size(graph[size(graph)][1])==1) 
+  if (size(graph[size(graph)][1])==1)
   {
     return(string());
@@ -2611 +2611 @@
     }
     // then the Newton polytope is a line segment
-    if ((size(graph[size(graph)][1])-size(syz(M)))==1) 
+    if ((size(graph[size(graph)][1])-size(syz(M)))==1)
     {
       bunchoflines=1;
@@ -2618 +2618 @@
   // go on with the case that a tropical curve is defined
   if (size(#)==0)
-  {    
+  {
      string texdrawtp="
 
@@ -2626 +2626 @@
   {
     if ((#[1]!="max") and (#[1]!=""))
-    {      
+    {
       string texdrawtp=#[1];
     }
@@ -2674 +2674 @@
         nachkomma++;
       }
-    }    
-    // if the scalefactor is < 1/100, then we should rather scale the 
+    }
+    // if the scalefactor is < 1/100, then we should rather scale the
     // coordinates directly, since otherwise texdraw gets into trouble
     if (nachkomma > 2)
@@ -2684 +2684 @@
         sf=sf*10;
       }
-    }    
+    }
     texdrawtp=texdrawtp+"
        \\relunitscale "+ decimal(scalefactor,nachkomma);
@@ -2697 +2697 @@
   {
     // if the curve is a bunch of lines no vertex has to be drawn
-    if (bunchoflines==0) 
+    if (bunchoflines==0)
     {
       texdrawtp=texdrawtp+"
@@ -2703 +2703 @@
     }
     // draw the bounded edges emerging from the ith vertex
-    for (j=1;j<=ncols(graph[i][3]);j++) 
-    {
-      // don't draw it twice - and if there is only one vertex 
+    for (j=1;j<=ncols(graph[i][3]);j++)
+    {
+      // don't draw it twice - and if there is only one vertex
       //                       and graph[i][3][1,1] is thus 0, nothing is done
-      if (i<graph[i][3][1,j]) 
-      {                       
+      if (i<graph[i][3][1,j])
+      {
         texdrawtp=texdrawtp+"
        \\move ("+decimal((graph[i][1]-centerx)/sf)+" "+decimal((graph[i][2]-centery)/sf)+") \\lvec ("+decimal((graph[graph[i][3][1,j]][1]-centerx)/sf)+" "+decimal((graph[graph[i][3][1,j]][2]-centery)/sf)+")";
         // if the multiplicity is more than one, denote it in the picture
-        if (graph[i][3][2,j]>1) 
+        if (graph[i][3][2,j]>1)
         {
           texdrawtp=texdrawtp+"
@@ -2721 +2721 @@
     // draw the unbounded edges emerging from the ith vertex
     // they should not be too long
-    for (j=1;j<=size(graph[i][4]);j++) 
-    {      
+    for (j=1;j<=size(graph[i][4]);j++)
+    {
       relxy=shorten(list(decimal((3*graph[i][4][j][1][1]/scalefactor)*sf),decimal((3*graph[i][4][j][1][2]/scalefactor)*sf),string(5*sf/2)));
       texdrawtp=texdrawtp+"
        \\move ("+decimal((graph[i][1]-centerx)/sf)+" "+decimal((graph[i][2]-centery)/sf)+") \\rlvec ("+relxy[1]+" "+relxy[2]+")";
       // if the multiplicity is more than one, denote it in the picture
-      if (graph[i][4][j][2]>1) 
+      if (graph[i][4][j][2]>1)
       {
         texdrawtp=texdrawtp+"
@@ -2805 +2805 @@
   poly scalefactor=minOfPolys(list(12/leadcoef(maxx),12/leadcoef(maxy)));
   if (scalefactor<1)
-  {    
+  {
     subdivision=subdivision+"
        \\relunitscale"+ decimal(scalefactor);
@@ -2813 +2813 @@
   {
     subdivision=subdivision+"
-        \\move ("+string(boundary[i][1])+" "+string(boundary[i][2])+")        
+        \\move ("+string(boundary[i][1])+" "+string(boundary[i][2])+")
         \\lvec ("+string(boundary[i+1][1])+" "+string(boundary[i+1][2])+")";
-  } 
+  }
   subdivision=subdivision+"
-        \\move ("+string(boundary[size(boundary)][1])+" "+string(boundary[size(boundary)][2])+")        
+        \\move ("+string(boundary[size(boundary)][1])+" "+string(boundary[size(boundary)][2])+")
         \\lvec ("+string(boundary[1][1])+" "+string(boundary[1][2])+")
 
@@ -2824 +2824 @@
   {
     subdivision=subdivision+"
-        \\move ("+string(inneredges[i][1][1])+" "+string(inneredges[i][1][2])+")        
+        \\move ("+string(inneredges[i][1][1])+" "+string(inneredges[i][1][2])+")
         \\lvec ("+string(inneredges[i][2][1])+" "+string(inneredges[i][2][2])+")";
   }
@@ -2844 +2844 @@
     }
   }
-  // deal with the pathological cases 
+  // deal with the pathological cases
   if (size(boundary)==1) // then the Newton polytope is a point
   {
@@ -2899 +2899 @@
   {
     subdivision=subdivision+"
-       \\move ("+string(markings[i][1])+" "+string(markings[i][2])+") 
+       \\move ("+string(markings[i][1])+" "+string(markings[i][2])+")
        \\fcir f:0 r:"+decimal(2/(8*scalefactor),size(string(int(scalefactor)))+1);
   }
   // enclose subdivision in the texdraw environment
-  string texsubdivision="     
+  string texsubdivision="
     \\begin{texdraw}
-       \\drawdim cm  \\relunitscale 1 
+       \\drawdim cm  \\relunitscale 1
        \\linewd 0.05"
     +subdivision+"
@@ -2919 +2919 @@
    poly f=x+y+x2y+xy2+1/t*xy;
    list graph=tropicalCurve(f);
-// compute the texdraw code of the Newton subdivision of the tropical curve 
+// compute the texdraw code of the Newton subdivision of the tropical curve
    texDrawNewtonSubdivision(graph);
 }
@@ -2927 +2927 @@
 proc texDrawTriangulation (list triang,list polygon)
 "USAGE:      texDrawTriangulation(triang,polygon);  triang,polygon list
-ASSUME:      polygon is a list of integer vectors describing the 
+ASSUME:      polygon is a list of integer vectors describing the
              lattice points of a marked polygon;
-             triang is a list of integer vectors describing a 
+             triang is a list of integer vectors describing a
              triangulation of the marked polygon
-             in the sense that an integer vector of the form (i,j,k) describes 
+             in the sense that an integer vector of the form (i,j,k) describes
              the triangle formed by polygon[i], polygon[j] and polygon[k]
-RETURN:      string, a texdraw code for the triangulation described 
+RETURN:      string, a texdraw code for the triangulation described
                      by triang without the texdraw environment
 EXAMPLE:     example texDrawTriangulation;   shows an example"
@@ -2942 +2942 @@
    ";
   int i,j; // indices
-  list pairs,markings; // stores edges of the triangulation, respecively 
-  // the marked points for each triangle store the edges and marked 
+  list pairs,markings; // stores edges of the triangulation, respecively
+  // the marked points for each triangle store the edges and marked
   // points of the triangle
   for (i=1;i<=size(triang);i++)
@@ -2952 +2952 @@
     markings[3*i-2]=triang[i][1];
     markings[3*i-1]=triang[i][2];
-    markings[3*i]=triang[i][3];    
+    markings[3*i]=triang[i][3];
   }
   // delete redundant pairs which occur more than once
@@ -2985 +2985 @@
   {
     latex=latex+"
-        \\move ("+string(polygon[markings[i]][1])+" "+string(polygon[markings[i]][2])+")        
+        \\move ("+string(polygon[markings[i]][1])+" "+string(polygon[markings[i]][2])+")
         \\fcir f:0 r:0.08";
   }
@@ -2992 +2992 @@
   {
     latex=latex+"
-        \\move ("+string(polygon[pairs[i][1]][1])+" "+string(polygon[pairs[i][1]][2])+")        
+        \\move ("+string(polygon[pairs[i][1]][1])+" "+string(polygon[pairs[i][1]][2])+")
         \\lvec ("+string(polygon[pairs[i][2]][1])+" "+string(polygon[pairs[i][2]][2])+")";
   }
@@ -2999 +2999 @@
   {
     latex=latex+"
-        \\move ("+string(polygon[i][1])+" "+string(polygon[i][2])+")        
+        \\move ("+string(polygon[i][1])+" "+string(polygon[i][2])+")
         \\fcir f:0.7 r:0.04";
   }
@@ -3008 +3008 @@
    "EXAMPLE:";
    echo=2;
-   // the lattice polygon spanned by the points (0,0), (3,0) and (0,3) 
+   // the lattice polygon spanned by the points (0,0), (3,0) and (0,3)
    // with all integer points as markings
    list polygon=intvec(1,1),intvec(3,0),intvec(2,0),intvec(1,0),intvec(0,0),
                 intvec(2,1),intvec(0,1),intvec(1,2),intvec(0,2),intvec(0,3);
-   // define a triangulation by connecting the only interior point 
+   // define a triangulation by connecting the only interior point
    //        with the vertices
    list triang=intvec(1,2,5),intvec(1,5,10),intvec(1,2,10);
@@ -3020 +3020 @@
 
 ///////////////////////////////////////////////////////////////////////////////
-/// Auxilary Procedures 
+/// Auxilary Procedures
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -3026 +3026 @@
 "USAGE:  radicalMemberShip (f,i); f poly, i ideal
 RETURN:  int, 1 if f is in the radical of i, 0 else
-EXAMPLE:     example radicalMemberShip;   shows an example" 
+EXAMPLE:     example radicalMemberShip;   shows an example"
 {
   def BASERING=basering;
@@ -3066 +3066 @@
 {
   // compute first the t-order of the leading coefficient of f (leitkoef[1]) and
-  // the rational constant corresponding to this order in leadkoef(f) 
+  // the rational constant corresponding to this order in leadkoef(f)
   // (leitkoef[2])
   list leitkoef=simplifyToOrder(f);
@@ -3076 +3076 @@
   // do the same for the remaining part of f and compare the results
   // keep only the smallest ones
-  int vglgewicht;  
-  f=f-lead(f);  
+  int vglgewicht;
+  f=f-lead(f);
   while (f!=0)
   {
-    leitkoef=simplifyToOrder(f);    
+    leitkoef=simplifyToOrder(f);
     vglgewicht=leitkoef[1]+scalarproduct(w,leadexp(f));
     if (vglgewicht<gewicht)
@@ -3095 +3095 @@
         initialf=initialf+koef*leadmonom(f);
       }
-    }    
+    }
     f=f-lead(f);
   }
@@ -3120 +3120 @@
 {
   // compute first the t-order of the leading coefficient of f (leitkoef[1]) and
-  // the rational constant corresponding to this order in leadkoef(f) 
+  // the rational constant corresponding to this order in leadkoef(f)
   // (leitkoef[2])
-  list leitkoef=simplifyToOrder(f);  
+  list leitkoef=simplifyToOrder(f);
   execute("poly koef="+leitkoef[2]+";");
   // take in lead(f) only the term of lowest t-order and set t=1
@@ -3131 +3131 @@
   // keep only the largest ones
   int vglgewicht;
-  f=f-lead(f);  
+  f=f-lead(f);
   while (f!=0)
   {
@@ -3149 +3149 @@
         initialf=initialf+koef*leadmonom(f);
       }
-    }    
+    }
     f=f-lead(f);
   }
@@ -3168 +3168 @@
 proc solveTInitialFormPar (ideal i)
 "USAGE:      solveTInitialFormPar(i); i ideal
-ASSUME:      i is a zero-dimensional ideal in Q(t)[x_1,...,x_n] generated 
-             by the (1,w)-homogeneous elements for some integer vector w 
+ASSUME:      i is a zero-dimensional ideal in Q(t)[x_1,...,x_n] generated
+             by the (1,w)-homogeneous elements for some integer vector w
              - i.e. by the (1,w)-initialforms of polynomials
 RETURN:      none
-NOTE:        the procedure just displays complex approximations 
+NOTE:        the procedure just displays complex approximations
              of the solution set of i
 EXAMPLE:     example solveTInitialFormPar;   shows an example"
@@ -3197 +3197 @@
 /////////////////////////////////////////////////////////////////////////
 
-proc detropicalise (poly p) 
+proc detropicalise (poly p)
 "USAGE:   detropicalise(f); f poly
 ASSUME:   f is a linear polynomial with an arbitrary constant term and
           positive integer coefficients as further coefficients;
 RETURN:   poly, the detropicalisation of (the non-constant part of) f
-NOTE:     the output will be a monomial and the constant coefficient 
+NOTE:     the output will be a monomial and the constant coefficient
           has been ignored
 EXAMPLE:  example detropicalise;   shows an example"
@@ -3210 +3210 @@
   {
     if (leadmonom(p)!=1)
-    { 
+    {
       dtp=dtp*leadmonom(p)^int(leadcoef(p));
     }
@@ -3263 +3263 @@
 proc parameterSubstitute (poly f,int N)
 "USAGE:   parameterSubstitute(f,N); f poly, N int
-ASSUME:   f is a polynomial in Q(t)[x_1,...,x_n] describing 
+ASSUME:   f is a polynomial in Q(t)[x_1,...,x_n] describing
           a plane curve over Q(t)
 RETURN:   poly f with t replaced by t^N
@@ -3317 +3317 @@
    poly f=t2x+1/t*y-1;
    tropicalSubst(f,2,x,x+t,y,tx+y+t2);
-   // The procedure can be used to study the effect of a transformation of 
+   // The procedure can be used to study the effect of a transformation of
    // the form x -> x+t^b, with b a rational number, on the tropicalisation and
    // the j-invariant of a cubic over the Puiseux series.
    f=t7*y3+t3*y2+t*(x3+xy2+y+1)+xy;
-   // - the j-invariant, and hence its valuation, 
+   // - the j-invariant, and hence its valuation,
    //   does not change under the transformation
    jInvariant(f,"ord");
-   // - b=3/2, then the cycle length of the tropical cubic equals -val(j-inv)   
-   list g32=tropicalSubst(f,2,x,x+t3,y,y);  
+   // - b=3/2, then the cycle length of the tropical cubic equals -val(j-inv)
+   list g32=tropicalSubst(f,2,x,x+t3,y,y);
    tropicalJInvariant(g32);
    // - b=1, then it is still true, but only just ...
@@ -3338 +3338 @@
 
 proc randomPoly (int d,int ug, int og, list #)
-"USAGE:      randomPoly(d,ug,og[,#]);   d, ug, og int, # list 
+"USAGE:      randomPoly(d,ug,og[,#]);   d, ug, og int, # list
 ASSUME:      the basering has a parameter t
-RETURN:      poly, a polynomial of degree d where the coefficients are 
+RETURN:      poly, a polynomial of degree d where the coefficients are
                    of the form t^j with j a random integer between ug and og
-NOTE:        if an optional argument # is given, then the coefficients are 
-             instead either of the form t^j as above or they are zero, 
+NOTE:        if an optional argument # is given, then the coefficients are
+             instead either of the form t^j as above or they are zero,
              and this is chosen randomly
 EXAMPLE:     example randomPoly;   shows an example"
@@ -3359 +3359 @@
   {
     if (size(#)!=0)
-    {      
+    {
       k=random(0,1);
     }
     if (k==0)
-    {      
+    {
       j=random(ug,og);
       randomPolynomial=randomPolynomial+t^j*m[i];
@@ -3393 +3393 @@
 RETURN:  none"
 {
-  system("sh","cd /tmp; /bin/rm -f tropicalcurve*; /bin/rm -f tropicalnewtonsubdivision*");  
+  system("sh","cd /tmp; /bin/rm -f tropicalcurve*; /bin/rm -f tropicalnewtonsubdivision*");
 }
 
@@ -3450 +3450 @@
 static proc cutdown (ideal jideal,intvec wvec,int dimension,list #)
 "USAGE:      cutdown(i,w,d); i ideal, w intvec, d int, # list
-ASSUME:      i an ideal in Q[t,x_1,...,x_n], (w_1,...,w_n) is in the tropical 
-             variety of jideal and d=dim(i)>0, in Q(t)[x]; the optional 
-             parameter # can contain the string 'isPrime' to indicate that 
-             the input ideal is prime and no minimal associated primes have 
+ASSUME:      i an ideal in Q[t,x_1,...,x_n], (w_1,...,w_n) is in the tropical
+             variety of jideal and d=dim(i)>0, in Q(t)[x]; the optional
+             parameter # can contain the string 'isPrime' to indicate that
+             the input ideal is prime and no minimal associated primes have
              to be computed
-RETURN:      list, the first entry is a ring, namely the basering where some 
-                   variables have been eliminated, and the ring contains 
+RETURN:      list, the first entry is a ring, namely the basering where some
+                   variables have been eliminated, and the ring contains
                    the ideal i (with the same variables eliminated),
-                   the t-initial ideal ini of i (w.r.t. the weight vector 
-                   where the entries corresponding to the deleted variables 
-                   have been eliminated) and a list repl where for each 
+                   the t-initial ideal ini of i (w.r.t. the weight vector
+                   where the entries corresponding to the deleted variables
+                   have been eliminated) and a list repl where for each
                    eliminated variable there is one entry, namely a polynomial
-                   in the remaining variables and t that explains how 
-                   resubstitution of a solution for the new i gives a solution 
+                   in the remaining variables and t that explains how
+                   resubstitution of a solution for the new i gives a solution
                    for the old i; the second entry is the weight vector
-                   wvec with the components corresponding to the eliminated 
+                   wvec with the components corresponding to the eliminated
                    variables removed
-NOTE:        needs the libraries random.lib and primdec.lib; 
+NOTE:        needs the libraries random.lib and primdec.lib;
              is called from tropicalLifting"
-{ 
-  // IDEA: i is an ideal of dimension d; we want to cut it with d random linear 
+{
+  // IDEA: i is an ideal of dimension d; we want to cut it with d random linear
   //       forms in such a way that the resulting
   //       ideal is 0-dim and still contains w in the tropical variety
-  // NOTE: t is the last variable in the basering  
+  // NOTE: t is the last variable in the basering
   ideal pideal;  //this is the ideal we want to return
   ideal cutideal;
@@ -3491 +3491 @@
   for (j1=1;j1<=nvars(basering)-1;j1++)
   {
-    variablen=variablen+var(j1); // read the set of variables 
+    variablen=variablen+var(j1); // read the set of variables
                                  // (needed to make the quotring later)
-    product=product*var(j1); // make product of all variables 
+    product=product*var(j1); // make product of all variables
                              // (needed for the initial-monomial-check later
-  }    
+  }
   execute("ring QUOTRING=("+charstr(basering)+",t),("+string(variablen)+"),dp;");
   setring BASERING;
@@ -3502 +3502 @@
   {
     setring QUOTRING;
-    ideal jideal=imap(BASERING,jideal); 
-    list primp=minAssGTZ(jideal); //compute the primary decomposition  
+    ideal jideal=imap(BASERING,jideal);
+    list primp=minAssGTZ(jideal); //compute the primary decomposition
     for (j1=1;j1<=size(primp);j1++)
-    {      
+    {
       for(j2=1;j2<=size(primp[j1]);j2++)
       {
         // clear all denominators
         primp[j1][j2]=primp[j1][j2]/content(primp[j1][j2]);
-      }       
+      }
     }
     setring BASERING;
     list primp=imap(QUOTRING,primp);
     // if i is not primary itself
-    // go through the list of min. ass. primes and find the first 
+    // go through the list of min. ass. primes and find the first
     // one which has w in its tropical variety
-    if (size(primp)>1) 
+    if (size(primp)>1)
     {
       j1=1;
@@ -3524 +3524 @@
         //compute the t-initial of the associated prime
         // - the last entry 1 only means that t is the last variable in the ring
-        primini=tInitialIdeal(primp[j1],wvec,1); 
-        // check if it contains a monomial (resp if the product of var 
+        primini=tInitialIdeal(primp[j1],wvec,1);
+        // check if it contains a monomial (resp if the product of var
         // is in the radical)
-        if (radicalMemberShip(product,primini)==0) 
-        { 
+        if (radicalMemberShip(product,primini)==0)
+        {
           // if w is in the tropical variety of the prime, we take that
           jideal=primp[j1];
@@ -3535 +3535 @@
           setring BASERING;
           winprim=1; // and stop the checking
-        } 
+        }
         j1=j1+1;  //else we look at the next associated prime
       }
@@ -3542 +3542 @@
     {
       jideal=primp[1]; //if i is primary itself we take its prime instead
-    }  
+    }
   }
   // now we start as a first try to intersect with a hyperplane parallel to
   // coordinate axes, because this would make our further computations
-  // a lot easier. 
-  // We choose a subset of our n variables of size d=dim(ideal). 
+  // a lot easier.
+  // We choose a subset of our n variables of size d=dim(ideal).
   // For each of these
-  // variables, we want to fix a value: x_i= a_i*t^-w_i. 
+  // variables, we want to fix a value: x_i= a_i*t^-w_i.
   // This will only work if the
-  // projection of the d-dim variety to the other n-d variables 
+  // projection of the d-dim variety to the other n-d variables
   // is the whole n-d plane.
-  // Then a general choice for a_i will intersect the variety 
+  // Then a general choice for a_i will intersect the variety
   // in finitely many points.
-  // If the projection is not the whole n-d plane, 
+  // If the projection is not the whole n-d plane,
   // then a general choice will not work.
-  // We could determine if we picked a good 
+  // We could determine if we picked a good
   // d-subset of variables using elimination
-  // (NOTE, there EXIST d variables such that 
+  // (NOTE, there EXIST d variables such that
   // a random choice of a_i's would work!).
-  // But since this involves many computations, 
+  // But since this involves many computations,
   // we prefer to choose randomly and just
-  // try in the end if our intersected ideal 
-  // satisfies our requirements. If this does not 
+  // try in the end if our intersected ideal
+  // satisfies our requirements. If this does not
   // work, we give up this try and use our second intersection idea, which
   // will work for a Zariksi-open subset (i.e. almost always).
   //
-  // As random subset of d variables we choose 
+  // As random subset of d variables we choose
   // those for which the absolute value of the
-  // wvec-coordinate is smallest, because this will 
+  // wvec-coordinate is smallest, because this will
   // give us the smallest powers of t and hence
-  // less effort in following computations. 
+  // less effort in following computations.
   // Note that the smallest absolute value have those
-  // which are biggest, because wvec is negative. 
+  // which are biggest, because wvec is negative.
   //print("first try");
   intvec wminust=intvecdelete(wvec,1);
@@ -3581 +3581 @@
   A[1,1..size(wminust)]=-wminust;
   A[2,1..size(wminust)]=1..size(wminust);
-  // sort this matrix in order to get 
+  // sort this matrix in order to get
   // the d biggest entries and their position in wvec
-  A=sortintmat(A); 
-  // we construct a vector which has 1 at entry j if j belongs to the list 
+  A=sortintmat(A);
+  // we construct a vector which has 1 at entry j if j belongs to the list
   // of the d biggest entries of wvec and a 0 else
   for (j1=1;j1<=nvars(basering)-1;j1++) //go through the variables
@@ -3593 +3593 @@
       {
         setvec[j1]=1;//put a 1
-      }        
-    }  
-  }
-  // using this 0/1-vector we produce 
-  // a random constant (i.e. coeff in Q times something in t) 
-  // for each of the biggest variables, 
+      }
+    }
+  }
+  // using this 0/1-vector we produce
+  // a random constant (i.e. coeff in Q times something in t)
+  // for each of the biggest variables,
   // we add the forms x_i-random constant to the ideal
-  // and we save the constant at the i-th place of 
+  // and we save the constant at the i-th place of
   // a list we want to return for later computations
   j3=0;
@@ -3611 +3611 @@
     {
       if(setvec[j1]==1)//if x_i belongs to the biggest variables
-      {     
+      {
         if ((j3==1) and ((char(basering)==0) or (char(basering)>3)))
-        {        
+        {
           randomp1=random(1,3);
-          randomp=t^(A[1,j2])*randomp1;// make a random constant 
+          randomp=t^(A[1,j2])*randomp1;// make a random constant
                                        // --- first we try small numbers
-        }   
+        }
         if ((j3==2) and ((char(basering)==0) or (char(basering)>100)))
         {
           randomp1=random(1,100);
-          randomp=t^(A[1,j2])*randomp1;// make a random constant 
+          randomp=t^(A[1,j2])*randomp1;// make a random constant
                                        // --- next we try bigger numbers
-        }   
+        }
         else
         {
@@ -3635 +3635 @@
       else
       {
-        ergl[j1]=0; //if the variable is not among the d biggest ones, 
+        ergl[j1]=0; //if the variable is not among the d biggest ones,
                     //save 0 in the list
         erglini[j1]=0;
-      }        
+      }
     }
       // print(ergl);print(pideal);
-      // now we check if we made a good choice of pideal, i.e. if dim=0 and 
+      // now we check if we made a good choice of pideal, i.e. if dim=0 and
       // wvec is still in the tropical variety
       // change to quotring where we compute dimension
@@ -3648 +3648 @@
     {
       if(setvec[j1]==1)
-      {      
-        cutideal=cutideal,var(j1)-ergl[j1];//add all forms to the ideal  
-      }      
+      {
+        cutideal=cutideal,var(j1)-ergl[j1];//add all forms to the ideal
+      }
     }
     setring QUOTRING;
@@ -3662 +3662 @@
     {
       // compute the t-initial of the associated prime
-      // - the last 1 just means that the variable t is 
+      // - the last 1 just means that the variable t is
       //   the last variable in the ring
       pini=tInitialIdeal(cutideal,wvec ,1);
       //print("initial");
       //print(pini);
-      // and if the initial w.r.t. t contains no monomial 
+      // and if the initial w.r.t. t contains no monomial
       // as we want (checked with
       // radical-membership of the product of all variables)
-      if (radicalMemberShip(product,pini)==0) 
-      {
-        // we made the right choice and now 
-        // we substitute the variables in the ideal    
+      if (radicalMemberShip(product,pini)==0)
+      {
+        // we made the right choice and now
+        // we substitute the variables in the ideal
         // to get an ideal in less variables
-        // also we make a projected vector 
+        // also we make a projected vector
         // from wvec only the components of the remaining variables
         wvecp=wvec;
-        variablen=0;   
+        variablen=0;
         j2=0;
         for(j1=1;j1<=nvars(basering)-1;j1++)
@@ -3691 +3691 @@
           else
           {
-            variablen=variablen+var(j1); // read the set of remaining variables 
+            variablen=variablen+var(j1); // read the set of remaining variables
                                          // (needed to make quotring later)
-          }    
-        }      
+          }
+        }
         // return pideal, the initial and the list ergl which tells us
         // which variables we replaced by which form
@@ -3704 +3704 @@
         export(ini);
         export(repl);
-        return(list(BASERINGLESS1,wvecp)); 
+        return(list(BASERINGLESS1,wvecp));
       }
     }
   }
   // this is our second try to cut down, which we only use if the first try
-  // didn't work out. We intersect with d general hyperplanes 
+  // didn't work out. We intersect with d general hyperplanes
   // (i.e. we don't choose
   // them to be parallel to coordinate hyperplanes anymore. This works out with
   // probability 1.
   //
-  // We choose general hyperplanes, i.e. linear forms which involve all x_i. 
-  // Each x_i has to be multiplied bz t^(w_i) in order 
-  // to get the same weight (namely 0) 
+  // We choose general hyperplanes, i.e. linear forms which involve all x_i.
+  // Each x_i has to be multiplied bz t^(w_i) in order
+  // to get the same weight (namely 0)
   // for each term. As we cannot have negative exponents, we multiply
-  // the whole form by t^minimumw. Notice that then in the first form, 
+  // the whole form by t^minimumw. Notice that then in the first form,
   // there is one term without t- the term of the variable
   // x_i such that w_i is minimal. That is, we can solve for this variable.
-  // In the second form, we can replace that variable, 
-  // and divide by t as much as possible. 
-  // Then there is again one term wihtout t - 
-  // the term of the variable with second least w. 
+  // In the second form, we can replace that variable,
+  // and divide by t as much as possible.
+  // Then there is again one term wihtout t -
+  // the term of the variable with second least w.
   // So we can solve for this one again and also replace it in the first form.
-  // Since all our coefficients are chosen randomly, 
-  // we can also from the beginning on 
-  // choose the set of variables which belong to the d smallest entries of wvec 
-  // (t not counting) and pick random forms g_i(t,x') 
-  // (where x' is the set of remaining variables) 
-  // and set x_i=g_i(t,x'). 
+  // Since all our coefficients are chosen randomly,
+  // we can also from the beginning on
+  // choose the set of variables which belong to the d smallest entries of wvec
+  // (t not counting) and pick random forms g_i(t,x')
+  // (where x' is the set of remaining variables)
+  // and set x_i=g_i(t,x').
   //
   // make a matrix with first row wvec (without t) and second row 1..n
   //print("second try");
   setring BASERING;
-  A[1,1..size(wminust)]=wminust;  
+  A[1,1..size(wminust)]=wminust;
   A[2,1..size(wminust)]=1..size(wminust);
-  // sort this matrix in otder to get the d smallest entries 
+  // sort this matrix in otder to get the d smallest entries
   // (without counting the t-entry)
   A=sortintmat(A);
@@ -3744 +3744 @@
   setvec=0;
   setvec[nvars(basering)-1]=0;
-  // we construct a vector which has 1 at entry j if j belongs to the list of 
+  // we construct a vector which has 1 at entry j if j belongs to the list of
   // the d smallest entries of wvec and a 0 else
   for (j1=1;j1<=nvars(basering)-1;j1++) //go through the variables
@@ -3764 +3764 @@
     {
       j2=j2+1;
-      wvecp=intvecdelete(wvecp,j1+2-j2);// delete the components 
+      wvecp=intvecdelete(wvecp,j1+2-j2);// delete the components
                                         // we substitute from wvec
     }
     else
     {
-      variablen=variablen+var(j1); // read the set of remaining variables 
+      variablen=variablen+var(j1); // read the set of remaining variables
                                    // (needed to make the quotring later)
     }
-  } 
+  }
   setring BASERING;
   execute("ring BASERINGLESS2=("+charstr(BASERING)+"),("+string(variablen)+",t),(dp("+string(ncols(variablen))+"),lp(1));");
-  // using the 0/1-vector which tells us which variables belong 
+  // using the 0/1-vector which tells us which variables belong
   // to the set of smallest entries of wvec
-  // we construct a set of d random linear 
-  // polynomials of the form x_i=g_i(t,x'), 
+  // we construct a set of d random linear
+  // polynomials of the form x_i=g_i(t,x'),
   // where the set of all x_i is the set of
-  // all variables which are in the list of smallest 
+  // all variables which are in the list of smallest
   // entries in wvec, and x' are the other variables.
-  // We add these d random linear polynomials to 
-  // the ideal pideal, i.e. we intersect 
+  // We add these d random linear polynomials to
+  // the ideal pideal, i.e. we intersect
   // with these and hope to get something
-  // 0-dim which still contains wvec in its 
-  // tropical variety. Also, we produce a list ergl  
+  // 0-dim which still contains wvec in its
+  // tropical variety. Also, we produce a list ergl
   // with g_i at the i-th position.
   // This is a list we want to return.
@@ -3792 +3792 @@
   setring BASERING;
   pideal=jideal;
-  for(j1=1;j1<=dimension;j1++)//go through the list of variables 
+  for(j1=1;j1<=dimension;j1++)//go through the list of variables
   { // corres to the d smallest in wvec
     if ((char(basering)==0) or (char(basering)>3))
-    { 
+    {
       randomp1=random(1,3);
       randomp=randomp1*t^(-A[1,j1]);
@@ -3808 +3808 @@
       if(setvec[j2]==0)//if x_j belongs to the set x'
       {
-        // add a random term with the suitable power 
+        // add a random term with the suitable power
         // of t to the random linear form
         if ((char(basering)==0) or (char(basering)>3))
@@ -3833 +3833 @@
     }
   //print(ergl);
-  // Again, we have to test if we made a good choice 
-  // to intersect,i.e. we have to check whether 
+  // Again, we have to test if we made a good choice
+  // to intersect,i.e. we have to check whether
   // pideal is 0-dim and contains wvec in the tropical variety.
   cutideal=pideal;
@@ -3841 +3841 @@
     if(setvec[j1]==1)
     {
-      cutideal=cutideal,var(j1)-ergl[j1];//add all forms to the ideal 
-    }    
+      cutideal=cutideal,var(j1)-ergl[j1];//add all forms to the ideal
+    }
   }
   setring QUOTRING;
@@ -3854 +3854 @@
   {
     // compute the t-initial of the associated prime
-    // - the last 1 just means that the variable t 
+    // - the last 1 just means that the variable t
     // is the last variable in the ring
     pini=tInitialIdeal(cutideal,wvec ,1);
@@ -3861 +3861 @@
     // and if the initial w.r.t. t contains no monomial as we want (checked with
     // radical-membership of the product of all variables)
-    if (radicalMemberShip(product,pini)==0) 
+    if (radicalMemberShip(product,pini)==0)
     {
       // we want to replace the variables x_i by the forms -g_i in
-      // our ideal in order to return an ideal with less variables  
+      // our ideal in order to return an ideal with less variables
       // first we substitute the chosen variables
       for(j1=1;j1<=nvars(basering)-1;j1++)
@@ -3881 +3881 @@
       export(ini);
       export(repl);
-      return(list(BASERINGLESS2,wvecp)); 
+      return(list(BASERINGLESS2,wvecp));
     }
   }
   // now we try bigger numbers
-  while (1) //a never-ending loop which will stop with prob. 1 
+  while (1) //a never-ending loop which will stop with prob. 1
   { // as we find a suitable ideal with that prob
     setring BASERING;
     pideal=jideal;
-    for(j1=1;j1<=dimension;j1++)//go through the list of variables 
+    for(j1=1;j1<=dimension;j1++)//go through the list of variables
     { // corres to the d smallest in wvec
       randomp1=random(1,100);
       randomp=randomp1*t^(-A[1,j1]);
       for(j2=1;j2<=nvars(basering)-1;j2++)//go through all variables
-      { 
+      {
         if(setvec[j2]==0)//if x_j belongs to the set x'
         {
-          // add a random term with the suitable power 
+          // add a random term with the suitable power
           // of t to the random linear form
           if ((char(basering)==0) or (char(basering)>100))
-          {  
+          {
             randomp2=random(1,100);
             randomp1=randomp1+randomp2*var(j2);
@@ -3921 +3921 @@
       }
     //print(ergl);
-    // Again, we have to test if we made a good choice to 
-    // intersect,i.e. we have to check whether 
+    // Again, we have to test if we made a good choice to
+    // intersect,i.e. we have to check whether
     // pideal is 0-dim and contains wvec in the tropical variety.
     cutideal=pideal;
@@ -3929 +3929 @@
       if(setvec[j1]==1)
       {
-        cutideal=cutideal,var(j1)-ergl[j1];//add all forms to the ideal  
-      }      
+        cutideal=cutideal,var(j1)-ergl[j1];//add all forms to the ideal
+      }
     }
     setring QUOTRING;
@@ -3938 +3938 @@
     //print(dimp);
     kill cutideal;
-    setring BASERING; 
+    setring BASERING;
     if (dimp==0) // if it is 0 as we want
     {
       // compute the t-initial of the associated prime
-      // - the last 1 just means that the variable t 
+      // - the last 1 just means that the variable t
       // is the last variable in the ring
       pini=tInitialIdeal(cutideal,wvec ,1);
       //print("initial");
       //print(pini);
-      // and if the initial w.r.t. t contains no monomial 
+      // and if the initial w.r.t. t contains no monomial
       // as we want (checked with
       // radical-membership of the product of all variables)
-      if (radicalMemberShip(product,pini)==0) 
+      if (radicalMemberShip(product,pini)==0)
       {
         // we want to replace the variables x_i by the forms -g_i in
@@ -3961 +3961 @@
             pideal=subst(pideal,var(j1),ergl[j1]);//substitute it
             pini=subst(pini,var(j1),erglini[j1]);
-          }   
-        }   
+          }
+        }
         // return pideal and the list ergl which tells us
         // which variables we replaced by which form
@@ -3972 +3972 @@
         export(ini);
         export(repl);
-        return(list(BASERINGLESS2,wvecp)); 
+        return(list(BASERINGLESS2,wvecp));
       }
     }
@@ -3983 +3983 @@
 static proc tropicalparametriseNoabs (ideal i,intvec ww,int ordnung,int gfanold,int nogfan,list #)
 "USAGE:  tropicalparametriseNoabs(i,tw,ord,gf,ng[,#]); i ideal, tw intvec, ord int, gf,ng int, # opt. list
-ASSUME:  - i is an ideal in Q[t,x_1,...,x_n,X_1,...,X_k], 
-           tw=(w_0,w_1,...,w_n,0,...,0) and (w_0,...,w_n,0,...,0) is in 
-           the tropical variety of i, and ord is the order up to which a point 
-           in V(i) over C((t)) lying over w shall be computed; 
+ASSUME:  - i is an ideal in Q[t,x_1,...,x_n,X_1,...,X_k],
+           tw=(w_0,w_1,...,w_n,0,...,0) and (w_0,...,w_n,0,...,0) is in
+           the tropical variety of i, and ord is the order up to which a point
+           in V(i) over C((t)) lying over w shall be computed;
          - moreover, k should be zero if the procedure is not called recursively;
-         - the point in the tropical variety is supposed to lie in the NEGATIVE 
+         - the point in the tropical variety is supposed to lie in the NEGATIVE
            orthant;
-         - the ideal is zero-dimensional when considered 
+         - the ideal is zero-dimensional when considered
            in (Q(t)[X_1,...,X_k]/m)[x_1,...,x_n],
-           where m=#[2] is a maximal ideal in Q(t)[X_1,...,X_k]; 
+           where m=#[2] is a maximal ideal in Q(t)[X_1,...,X_k];
          - gf is 0 if version 2.2 or larger is used and it is 1 else
-         - ng is 1 if gfan should not be executed 
+         - ng is 1 if gfan should not be executed
 RETURN:  list, l[1] = ring Q(0,X_1,...,X_r)[[t]]
                l[2] = int
                l[3] = string
 NOTE:    - the procedure is also called recursively by itself, and
-           if it is called in the first recursion, the list # is empty, 
-           otherwise #[1] is an integer, one more than the number 
+           if it is called in the first recursion, the list # is empty,
+           otherwise #[1] is an integer, one more than the number
            of true variables x_1,...,x_n,
            and #[2] will contain the maximal ideal m in the variables X_1,...X_k
@@ -4006 +4006 @@
            work correctly in K[t,x_1,...,x_n] where K=Q[X_1,...,X_k]/m is a field
            extension of Q;
-         - the ring l[1] contains an ideal PARA, which contains the 
-           parametrisation of a point in V(i) lying over w up to the 
+         - the ring l[1] contains an ideal PARA, which contains the
+           parametrisation of a point in V(i) lying over w up to the
            first ord terms;
-         - the string m=l[3] contains the code of the maximal ideal m, 
-           by which we have to divide Q[X_1,...,X_r] in order to have 
+         - the string m=l[3] contains the code of the maximal ideal m,
+           by which we have to divide Q[X_1,...,X_r] in order to have
            the appropriate field extension over which the parametrisation lives;
-         - and if the integer l[2] is N then t has to be replaced by t^1/N in 
-           the parametrisation, or alternatively replace t by t^N in the 
+         - and if the integer l[2] is N then t has to be replaced by t^1/N in
+           the parametrisation, or alternatively replace t by t^N in the
            defining ideal
-         - the procedure REQUIRES that the program GFAN is installed on 
+         - the procedure REQUIRES that the program GFAN is installed on
            your computer"
 {
@@ -4023 +4023 @@
   if (size(#)==2) // this means the precedure has been called recursively
   {
-    // how many variables are true variables, and how many come 
+    // how many variables are true variables, and how many come
     // from the field extension
     // only true variables have to be transformed
@@ -4029 +4029 @@
     ideal gesamt_m=std(#[2]); // stores all maxideals used for field extensions
     // find the zeros of the w-initial ideal and transform the ideal i;
-    // findzeros and basictransformideal need to know how 
+    // findzeros and basictransformideal need to know how
     // many of the variables are true variables
     list m_ring=findzeros(i,ww,anzahlvariablen);
@@ -4036 +4036 @@
   else // the procedure has been called by tropicalLifting
   {
-    // how many variables are true variables, and how many come from 
+    // how many variables are true variables, and how many come from
     // the field extension only true variables have to be transformed
     int anzahlvariablen=nvars(basering);
@@ -4043 +4043 @@
     ideal ini=#[1];
     // find the zeros of the w-initial ideal and transform the ideal i;
-    // we should hand the t-initial ideal ine to findzeros, 
+    // we should hand the t-initial ideal ine to findzeros,
     // since we know it already
     list m_ring=findzeros(i,ww,ini);
@@ -4065 +4065 @@
     list a=btr[2];
     ideal m=btr[3];
-    gesamt_m=gesamt_m+m; // add the newly found maximal 
+    gesamt_m=gesamt_m+m; // add the newly found maximal
                          // ideal to the previous ones
   }
   // check if there is a solution which has the n-th component zero,
-  // if so, then eliminate the n-th variable from sat(i+x_n,t), 
+  // if so, then eliminate the n-th variable from sat(i+x_n,t),
   // otherwise leave i as it is;
-  // then check if the (remaining) ideal has as solution 
+  // then check if the (remaining) ideal has as solution
   // where the n-1st component is zero,
   // and procede as before; do the same for the remaining variables;
-  // this way we make sure that the remaining ideal has 
+  // this way we make sure that the remaining ideal has
   // a solution which has no component zero;
   intvec deletedvariables;    // the jth entry is set 1, if we eliminate x_j
   int numberdeletedvariables; // the number of eliminated variables
   ideal variablen;  // will contain the variables which are not eliminated
-  intvec tw=ww;     // in case some variables are deleted, 
+  intvec tw=ww;     // in case some variables are deleted,
                     // we have to store the old weight vector
   deletedvariables[anzahlvariablen]=0;
-  ideal I,LI; 
+  ideal I,LI;
   i=i+m; // if a field extension was necessary, then i has to be extended by m
   for (jj=anzahlvariablen-1;jj>=1;jj--)  // the variable t is the last one !!!
@@ -4089 +4089 @@
     LI=subst(I,var(nvars(basering)),0);
     //size(deletedvariables)=anzahlvariablen(before elim.)
-    for (kk=1;kk<=size(deletedvariables)-1;kk++) 
+    for (kk=1;kk<=size(deletedvariables)-1;kk++)
     {
       LI=subst(LI,var(kk),0);
     }
-    if (size(LI)==0) // if no power of t is in lead(I) 
+    if (size(LI)==0) // if no power of t is in lead(I)
     { // (where the X(i) are considered as field elements)
-      // get rid of var(jj)   
+      // get rid of var(jj)
       i=eliminate(I,var(jj));
       deletedvariables[jj]=1;
-      anzahlvariablen--; // if a variable is eliminated, 
+      anzahlvariablen--; // if a variable is eliminated,
                          // then the number of true variables drops
       numberdeletedvariables++;
@@ -4108 +4108 @@
   }
   variablen=invertorder(variablen);
-  // store also the additional variables and t, 
+  // store also the additional variables and t,
   // since they for sure have not been eliminated
   for (jj=anzahlvariablen+numberdeletedvariables-1;jj<=nvars(basering);jj++)
@@ -4114 +4114 @@
     variablen=variablen+var(jj);
   }
-  // if some variables have been eliminated, 
+  // if some variables have been eliminated,
   // then pass to a new ring which has less variables,
   // but if no variables are left, then we are done
   def BASERING=basering;
-  if ((numberdeletedvariables>0) and (anzahlvariablen>1)) // if only t remains, 
+  if ((numberdeletedvariables>0) and (anzahlvariablen>1)) // if only t remains,
   { // all true variables are gone
     execute("ring NEURING=("+charstr(basering)+"),("+string(variablen)+"),(dp("+string(size(variablen)-1)+"),lp(1));");
     ideal i=imap(BASERING,i);
-    ideal gesamt_m=imap(BASERING,gesamt_m);    
-  }
-  // now we have to compute a point ww on the tropical variety 
+    ideal gesamt_m=imap(BASERING,gesamt_m);
+  }
+  // now we have to compute a point ww on the tropical variety
   // of the transformed ideal i;
-  // of course, we only have to do so, if we have not yet 
+  // of course, we only have to do so, if we have not yet
   // reached the order up to which we
   // were supposed to do our computations
-  if ((ordnung>1) and (anzahlvariablen>1)) // if only t remains, 
+  if ((ordnung>1) and (anzahlvariablen>1)) // if only t remains,
   { // all true variables are gone
     def PREGFANRING=basering;
     if (nogfan!=1)
-    {      
+    {
       // pass to a ring which has variables which are suitable for gfan
       execute("ring GFANRING=("+charstr(basering)+"),(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z),dp;");
-      ideal phiideal=b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z; 
+      ideal phiideal=b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z;
       phiideal[nvars(PREGFANRING)]=a; // map t to a
-      map phi=PREGFANRING,phiideal; 
+      map phi=PREGFANRING,phiideal;
       ideal i=phi(i);
-      // homogenise the ideal i with the first not yet 
-      // used variable in our ring, since gfan 
-      // only handles homogenous ideals; in principle 
+      // homogenise the ideal i with the first not yet
+      // used variable in our ring, since gfan
+      // only handles homogenous ideals; in principle
       // for this one has first to compute a
-      // standard basis of i and homogenise that, 
-      // but for the tropical variety (says Anders) 
+      // standard basis of i and homogenise that,
+      // but for the tropical variety (says Anders)
       // it suffices to homogenise an arbitrary system of generators
-      // i=groebner(i); 
+      // i=groebner(i);
       i=homog(i,maxideal(1)[nvars(PREGFANRING)+1]);
       // if gfan version >= 0.3.0 is used and the characteristic
@@ -4159 +4159 @@
         write(":a /tmp/gfaninput","{"+string(i)+"}");
       }
-      else  
+      else
       {
         // write the ideal to a file which gfan takes as input and call gfan
@@ -4180 +4180 @@
         string trop=read("/tmp/gfanoutput");
         setring PREGFANRING;
-        intvec wneu=-1;    // this integer vector will store 
+        intvec wneu=-1;    // this integer vector will store
                            // the point on the tropical variety
         wneu[nvars(basering)]=0;
@@ -4193 +4193 @@
         "IF YOU WANT wneu TO BE TESTED, THEN SET goon=0;";
         ~
-          // THIS IS NOT NECESSARY !!!! IF WE COMPUTE NOT ONLY THE 
+          // THIS IS NOT NECESSARY !!!! IF WE COMPUTE NOT ONLY THE
           // TROPICAL PREVARIETY
-          // test, if wneu really is in the tropical variety    
+          // test, if wneu really is in the tropical variety
         while (goon==0)
         {
@@ -4212 +4212 @@
       {
         system("sh","gfan_tropicallifting -n "+string(anzahlvariablen)+" --noMult -c < /tmp/gfaninput > /tmp/gfanoutput");
-        // read the result from gfan and store it to a string, 
+        // read the result from gfan and store it to a string,
         // which in a later version
         // should be interpreded by Singular
@@ -4225 +4225 @@
     }
   }
-  // if we have not yet computed our parametrisation 
+  // if we have not yet computed our parametrisation
   // up to the required order and
-  // zero is not yet a solution, then we have 
+  // zero is not yet a solution, then we have
   // to go on by calling the procedure recursively;
   // if all variables were deleted, then i=0 and thus anzahlvariablen==0
   if ((ordnung>1) and (anzahlvariablen>1))
-  {   
-    // we call the procedure with the transformed ideal i, 
+  {
+    // we call the procedure with the transformed ideal i,
     // the new weight vector, with the
-    // required order lowered by one, and with 
+    // required order lowered by one, and with
     // additional parameters, namely the number of
-    // true variables and the maximal ideal that 
+    // true variables and the maximal ideal that
     // was computed so far to describe the field extension
     list PARALIST=tropicalparametriseNoabs(i,wneu,ordnung-1,gfanold,nogfan,anzahlvariablen,gesamt_m);
-    // the output will be a ring, in which the 
+    // the output will be a ring, in which the
     // parametrisation lives, and a string, which contains
     // the maximal ideal that describes the necessary field extension
@@ -4246 +4246 @@
     string PARAm=PARALIST[3];
     setring PARARing;
-    // if some variables have been eliminated in before, 
-    // then we have to insert zeros 
+    // if some variables have been eliminated in before,
+    // then we have to insert zeros
     // into the parametrisation for those variables
     if (numberdeletedvariables>0)
@@ -4253 +4253 @@
       ideal PARAneu=PARA;
       int k;
-      for (jj=1;jj<=anzahlvariablen+numberdeletedvariables-1;jj++) // t admits 
+      for (jj=1;jj<=anzahlvariablen+numberdeletedvariables-1;jj++) // t admits
       { // no parametrisation
         if (deletedvariables[jj]!=1)
@@ -4267 +4267 @@
     }
   }
-  // otherwise we are done and we can start to compute 
+  // otherwise we are done and we can start to compute
   // the last step of the parametrisation
   else
@@ -4273 +4273 @@
     // we store the information on m in a string
     string PARAm=string(gesamt_m);
-    // we define the weight of t, i.e. in the parametrisation t 
+    // we define the weight of t, i.e. in the parametrisation t
     // has to be replaced by t^1/tweight
     int tweight=-tw[1];
-    // if additional variables were necessary, 
+    // if additional variables were necessary,
     // we introduce them now as parameters;
-    // in any case the parametrisation ring will 
-    // have only one variable, namely t,  
-    // and its order will be local, so that it 
+    // in any case the parametrisation ring will
+    // have only one variable, namely t,
+    // and its order will be local, so that it
     // displays the lowest term in t first
     if (anzahlvariablen+numberdeletedvariables<nvars(basering))
@@ -4291 +4291 @@
     }
     ideal PARA; // will contain the parametrisation
-    // we start by initialising the entries to be zero; 
+    // we start by initialising the entries to be zero;
     // one entry for each true variable
-    // here we also have to consider the variables 
+    // here we also have to consider the variables
     // that we have eliminated in before
     for (jj=1;jj<=anzahlvariablen+numberdeletedvariables-1;jj++)
@@ -4300 +4300 @@
     }
   }
-  // we now have to change the parametrisation by 
+  // we now have to change the parametrisation by
   // reverting the transformations that we have done
   list a=imap(BASERING,a);
-  if (defined(wneu)==0) // when tropicalparametriseNoabs is called for the 
-  { // last time, it does not enter the part, where wneu is defined and the 
+  if (defined(wneu)==0) // when tropicalparametriseNoabs is called for the
+  { // last time, it does not enter the part, where wneu is defined and the
     intvec wneu=-1;     // variable t should have weight -1
   }
@@ -4311 +4311 @@
     PARA[jj]=(PARA[jj]+a[jj+1])*t^(tw[jj+1]*tweight/ww[1]);
   }
-  // if we have reached the stop-level, i.e. either 
+  // if we have reached the stop-level, i.e. either
   // we had only to compute up to order 1
-  // or zero was a solution of the ideal, then we have 
+  // or zero was a solution of the ideal, then we have
   // to export the computed parametrisation
   // otherwise it has already been exported before
   // note, if all variables were deleted, then i==0 and thus testaufnull==0
   if ((ordnung==1) or (anzahlvariablen==1))
-  {    
+  {
     export(PARA);
   }
   // kill the gfan files in /tmp
-  system("sh","cd /tmp; /usr/bin/touch gfaninput; /usr/bin/touch gfanoutput; /bin/rm gfaninput; /bin/rm gfanoutput");  
-  // we return a list which contains the 
+  system("sh","cd /tmp; /usr/bin/touch gfaninput; /usr/bin/touch gfanoutput; /bin/rm gfaninput; /bin/rm gfanoutput");
+  // we return a list which contains the
   // parametrisation ring (with the parametrisation ideal)
-  // and the string representing the maximal ideal 
+  // and the string representing the maximal ideal
   // describing the necessary field extension
   return(list(PARARing,tweight,PARAm));
@@ -4334 +4334 @@
 static proc findzeros (ideal i,intvec w,list #)
 "USAGE:      findzeros(i,w[,#]); i ideal, w intvec, # an optional list
-ASSUME:      i is an ideal in Q[t,x_1,...,x_n,X_n+1,...,X_m] and 
+ASSUME:      i is an ideal in Q[t,x_1,...,x_n,X_n+1,...,X_m] and
              w=(w_0,...,w_n,0,...,0) is in the tropical variety of i
-RETURN:      list, l[1] = is polynomial ring containing an associated maximal 
-                          ideal m of the w-initial ideal of i which does not 
+RETURN:      list, l[1] = is polynomial ring containing an associated maximal
+                          ideal m of the w-initial ideal of i which does not
                           contain any monomial and where the variables
-                          which do not lead to a field extension have already 
-                          been eliminated, and containing a list a such that 
-                          the non-zero entries of a correspond to the values 
+                          which do not lead to a field extension have already
+                          been eliminated, and containing a list a such that
+                          the non-zero entries of a correspond to the values
                           of the zero of the associated maximal ideal for the
                           eliminated variables
                    l[2] = number of variables which have not been eliminated
-                   l[3] = intvec, if the entry is one then the corresponding 
+                   l[3] = intvec, if the entry is one then the corresponding
                                   variable has not been eliminated
-NOTE:        the procedure is called from inside the recursive procedure 
+NOTE:        the procedure is called from inside the recursive procedure
              tropicalparametriseNoabs;
-             if it is called in the first recursion, the list #[1] contains 
-             the t-initial ideal of i w.r.t. w, otherwise #[1] is an integer, 
+             if it is called in the first recursion, the list #[1] contains
+             the t-initial ideal of i w.r.t. w, otherwise #[1] is an integer,
              one more than the number of true variables x_1,...,x_n"
 {
-  def BASERING=basering;  
+  def BASERING=basering;
   // set anzahlvariablen to the number of true variables
   if (typeof(#[1])=="int")
@@ -4359 +4359 @@
     int anzahlvariablen=#[1];
     // compute the initial ideal of i
-    // - the last 1 just means that the variable t is the last 
+    // - the last 1 just means that the variable t is the last
     //   variable in the ring
     ideal ini=tInitialIdeal(i,w,1);
@@ -4366 +4366 @@
   {
     int anzahlvariablen=nvars(basering);
-    ideal ini=#[1]; // the t-initial ideal has been computed 
+    ideal ini=#[1]; // the t-initial ideal has been computed
                     // in before and was handed over
   }
-  // move to a polynomial ring with global monomial ordering 
+  // move to a polynomial ring with global monomial ordering
   // - the variable t is superflous
   ideal variablen;
   for (int j=1;j<=nvars(basering)-1;j++)
-  {   
+  {
     variablen=variablen+var(j);
   }
@@ -4379 +4379 @@
   ideal ini=imap(BASERING,ini);
   // compute the associated primes of the initialideal
-  // ordering the maximal ideals shall help to avoid 
+  // ordering the maximal ideals shall help to avoid
   // unneccessary field extensions
   list maximalideals=ordermaximalidealsNoabs(minAssGTZ(std(ini)),anzahlvariablen);
   ideal m=maximalideals[1][1];              // the first associated maximal ideal
   int neuvar=maximalideals[1][2];           // the number of new variables needed
-  intvec neuevariablen=maximalideals[1][3]; // the information which variable 
+  intvec neuevariablen=maximalideals[1][3]; // the information which variable
                                             // leads to a new one
-  list a=maximalideals[1][4];               // a_k is the kth component of a 
+  list a=maximalideals[1][4];               // a_k is the kth component of a
                                             // zero of m, if it is not zero
-  // eliminate from m the superflous variables, that is those ones, 
+  // eliminate from m the superflous variables, that is those ones,
   // which do not lead to a new variable
   poly elimvars=1;
@@ -4398 +4398 @@
     }
   }
-  m=eliminate(m,elimvars);  
-  export(a);  
+  m=eliminate(m,elimvars);
+  export(a);
   export(m);
   list m_ring=INITIALRING,neuvar,neuevariablen;
@@ -4411 +4411 @@
 static proc basictransformideal (ideal i,intvec w,list m_ring,list #)
 "USAGE:  basictransformideal(i,w,m_ring[,#]); i ideal, w intvec, m_ring list, # an optional list
-ASSUME:  i is an ideal in Q[t,x_1,...,x_n,X_1,...,X_k], 
-         w=(w_0,...,w_n,0,...,0) is in the tropical variety of i, and 
+ASSUME:  i is an ideal in Q[t,x_1,...,x_n,X_1,...,X_k],
+         w=(w_0,...,w_n,0,...,0) is in the tropical variety of i, and
          m_ring contains a ring containing a maximal ideal m needed
-         to describe the field extension over which a corresponding 
-         associated maximal ideal of the initialideal of i, considered 
-         in (Q[X_1,...,X_k]/m_alt)(t)[x_1,...,x_n], has a zero, and 
+         to describe the field extension over which a corresponding
+         associated maximal ideal of the initialideal of i, considered
+         in (Q[X_1,...,X_k]/m_alt)(t)[x_1,...,x_n], has a zero, and
          containing a list a describing the zero of m, and m_ring contains
          the information how many new variables are needed for m
@@ -4423 +4423 @@
                       l[3] = ideal, the maximal ideal m
                or l[1] = ring which contains the ideals i and m, and the list a
-NOTE:    the procedure is called from inside the recursive procedure 
+NOTE:    the procedure is called from inside the recursive procedure
          tropicalparametriseNoabs;
-         if it is called in the first recursion, the list # is empty, 
+         if it is called in the first recursion, the list # is empty,
          otherwise #[1] is an integer, the number of true variables x_1,...,x_n;
-         during the procedure we check if a field extension is necessary 
-         to express a zero (a_1,...,a_n) of m; if so, we have to introduce 
-         new variables and a list containing a ring is returned, otherwise 
-         the list containing i, a and m is returned; 
-         the ideal m will be changed during the procedure since all variables 
+         during the procedure we check if a field extension is necessary
+         to express a zero (a_1,...,a_n) of m; if so, we have to introduce
+         new variables and a list containing a ring is returned, otherwise
+         the list containing i, a and m is returned;
+         the ideal m will be changed during the procedure since all variables
          which reduce to a polynomial in X_1,...,X_k modulo m will be eliminated,
          while the others are replaced by new variables X_k+1,...,X_k'"
@@ -4443 +4443 @@
     wdegs[j]=deg(i[j],intvec(w[2..size(w)],w[1]));
   }
-  // how many variables are true variables, 
+  // how many variables are true variables,
   // and how many come from the field extension
   // only real variables have to be transformed
@@ -4458 +4458 @@
   // get the information if any new variables are needed from m_ring
   int neuvar=m_ring[2];  // number of variables which have to be added
-  intvec neuevariablen=m_ring[3];  // [i]=1, if for the ith comp. 
+  intvec neuevariablen=m_ring[3];  // [i]=1, if for the ith comp.
                                    // of a zero of m a new variable is needed
   def MRING=m_ring[1];   // MRING contains a and m
-  list a=imap(MRING,a);  // (a_1,...,a_n)=(a[2],...,a[n+1]) will be 
+  list a=imap(MRING,a);  // (a_1,...,a_n)=(a[2],...,a[n+1]) will be
                          // a common zero of the ideal m
-  ideal m=std(imap(MRING,m)); // m is zero, if neuvar==0, 
+  ideal m=std(imap(MRING,m)); // m is zero, if neuvar==0,
                               // otherwise we change the ring anyway
-  // if a field extension is needed, then extend the polynomial 
+  // if a field extension is needed, then extend the polynomial
   // ring by new variables X_k+1,...,X_k';
   if (neuvar>0)
   {
-    // change to a ring where for each variable needed 
+    // change to a ring where for each variable needed
     // in m a new variable has been introduced
     ideal variablen;
@@ -4480 +4480 @@
     // map i into the new ring
     ideal i=imap(BASERING,i);
-    // define a map phi which maps the true variables, which are not 
+    // define a map phi which maps the true variables, which are not
     // reduced to polynomials in the additional variables modulo m, to
-    // the corresponding newly introduced variables, and which maps 
+    // the corresponding newly introduced variables, and which maps
     // the old additional variables to themselves
     ideal phiideal;
     k=1;
-    for (j=2;j<=size(neuevariablen);j++)  // starting with 2, since the 
+    for (j=2;j<=size(neuevariablen);j++)  // starting with 2, since the
     { // first entry corresponds to t
       if(neuevariablen[j]==1)
@@ -4495 +4495 @@
       else
       {
-        phiideal[j-1]=0;  
+        phiideal[j-1]=0;
       }
     }
@@ -4502 +4502 @@
       phiideal=phiideal,X(1..nvars(BASERING)-anzahlvariablen);
     }
-    map phi=MRING,phiideal; 
-    // map m and a to the new ring via phi, so that the true variables 
+    map phi=MRING,phiideal;
+    // map m and a to the new ring via phi, so that the true variables
     // in m and a are replaced by
     // the corresponding newly introduced variables
@@ -4509 +4509 @@
     list a=phi(a);
   }
-  // replace now the zeros among the a_j by the corresponding 
+  // replace now the zeros among the a_j by the corresponding
   // newly introduced variables;
-  // note that no component of a can be zero 
+  // note that no component of a can be zero
   // since the maximal ideal m contains no variable!
-  // moreover, substitute right away in the ideal i 
+  // moreover, substitute right away in the ideal i
   // the true variable x_j by (a_j+x_j)*t^w_j
   zaehler=nvars(BASERING)-anzahlvariablen+1;
-  for (j=1;j<=anzahlvariablen;j++)  
+  for (j=1;j<=anzahlvariablen;j++)
   {
     if ((a[j]==0) and (j!=1))  // a[1]=0, since t->t^w_0
-    {        
+    {
       a[j]=X(zaehler);
       zaehler++;
@@ -4526 +4526 @@
     {
       if (j!=1) // corresponds to  x_(j-1) --  note t is the last variable
-      {        
+      {
         i[k]=substitute(i[k],var(j-1),(a[j]+var(j-1))*t^(-w[j]));
       }
@@ -4538 +4538 @@
   for (j=1;j<=ncols(i);j++)
   {
-    if (wdegs[j]<0) // if wdegs[j]==0 there is no need to divide, and 
+    if (wdegs[j]<0) // if wdegs[j]==0 there is no need to divide, and
     { // we made sure that it is no positive
       i[j]=i[j]/t^(-wdegs[j]);
     }
   }
-  // since we want to consider i now in the ring 
+  // since we want to consider i now in the ring
   // (Q[X_1,...,X_k']/m)[t,x_1,...,x_n]
-  // we can  reduce i modulo m, so that "constant terms" 
+  // we can  reduce i modulo m, so that "constant terms"
   // which are "zero" since they
   // are in m will disappear; simplify(...,2) then really removes them
   i=simplify(reduce(i,m),2);
-  // if new variables have been introduced, we have 
+  // if new variables have been introduced, we have
   // to return the ring containing i, a and m
   // otherwise we can simply return a list containing i, a and m
@@ -4570 +4570 @@
 static proc testw (ideal i,intvec w,int anzahlvariablen,list #)
 "USAGE:      testw(i,w,n); i ideal, w intvec, n number
-ASSUME:      i is an ideal in Q[t,x_1,...,x_n,X_1,...,X_k] and 
-             w=(w_0,...,w_n,0,...,0)            
-RETURN:      int b, 0 if the t-initial ideal of i considered in 
+ASSUME:      i is an ideal in Q[t,x_1,...,x_n,X_1,...,X_k] and
+             w=(w_0,...,w_n,0,...,0)
+RETURN:      int b, 0 if the t-initial ideal of i considered in
                     Q(X_1,...,X_k)[t,x_1,...,x_n] is monomial free, 1 else
 NOTE:        the procedure is called by tinitialform"
@@ -4586 +4586 @@
     ideal tin=tInitialIdeal(i,w,1);
   }
-  
+
   int j;
   ideal variablen;
@@ -4618 +4618 @@
   def BASERING=basering;
   if (anzahlvariablen<nvars(basering))
-  {   
+  {
     execute("ring TINRING=("+charstr(basering)+","+string(Parameter)+"),("+string(variablen)+"),dp;");
   }
@@ -4628 +4628 @@
   poly monom=imap(BASERING,monom);
   return(radicalMemberShip(monom,tin));
-}  
+}
 
 /////////////////////////////////////////////////////////////////////////
@@ -4634 +4634 @@
 static proc simplifyToOrder (poly f)
 "USAGE:      simplifyToOrder(f); f a polynomial
-ASSUME:      f is a polynomial in Q(t)[x_1,...,x_n] 
+ASSUME:      f is a polynomial in Q(t)[x_1,...,x_n]
 RETURN:      list, l[1] = t-order of leading term of f
                    l[2] = the rational coefficient of the term of lowest t-order
@@ -4657 +4657 @@
 static proc scalarproduct (intvec w,intvec v)
 "USAGE:      scalarproduct(w,v); w,v intvec
-ASSUME:      w and v are integer vectors of the same length 
+ASSUME:      w and v are integer vectors of the same length
 RETURN:      int, the scalarproduct of v and w
 NOTE:        the procedure is called by tropicalparametriseNoabs"
@@ -4715 +4715 @@
 "USAGE:      ordermaximalidealsNoabs(minassi); minassi list
 ASSUME:      minassi is a list of maximal ideals
-RETURN:      list, the procedure orders the maximal ideals in minassi according 
-                   to how many new variables are needed to describe the zeros 
+RETURN:      list, the procedure orders the maximal ideals in minassi according
+                   to how many new variables are needed to describe the zeros
                    of the ideal
                    l[j][1] = jth maximal ideal
                    l[j][2] = the number of variables needed
-                   l[j][3] = intvec, if for the kth variable a new variable is 
-                                     needed to define the corresponding zero of 
+                   l[j][3] = intvec, if for the kth variable a new variable is
+                                     needed to define the corresponding zero of
                                      l[j][1], then the k+1st entry is one
-                   l[j][4] = list, if for the kth variable no new variable is 
-                                   needed to define the corresponding zero of 
+                   l[j][4] = list, if for the kth variable no new variable is
+                                   needed to define the corresponding zero of
                                    l[j][1], then its value is the k+1st entry
 NOTE:        if a maximal ideal contains a variable, it is removed from the list;
@@ -4733 +4733 @@
   int pruefer;       // is set one if a maximal ideal contains a variable
   list minassisort;  // will contain the output
-  for (j=1;j<=size(minassi);j++){minassisort[j]=0;} // initialise minassisort 
+  for (j=1;j<=size(minassi);j++){minassisort[j]=0;} // initialise minassisort
                                                     // to fix its initial length
   list zwischen;     // needed for reordering
   list a;// (a_1,...,a_n)=(a[2],...,a[n+1]) will be a common zero of the ideal m
   poly nf;           // normalform of a variable w.r.t. m
-  intvec neuevariablen; // ith entry is 1, if for the ith component of a zero 
+  intvec neuevariablen; // ith entry is 1, if for the ith component of a zero
                         // of m a new variable is needed
   intvec testvariablen; // integer vector of length n=number of variables
-  // compute for each maximal ideal the number of new variables, 
+  // compute for each maximal ideal the number of new variables,
   // which are needed to describe
-  // its zeros -- note, a new variable is needed if modulo 
-  // the maximal ideal it does not reduce 
+  // its zeros -- note, a new variable is needed if modulo
+  // the maximal ideal it does not reduce
   // to something which only depends on the following variables;
-  // if no new variable is needed, then store the value 
-  // a variable reduces to in the list a; 
+  // if no new variable is needed, then store the value
+  // a variable reduces to in the list a;
   for (j=size(minassi);j>=1;j--)
   {
-    a[1]=poly(0);         // the first entry in a and in neuevariablen 
+    a[1]=poly(0);         // the first entry in a and in neuevariablen
                           // corresponds to the variable t,
     neuevariablen[1]=0;   // which is not present in the INITIALRING
@@ -4758 +4758 @@
     {
       nf=reduce(var(k),minassi[j]);
-      // if a variable reduces to zero, then the maximal ideal 
+      // if a variable reduces to zero, then the maximal ideal
       // contains a variable and we can delete it
       if (nf==0)
@@ -4764 +4764 @@
         pruefer=1;
       }
-      // set the entries of testvariablen corresponding to the first 
+      // set the entries of testvariablen corresponding to the first
       // k variables to 1, and the others to 0
       for (l=1;l<=nvars(basering);l++)
       {
         if (l<=k)
-        {          
+        {
           testvariablen[l]=1;
         }
@@ -4777 +4777 @@
         }
       }
-      // if the variable x_j reduces to a polynomial 
+      // if the variable x_j reduces to a polynomial
       // in x_j+1,...,x_n,X_1,...,X_k modulo m
-      // then we can eliminate x_j from the maximal ideal 
+      // then we can eliminate x_j from the maximal ideal
       // (since we do not need any
-      // further field extension to express a_j) and a_j 
+      // further field extension to express a_j) and a_j
       // will just be this normalform,
       // otherwise we have to introduce a new variable in order to express a_j;
@@ -4788 +4788 @@
         a[k+1]=nf; // a_k is the normal form of the kth variable modulo m
         neuevariablen[k+1]=0;  // no new variable is needed
-      }    
+      }
       else
       {
-        a[k+1]=poly(0); // a_k is set to zero until we have 
+        a[k+1]=poly(0); // a_k is set to zero until we have
                         // introduced the new variable
         neuevariablen[k+1]=1;
@@ -4799 +4799 @@
     // if the maximal ideal contains a variable, we simply delete it
     if (pruefer==0)
-    {      
+    {
       minassisort[j]=list(minassi[j],neuvar,neuevariablen,a);
     }
-    // otherwise we store the information on a, 
+    // otherwise we store the information on a,
     // neuevariablen and neuvar together with the ideal
     else
@@ -4811 +4811 @@
     }
   }
-  // sort the maximal ideals ascendingly according to 
+  // sort the maximal ideals ascendingly according to
   // the number of new variables needed to
   // express the zero of the maximal ideal
@@ -4818 +4818 @@
     l=j;
     for (k=j-1;k>=1;k--)
-    {      
+    {
       if (minassisort[l][2]<minassisort[k][2])
       {
@@ -4836 +4836 @@
 "USAGE:  displaypoly(p,N,wj,w1); p poly, N, wj, w1 int
 ASSUME:  p is a polynomial in r=(0,X(1..k)),t,ls
-RETURN:  string, the string of t^-wj/w1*p(t^1/N)  
+RETURN:  string, the string of t^-wj/w1*p(t^1/N)
 NOTE:    the procedure is called from displayTropicalLifting"
 {
@@ -4854 +4854 @@
   {
     if (koeffizienten[j-ord(p)+1]!=0)
-    {      
+    {
       if ((j-(N*wj)/w1)==0)
       {
@@ -4904 +4904 @@
 static proc displaycoef (poly p)
 "USAGE:      displaycoef(p); p poly
-RETURN:      string, the string of p where brackets around 
+RETURN:      string, the string of p where brackets around
                      have been added if they were missing
 NOTE:        the procedure is called from displaypoly"
@@ -4976 +4976 @@
 static proc tropicalliftingresubstitute (ideal i,list liftring,int N,list #)
 "USAGE:   tropicalliftingresubstitute(i,L,N[,#]); i ideal, L list, N int, # string
-ASSUME:   i is an ideal and L[1] is a ring which contains the lifting of a 
-          point in the tropical variety of i computed with tropicalLifting; 
-          t has to be replaced by t^1/N in the lifting; #[1]=m is the string 
-          of the maximal ideal defining the necessary field extension as 
+ASSUME:   i is an ideal and L[1] is a ring which contains the lifting of a
+          point in the tropical variety of i computed with tropicalLifting;
+          t has to be replaced by t^1/N in the lifting; #[1]=m is the string
+          of the maximal ideal defining the necessary field extension as
           computed by tropicalLifting, if #[1] is present
 RETURN:   string, the lifting has been substituted into i
@@ -5002 +5002 @@
       ideal i=imap(BASERING,i);
     }
-  }  
+  }
   else
   {
@@ -5015 +5015 @@
   }
   // map the resulting i back to LIFTRing;
-  // if noAbs, then reduce i modulo the maximal ideal  
+  // if noAbs, then reduce i modulo the maximal ideal
   // before going back to LIFTRing
   if ((size(parstr(LIFTRing))!=0) and size(#)>0)
@@ -5032 +5032 @@
   for (j=1;j<=ncols(i);j++)
   {
-    SUBSTTEST[j]=displaypoly(i[j],N,0,1);  
+    SUBSTTEST[j]=displaypoly(i[j],N,0,1);
   }
   return(SUBSTTEST);
@@ -5042 +5042 @@
 /// - eliminatecomponents
 /// - findzerosAndBasictransform
-/// - ordermaximalideals 
+/// - ordermaximalideals
 ///////////////////////////////////////////////////////////////////////////////
 
 static proc tropicalparametrise (ideal i,intvec ww,int ordnung,int gfanold,int findall,int nogfan,list #)
 "USAGE:  tropicalparametrise(i,tw,ord,gf,fa,ng[,#]); i ideal, tw intvec, ord int, gf,fa,ng int, # opt. list
-ASSUME:  - i is an ideal in Q[t,x_1,...,x_n,@a], tw=(w_0,w_1,...,w_n,0) 
-           and (w_0,...,w_n,0) is in the tropical variety of i, 
-           and ord is the order up to which a point in V(i) 
-           over K{{t}} lying over w shall be computed; 
-         - moreover, @a should be not be there if the procedure is not 
+ASSUME:  - i is an ideal in Q[t,x_1,...,x_n,@a], tw=(w_0,w_1,...,w_n,0)
+           and (w_0,...,w_n,0) is in the tropical variety of i,
+           and ord is the order up to which a point in V(i)
+           over K{{t}} lying over w shall be computed;
+         - moreover, @a should be not be there if the procedure is not
            called recursively;
          - the point in the tropical variety is supposed to lie in the
            NEGATIVE orthant;
-         - the ideal is zero-dimensional when considered in 
-           (K(t)[@a]/m)[x_1,...,x_n], where m=#[2] is a maximal ideal in K[@a]; 
+         - the ideal is zero-dimensional when considered in
+           (K(t)[@a]/m)[x_1,...,x_n], where m=#[2] is a maximal ideal in K[@a];
          - gf is 0 if version 2.2 or larger is used and it is 1 else
          - fa is 1 if all solutions should be found
@@ -5063 +5063 @@
                l[2] = int
 NOTE:    - the procedure is also called recursively by itself, and
-           if it is called in the first recursion, the list # is empty, 
-           otherwise #[1] is an integer, one more than the number of 
-           true variables x_1,...,x_n, and #[2] will contain the maximal 
-           ideal m in the variable @a by which the ring K[t,x_1,...,x_n,@a] 
-           should be divided to work correctly in L[t,x_1,...,x_n] where 
+           if it is called in the first recursion, the list # is empty,
+           otherwise #[1] is an integer, one more than the number of
+           true variables x_1,...,x_n, and #[2] will contain the maximal
+           ideal m in the variable @a by which the ring K[t,x_1,...,x_n,@a]
+           should be divided to work correctly in L[t,x_1,...,x_n] where
            L=Q[@a]/m is a field extension of K
-         - the ring l[1] contains an ideal PARA, which contains the 
-           parametrisation of a point in V(i) lying over w up to the first 
+         - the ring l[1] contains an ideal PARA, which contains the
+           parametrisation of a point in V(i) lying over w up to the first
            ord terms;
-         - the string m contains the code of the maximal ideal m, by which we 
+         - the string m contains the code of the maximal ideal m, by which we
            have to divide K[@a] in order to have the appropriate field extension
            over which the parametrisation lives;
          - and if the integer l[3] is N then t has to be replaced by t^1/N in the
-           parametrisation, or alternatively replace t by t^N in the defining 
+           parametrisation, or alternatively replace t by t^N in the defining
            ideal
-         - the procedure REQUIRES that the program GFAN is installed 
+         - the procedure REQUIRES that the program GFAN is installed
            on your computer"
 {
@@ -5084 +5084 @@
   int recursively; // is set 1 if the procedure is called recursively by itself
   int ii,jj,kk,ll,jjj,kkk,lll;
-  if (typeof(#[1])=="int") // this means the precedure has been 
+  if (typeof(#[1])=="int") // this means the precedure has been
   { // called recursively
-    // how many variables are true variables, and how many come 
+    // how many variables are true variables, and how many come
     // from the field extension
     // only true variables have to be transformed
     int anzahlvariablen=#[1];
     // find the zeros of the w-initial ideal and transform the ideal i;
-    // findzeros and basictransformideal need to know 
+    // findzeros and basictransformideal need to know
     // how many of the variables are true variables
     // and do the basic transformation as well
@@ -5099 +5099 @@
   else // the procedure has been called by tropicalLifting
   {
-    // how many variables are true variables, and 
+    // how many variables are true variables, and
     // how many come from the field extension
     // only true variables have to be transformed
     int anzahlvariablen=nvars(basering);
-    list zerolist; // will carry the zeros which are 
-    //computed in the recursion steps    
+    list zerolist; // will carry the zeros which are
+    //computed in the recursion steps
     // the initial ideal of i has been handed over as #[1]
     ideal ini=#[1];
     // find the zeros of the w-initial ideal and transform the ideal i;
-    // we should hand the t-initial ideal ine to findzeros, 
+    // we should hand the t-initial ideal ine to findzeros,
     // since we know it already;
     // and do the basic transformation as well
@@ -5114 +5114 @@
   }
   list wneulist; // carries all newly computed weight vector
-  intvec wneu;   // carries the newly computed weight vector 
+  intvec wneu;   // carries the newly computed weight vector
   int tweight;   // carries the weight of t
-  list PARALIST; // carries the result when tropicalparametrise 
+  list PARALIST; // carries the result when tropicalparametrise
                  // is recursively called
   list eliminaterings;     // carries the result of eliminatecomponents
@@ -5125 +5125 @@
   list liftings,partliftings;  // the computed liftings (all resp. partly)
   // consider each ring which has been returned when computing the zeros of the
-  // the t-initial ideal, equivalently, consider 
+  // the t-initial ideal, equivalently, consider
   // each zero which has been returned
   for (jj=1;jj<=size(trring);jj++)
@@ -5131 +5131 @@
     def TRRING=trring[jj];
     setring TRRING;
-    // check if a certain number of components lead to suitable 
+    // check if a certain number of components lead to suitable
     // solutions with zero components;
     // compute them all if findall==1
     eliminaterings=eliminatecomponents(i,m,oldanzahlvariablen,findall,oldanzahlvariablen-1,deletedvariables);
-    // consider each of the rings returned by eliminaterings ... 
+    // consider each of the rings returned by eliminaterings ...
     // there is at least one !!!
     for (ii=1;ii<=size(eliminaterings);ii++)
     {
       // #variables which have been eliminated
-      numberdeletedvariables=oldanzahlvariablen-eliminaterings[ii][2]; 
+      numberdeletedvariables=oldanzahlvariablen-eliminaterings[ii][2];
       // #true variables which remain (including t)
-      anzahlvariablen=eliminaterings[ii][2];  
+      anzahlvariablen=eliminaterings[ii][2];
       // a 1 in this vector says that variable was eliminated
-      deletedvariables=eliminaterings[ii][3]; 
+      deletedvariables=eliminaterings[ii][3];
       setring TRRING; // set TRRING - this is important for the loop
       // pass the ring computed by eliminatecomponents
-      def PREGFANRING=eliminaterings[ii][1];  
+      def PREGFANRING=eliminaterings[ii][1];
       setring PREGFANRING;
       poly m=imap(TRRING,m);        // map the maximal ideal to this ring
       list zero=imap(TRRING,zero);  // map the vector of zeros to this ring
-      // now we have to compute a point ww on the tropical 
+      // now we have to compute a point ww on the tropical
       // variety of the transformed ideal i;
-      // of course, we only have to do so, if we have 
+      // of course, we only have to do so, if we have
       // not yet reached the order up to which we
       // were supposed to do our computations
-      if ((ordnung>1) and (anzahlvariablen>1)) // if only t remains, 
+      if ((ordnung>1) and (anzahlvariablen>1)) // if only t remains,
       { // all true variables are gone
         if (nogfan!=1)
-        {          
+        {
           // pass to a ring which has variables which are suitable for gfan
           execute("ring GFANRING=("+string(char(basering))+"),(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z),dp;");
-          ideal phiideal=b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z; 
+          ideal phiideal=b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z;
           phiideal[nvars(PREGFANRING)]=a; // map t to a
-          map phi=PREGFANRING,phiideal; 
+          map phi=PREGFANRING,phiideal;
           ideal II=phi(i);
-          // homogenise the ideal II with the first not yet 
-          // used variable in our ring, since gfan 
-          // only handles homogenous ideals; in principle for this 
+          // homogenise the ideal II with the first not yet
+          // used variable in our ring, since gfan
+          // only handles homogenous ideals; in principle for this
           // one has first to compute a
-          // standard basis of II and homogenise that, 
-          // but for the tropical variety (says Anders) 
+          // standard basis of II and homogenise that,
+          // but for the tropical variety (says Anders)
           // it suffices to homogenise an arbitrary system of generators
-          // II=groebner(II); 
+          // II=groebner(II);
           II=homog(II,maxideal(1)[nvars(PREGFANRING)+1]);
           // if gfan version >= 0.3.0 is used and the characteristic
@@ -5211 +5211 @@
             int goon=1;
             trop;
-            "CHOOSE A RAY IN THE OUTPUT OF GFAN WHICH HAS ONLY"; 
+            "CHOOSE A RAY IN THE OUTPUT OF GFAN WHICH HAS ONLY";
             "NON-POSITIVE ENTRIES AND STARTS WITH A NEGATIVE ONE,";
             "E.G. (-3,-4,-1,-5,0,0,0) - the last entry will always be 0 -";
@@ -5218 +5218 @@
             "IF YOU WANT wneu TO BE TESTED, THEN SET goon=0;";
             ~
-            // THIS IS NOT NECESSARY !!!! IF WE COMPUTE NOT ONLY 
+            // THIS IS NOT NECESSARY !!!! IF WE COMPUTE NOT ONLY
             // THE TROPICAL PREVARIETY
-            // test, if wneu really is in the tropical variety    
+            // test, if wneu really is in the tropical variety
             while (goon==0)
             {
@@ -5238 +5238 @@
           {
             system("sh","gfan_tropicallifting -n "+string(anzahlvariablen)+" --noMult -c < /tmp/gfaninput > /tmp/gfanoutput");
-            // read the result from gfan and store it to a string, 
+            // read the result from gfan and store it to a string,
             // which in a later version
             // should be interpreded by Singular
@@ -5261 +5261 @@
         }
       }
-      // if we have not yet computed our parametrisation up to 
+      // if we have not yet computed our parametrisation up to
       // the required order and
-      // zero is not yet a solution, then we have to go on 
+      // zero is not yet a solution, then we have to go on
       // by calling the procedure recursively;
       // if all variables were deleted, then i=0 and thus anzahlvariablen==0
       lll=0;
       if ((ordnung>1) and (anzahlvariablen>1))
-      { 
+      {
         partliftings=list(); // initialise partliftings
-        // we call the procedure with the transformed 
+        // we call the procedure with the transformed
         // ideal i, the new weight vector, with the
-        // required order lowered by one, and with 
+        // required order lowered by one, and with
         // additional parameters, namely the number of
-        // true variables and the maximal ideal that 
+        // true variables and the maximal ideal that
         // was computed so far to describe the field extension
         for (kk=1;kk<=size(wneulist);kk++)
@@ -5280 +5280 @@
           wneu=wneulist[kk];
           PARALIST=tropicalparametrise(i,wneu,ordnung-1,gfanold,findall,nogfan,anzahlvariablen,zero);
-          // the output will be a ring, in which the 
+          // the output will be a ring, in which the
           // parametrisation lives, and a string, which contains
           // the maximal ideal that describes the necessary field extension
           for (ll=1;ll<=size(PARALIST);ll++)
-          {  
+          {
             def PARARing=PARALIST[ll][1];
             tweight=-ww[1]*PARALIST[ll][2];
             setring PARARing;
-            // if some variables have been eliminated 
-            // in before, then we have to insert zeros 
+            // if some variables have been eliminated
+            // in before, then we have to insert zeros
             // into the parametrisation for those variables
             if (numberdeletedvariables>0)
@@ -5295 +5295 @@
               ideal PARAneu=PARA;
               kkk=0;
-              for (jjj=1;jjj<=anzahlvariablen+numberdeletedvariables-1;jjj++) 
+              for (jjj=1;jjj<=anzahlvariablen+numberdeletedvariables-1;jjj++)
               { // t admits no parametrisation
                 if (deletedvariables[jjj]!=1)
@@ -5315 +5315 @@
         }
       }
-      // otherwise we are done and we can start 
+      // otherwise we are done and we can start
       // to compute the last step of the parametrisation
       else
       {
-        // we define the weight of t, i.e. in the 
+        // we define the weight of t, i.e. in the
         // parametrisation t has to be replaced by t^1/tweight
         tweight=-ww[1];
-        // if additional variables were necessary, 
+        // if additional variables were necessary,
         // we introduce them now as parameters;
-        // in any case the parametrisation ring will 
-        // have only one variable, namely t,  
-        // and its order will be local, so that it 
+        // in any case the parametrisation ring will
+        // have only one variable, namely t,
+        // and its order will be local, so that it
         // displays the lowest term in t first
         if (anzahlvariablen<nvars(basering))
@@ -5338 +5338 @@
         }
         ideal PARA; // will contain the parametrisation
-        // we start by initialising the entries to be zero; 
+        // we start by initialising the entries to be zero;
         // one entry for each true variable
-        // here we also have to consider the variables 
+        // here we also have to consider the variables
         // that we have eliminated in before
         for (jjj=1;jjj<=anzahlvariablen+numberdeletedvariables-1;jjj++)
@@ -5352 +5352 @@
         kill PARARing;
       }
-      // we now have to change the parametrisation by 
+      // we now have to change the parametrisation by
       // reverting the transformations that we have done
       for (lll=1;lll<=size(partliftings);lll++)
       {
-        if (size(partliftings[lll])==2) // when tropicalparametrise is called 
-        { // for the last time, it does not enter the part, where wneu is 
+        if (size(partliftings[lll])==2) // when tropicalparametrise is called
+        { // for the last time, it does not enter the part, where wneu is
           wneu=-1;     // defined and the variable t should have weight -1
         }
@@ -5372 +5372 @@
           PARA[jjj]=(PARA[jjj]+zeros[size(zeros)][jjj+1])*t^(ww[jjj+1]*tweight/ww[1]);
         }
-        // delete the last entry in zero, since that one has 
+        // delete the last entry in zero, since that one has
         // been used for the transformation
         zeros=delete(zeros,size(zeros));
-        // in order to avoid redefining commands an empty 
+        // in order to avoid redefining commands an empty
         // zeros list should be removed
         if (size(zeros)==0)
@@ -5391 +5391 @@
   }
   // kill the gfan files in /tmp
-  system("sh","cd /tmp; /usr/bin/touch gfaninput; /usr/bin/touch gfanoutput; /bin/rm gfaninput; /bin/rm gfanoutput");  
-  // we return a list which contains lists of the parametrisation 
+  system("sh","cd /tmp; /usr/bin/touch gfaninput; /usr/bin/touch gfanoutput; /bin/rm gfaninput; /bin/rm gfanoutput");
+  // we return a list which contains lists of the parametrisation
   // rings (with the parametrisation ideal)
   // and an integer N such that t should be replaced by t^1/N
@@ -5402 +5402 @@
 static proc eliminatecomponents (ideal i,ideal m,int anzahlvariablen,int findall,int lastvar,intvec deletedvariables)
 "USAGE:  eliminatecomponents(i,m,n,a,v,d); i,m ideal, n,a,v int, d intvec
-ASSUME:  i is an ideal in Q[x_1,...,x_n,@a,t] and w=(-w_1/w_0,...,-w_n/w_0) 
-         is in the tropical variety of i considered in 
-         Q[@a]/m{{t}}[x_1,...,x_n]; 
-         considered in this ring i is zero-dimensional; @a need not be present 
+ASSUME:  i is an ideal in Q[x_1,...,x_n,@a,t] and w=(-w_1/w_0,...,-w_n/w_0)
+         is in the tropical variety of i considered in
+         Q[@a]/m{{t}}[x_1,...,x_n];
+         considered in this ring i is zero-dimensional; @a need not be present
          in which case m is zero; 1<=v<=n
 RETURN:  list, L of lists
@@ -5411 +5411 @@
                L[j][2] = an integer anzahlvariablen
                L[j][3] = an intvec deletedvariables
-NOTE:    - the procedure is called from inside the recursive 
+NOTE:    - the procedure is called from inside the recursive
            procedure tropicalparametrise
-         - the procedure checks for solutions which have certain 
-           components zero; these are separated from the rest by 
-           elimination and saturation; the integer deletedvariables 
-           records which variables have been eliminated; 
-           the integer anzahlvariablen records how many true variables remain 
+         - the procedure checks for solutions which have certain
+           components zero; these are separated from the rest by
+           elimination and saturation; the integer deletedvariables
+           records which variables have been eliminated;
+           the integer anzahlvariablen records how many true variables remain
            after the elimination
-         - if the integer a is one then all zeros of the ideal i are 
-           considered and found, otherwise only one is considered, so that L 
+         - if the integer a is one then all zeros of the ideal i are
+           considered and found, otherwise only one is considered, so that L
            has length one"
 {
@@ -5428 +5428 @@
   // if all solutions have to be found
   if (findall==1)
-  {    
+  {
     list saturatelist,eliminatelist; // carry the solution of the two tests
-    // we test first if there is a solution which has the component 
-    // lastvar zero and 
+    // we test first if there is a solution which has the component
+    // lastvar zero and
     // where the order of each component is strictly positive;
-    // if so, we add this variable to the ideal and 
+    // if so, we add this variable to the ideal and
     // eliminate it - which amounts to
-    // to projecting the solutions with this component 
+    // to projecting the solutions with this component
     // zero to the hyperplane without this component;
-    // for the test we compute the saturation with 
+    // for the test we compute the saturation with
     // respect to t and replace each variable
-    // x_i and also t by zero -- if the result is zero, 
-    // then 1 is not in I:t^infty 
+    // x_i and also t by zero -- if the result is zero,
+    // then 1 is not in I:t^infty
     // (i.e. there is a solution which has the component lastvar zero) and
-    // the result lives in the maximal 
-    // ideal <t,x_1,...,[no x_lastvar],...,x_n> so that 
+    // the result lives in the maximal
+    // ideal <t,x_1,...,[no x_lastvar],...,x_n> so that
     // there is a solution which has strictly positive valuation
 /*
     // DER NACHFOLGENDE TEIL IST MUELL UND WIRD NICHT MEHR GAMACHT
-    // for the test we simply compute the leading ideal 
+    // for the test we simply compute the leading ideal
     // and set all true variables zero;
-    // since the ordering was an elimination ordering 
+    // since the ordering was an elimination ordering
     // with respect to (@a if present and) t
-    // there remains something not equal to zero 
+    // there remains something not equal to zero
     // if and only if there is polynomial which only
-    // depends on t (and @a if present), but that is 
+    // depends on t (and @a if present), but that is
     // a unit in K{{t}}, which would show that there
     // is no solution with the component lastvar zero;
-    // however, we also have to ensure that if there 
+    // however, we also have to ensure that if there
     // exists a solution with the component lastvar
-    // equal to zero then this component has a 
+    // equal to zero then this component has a
     // valuation with all strictly positive values!!!!;
-    // for this we can either saturate the ideal 
+    // for this we can either saturate the ideal
     // after elimination with respect to <t,x_1,...,x_n>
-    // and see if the saturated ideal is contained in <t,x_1,...x_n>+m, 
-    // or ALTERNATIVELY we can pass to the 
+    // and see if the saturated ideal is contained in <t,x_1,...x_n>+m,
+    // or ALTERNATIVELY we can pass to the
     // ring 0,(t,x_1,...,x_n,@a),(ds(n+1),dp(1)),
-    // compute a standard basis of the elimination 
+    // compute a standard basis of the elimination
     // ideal (plus m) there and check if the dimension 1
-    // (since we have not omitted the variable lastvar, 
+    // (since we have not omitted the variable lastvar,
     // this means that we have the ideal
-    // generated by t,x_1,...,[no x_lastvar],...,x_n 
+    // generated by t,x_1,...,[no x_lastvar],...,x_n
     // and this defines NO curve after omitting x_lastvar)
     I=std(ideal(var(lastvar)+i));
@@ -5475 +5475 @@
     LI=lead(reduce(I,std(m)));
     //size(deletedvariables)=anzahlvariablen(before elimination)
-    for (j=1;j<=anzahlvariablen-1;j++) 
+    for (j=1;j<=anzahlvariablen-1;j++)
     {
       LI=subst(LI,var(j),0);
@@ -5481 +5481 @@
     if (size(LI)==0) // if no power of t is in lead(I) (where @a is considered as a field element)
 */
-    I=reduce(sat(ideal(var(lastvar)+i),t)[1],std(m)); // get rid of the minimal 
+    I=reduce(sat(ideal(var(lastvar)+i),t)[1],std(m)); // get rid of the minimal
                                                       // polynomial for the test
     LI=subst(I,var(nvars(basering)),0);
     //size(deletedvariables)=anzahlvariablen(before elimination)
-    for (j=1;j<=anzahlvariablen-1;j++) 
+    for (j=1;j<=anzahlvariablen-1;j++)
     {
       LI=subst(LI,var(j),0);
     }
-    if (size(LI)==0) // the saturation lives in the maximal 
+    if (size(LI)==0) // the saturation lives in the maximal
     { // ideal generated by t and the x_i
       // get rid of var(lastvar)
@@ -5504 +5504 @@
       {
         string elring="ring ELIMINATERING=("+charstr(basering)+"),("+string(simplify(reduce(maxideal(1),std(var(lastvar))),2))+"),(";
-      }    
-      if (anzahlvariablen<nvars(basering)) // if @a was present, the 
+      }
+      if (anzahlvariablen<nvars(basering)) // if @a was present, the
       { // ordersting needs an additional entry
         elring=elring+"dp(1),";
       }
       elring=elring+"lp(1));";
-      execute(elring);      
+      execute(elring);
       ideal i=imap(BASERING,I); // move the ideal I to the new ring
-      // if not yet all variables have been checked, 
+      // if not yet all variables have been checked,
       // then go on with the next smaller variable,
-      // else prepare the elimination ring and the neccessary 
+      // else prepare the elimination ring and the neccessary
       // information for return
       if (lastvar>1)
@@ -5527 +5527 @@
       setring BASERING;
     }
-    // next we have to test if there is also a solution 
+    // next we have to test if there is also a solution
     // which has the variable lastvar non-zero;
-    // to do so, we saturate with respect to this variable; 
-    // since when considered over K{{t}} 
-    // the ideal is zero dimensional, this really removes  
+    // to do so, we saturate with respect to this variable;
+    // since when considered over K{{t}}
+    // the ideal is zero dimensional, this really removes
     // all solutions with that component zero;
     // the checking is then done as above
     i=std(sat(i,var(lastvar))[1]);
     I=reduce(i,std(m)); // "remove" m from i
-    // test first, if i still is in the ideal <t,x_1,...,x_n> -- if not, then 
-    // we know that i has no longer a point in the tropical 
+    // test first, if i still is in the ideal <t,x_1,...,x_n> -- if not, then
+    // we know that i has no longer a point in the tropical
     // variety with all components negative
     LI=subst(I,var(nvars(basering)),0);
-    for (j=1;j<=anzahlvariablen-1;j++) // set all variables 
+    for (j=1;j<=anzahlvariablen-1;j++) // set all variables
     { // t,x_1,...,x_n equal to zero
       LI=subst(LI,var(j),0);
     }
     if (size(LI)==0) // the entries of i have not constant part
-    {      
-      // check now, if the leading ideal of i contains an element 
+    {
+      // check now, if the leading ideal of i contains an element
       // which only depends on t
       LI=lead(I);
       //size(deletedvariables)=anzahlvariablen(before elimination)
-      for (j=1;j<=anzahlvariablen-1;j++) 
+      for (j=1;j<=anzahlvariablen-1;j++)
       {
         LI=subst(LI,var(j),0);
       }
-      if (size(LI)==0) // if no power of t is in lead(i) 
+      if (size(LI)==0) // if no power of t is in lead(i)
       { // (where @a is considered as a field element)
-        // if not yet all variables have been tested, go on with the 
+        // if not yet all variables have been tested, go on with the
         // next smaller variable
         // else prepare the neccessary information for return
@@ -5564 +5564 @@
         }
         else
-        {   
+        {
           execute("ring SATURATERING=("+charstr(basering)+"),("+varstr(basering)+"),("+ordstr(basering)+");");
           ideal i=imap(BASERING,i);
@@ -5575 +5575 @@
     return(eliminatelist+saturatelist);
   }
-  else // only one solution is searched for, we can do a simplified 
+  else // only one solution is searched for, we can do a simplified
   { // version of the above
-    // check if there is a solution which has the n-th component 
+    // check if there is a solution which has the n-th component
     // zero and with positive valuation,
-    // if so, then eliminate the n-th variable from 
+    // if so, then eliminate the n-th variable from
     // sat(i+x_n,t), otherwise leave i as it is;
-    // then check if the (remaining) ideal has as 
+    // then check if the (remaining) ideal has as
     // solution where the n-1st component is zero ...,
     // and procede as before; do the same for the remaining variables;
-    // this way we make sure that the remaining ideal has 
+    // this way we make sure that the remaining ideal has
     // a solution which has no component zero;
     ideal variablen; // will contain the variables which are not eliminated
@@ -5592 +5592 @@
       LI=subst(I,var(nvars(basering)),0);
       //size(deletedvariables)=anzahlvariablen-1(before elimination)
-      for (k=1;k<=size(deletedvariables);k++) 
+      for (k=1;k<=size(deletedvariables);k++)
       {
         LI=subst(LI,var(k),0);
       }
-      if (size(LI)==0) // if no power of t is in lead(I) 
+      if (size(LI)==0) // if no power of t is in lead(I)
       { // (where the X(i) are considered as field elements)
-        // get rid of var(j)   
+        // get rid of var(j)
         i=eliminate(I,var(j));
         deletedvariables[j]=1;
-        anzahlvariablen--; // if a variable is eliminated, 
+        anzahlvariablen--; // if a variable is eliminated,
                            // then the number of true variables drops
       }
@@ -5610 +5610 @@
     }
     variablen=invertorder(variablen);
-    // store also the additional variable and t, 
+    // store also the additional variable and t,
     // since they for sure have not been eliminated
     for (j=size(deletedvariables)+1;j<=nvars(basering);j++)
@@ -5616 +5616 @@
       variablen=variablen+var(j);
     }
-    // if there are variables left, then pass to a ring which 
-    // only realises these variables else we are done 
+    // if there are variables left, then pass to a ring which
+    // only realises these variables else we are done
     if (anzahlvariablen>1)
     {
@@ -5625 +5625 @@
     {
       string elring="ring ELIMINATERING=("+charstr(basering)+"),("+string(variablen)+"),(";
-    }    
-    if (size(deletedvariables)+1<nvars(basering)) // if @a was present, 
+    }
+    if (size(deletedvariables)+1<nvars(basering)) // if @a was present,
     { // the ordersting needs an additional entry
       elring=elring+"dp(1),";
     }
     elring=elring+"lp(1));";
-    execute(elring);      
+    execute(elring);
     ideal i=imap(BASERING,i);
     ideal m=imap(BASERING,m);
@@ -5644 +5644 @@
 static proc findzerosAndBasictransform (ideal i,intvec w,list zerolist,int findall,list #)
 "USAGE:  findzerosAndBasictransform(i,w,z,f[,#]); i ideal, w intvec, z list, f int,# an optional list
-ASSUME:  i is an ideal in Q[t,x_1,...,x_n,@a] and w=(w_0,...,w_n,0) 
+ASSUME:  i is an ideal in Q[t,x_1,...,x_n,@a] and w=(w_0,...,w_n,0)
          is in the tropical variety of i; @a need not be present;
          the list 'zero' contains the zeros computed in previous recursion steps;
-         if 'f' is one then all zeros should be found and returned, 
+         if 'f' is one then all zeros should be found and returned,
          otherwise only one
-RETURN:  list, each entry is a ring corresponding to one conjugacy class of 
-               zeros of the t-initial ideal inside the torus; each of the rings 
+RETURN:  list, each entry is a ring corresponding to one conjugacy class of
+               zeros of the t-initial ideal inside the torus; each of the rings
                contains the following objects
                ideal i    = the ideal i, where the variable @a (if present) has
-                            possibly been transformed according to the new 
-                            minimal polynomial, and where itself has been 
-                            submitted to the basic transform of the algorithm 
+                            possibly been transformed according to the new
+                            minimal polynomial, and where itself has been
+                            submitted to the basic transform of the algorithm
                             given by the jth zero found for the t-initial ideal;
-                            note that the new minimal polynomial has already 
+                            note that the new minimal polynomial has already
                             been added
-               poly m     = the new minimal polynomial for @a 
+               poly m     = the new minimal polynomial for @a
                             (it is zero if no @a is present)
-               list zero  = zero[k+1] is the kth component of a zero 
+               list zero  = zero[k+1] is the kth component of a zero
                             the t-initial ideal of i
-NOTE:     -  the procedure is called from inside the recursive procedure 
+NOTE:     -  the procedure is called from inside the recursive procedure
              tropicalparametrise;
-             if it is called in the first recursion, the list #[1] contains 
-             the t-initial ideal of i w.r.t. w, otherwise #[1] is an integer, 
+             if it is called in the first recursion, the list #[1] contains
+             the t-initial ideal of i w.r.t. w, otherwise #[1] is an integer,
              one more than the number of true variables x_1,...,x_n
-          -  if #[2] is present, then it is an integer which tells whether 
+          -  if #[2] is present, then it is an integer which tells whether
              ALL zeros should be found or not"
 {
@@ -5686 +5686 @@
     int anzahlvariablen=#[1];
     // compute the initial ideal of i
-    // - the last 1 just means that the variable t is the last 
+    // - the last 1 just means that the variable t is the last
     //   variable in the ring
     ideal ini=tInitialIdeal(i,w,1);
@@ -5694 +5694 @@
     int recursive=0;
     int anzahlvariablen=nvars(basering);
-    ideal ini=#[1]; // the t-initial ideal has been computed 
+    ideal ini=#[1]; // the t-initial ideal has been computed
                     // in before and was handed over
-  } 
+  }
   // collect the true variables x_1,...,x_n plus @a, if it is defined in BASERING
   ideal variablen;
   for (j=1;j<=nvars(basering)-1;j++)
-  {   
+  {
     variablen=variablen+var(j);
   }
-  // move to a polynomial ring with global monomial ordering 
+  // move to a polynomial ring with global monomial ordering
   // - the variable t is superflous,
   // the variable @a is not if it was already present
   execute("ring INITIALRING=("+charstr(basering)+"),("+string(variablen)+"),dp;");
   ideal ini=imap(BASERING,ini);
-  // compute the minimal associated primes of the 
+  // compute the minimal associated primes of the
   // initialideal over the algebraic closure;
-  // ordering the maximal ideals shall help to 
+  // ordering the maximal ideals shall help to
   // avoid unneccessary field extensions
   list absminass=absPrimdecGTZ(ini);
-  def ABSRING=absminass[1]; // the ring in which the minimal 
+  def ABSRING=absminass[1]; // the ring in which the minimal
                             // associated primes live
   setring ABSRING;
@@ -5726 +5726 @@
     // check fort the jth maximal ideal a field extension is necessary;
     // the latter condition says that @a is not in BASERING;
-    // if some of the maximal ideals needs a field extension, 
+    // if some of the maximal ideals needs a field extension,
     // then everything will live in this ring
     if ((maximalideals[j][1]!=0) and (nvars(BASERING)==anzahlvariablen))
     {
-      // define the extension ring which contains 
+      // define the extension ring which contains
       // the new variable @a, if it is not yet present
       execute("ring EXTENSIONRING=("+charstr(BASERING)+"),("+string(imap(BASERING,variablen))+",@a,"+tvar+"),(dp("+string(anzahlvariablen-1)+"),dp(1),lp(1));");
-      // phi maps x_i to x_i, @a to @a (if present in the ring), 
+      // phi maps x_i to x_i, @a to @a (if present in the ring),
       // and the additional variable
-      // for the field extension is mapped to @a as well 
+      // for the field extension is mapped to @a as well
       // -- note that we only apply phi
-      // to the list a, and in this list no @a is present; 
+      // to the list a, and in this list no @a is present;
       // therefore, it does not matter where this is mapped to
       map phi=ABSRING,imap(BASERING,variablen),@a;
     }
-    else // @a was already present in the BASERING or no 
+    else // @a was already present in the BASERING or no
     { // field extension is necessary
       execute("ring EXTENSIONRING=("+charstr(BASERING)+"),("+varstr(BASERING)+"),("+ordstr(BASERING)+");");
-      // phi maps x_i to x_i, @a to @a (if present in the ring), 
+      // phi maps x_i to x_i, @a to @a (if present in the ring),
       // and the additional variable
-      // for the field extension is mapped to @a as well respectively to 0, 
+      // for the field extension is mapped to @a as well respectively to 0,
       // if no @a is present;
-      // note that we only apply phi to the list a and to 
+      // note that we only apply phi to the list a and to
       // the replacement rule for
-      // the old variable @a, and in this list resp. 
-      // replacement rule no @a is present; 
+      // the old variable @a, and in this list resp.
+      // replacement rule no @a is present;
       // therefore, it does not matter where this is mapped to;
       if (anzahlvariablen<nvars(EXTENSIONRING)) // @a is in EXTENSIONRING
-      {      
+      {
         // additional variable is mapped to @a
-        map phi=ABSRING,imap(BASERING,variablen),@a; 
+        map phi=ABSRING,imap(BASERING,variablen),@a;
       }
       else
       {
         // additional variable is mapped to 0
-        map phi=ABSRING,imap(BASERING,variablen),0;  
+        map phi=ABSRING,imap(BASERING,variablen),0;
       }
     }
@@ -5768 +5768 @@
     poly m=maximalideals[j][1];    // extract m
     list zeroneu=maximalideals[j][2]; // extract the new zero
-    poly repl=maximalideals[j][3]; // extract the replacement rule    
-    // the list zero may very well exist as an EMPTY global list 
+    poly repl=maximalideals[j][3]; // extract the replacement rule
+    // the list zero may very well exist as an EMPTY global list
     // - in this case we have to remove it
     // in order to avoid a redefining warning
-    if (defined(zero)!=0) 
+    if (defined(zero)!=0)
     {
       if (size(zero)==0)
@@ -5783 +5783 @@
     {
       ideal i=imap(BASERING,i);
-      if (defined(zerolist)==0) // if zerolist is empty, it does not 
+      if (defined(zerolist)==0) // if zerolist is empty, it does not
       { // depend on BASERING !
         list zero=imap(BASERING,zerolist);
       }
-      else 
+      else
       {
         list zero=zerolist;
       }
     }
-    else // in BASERING was @a present 
+    else // in BASERING was @a present
     {
       ideal variablen=imap(BASERING,variablen);
-      // map i and zerolist to EXTENSIONRING replacing @a 
+      // map i and zerolist to EXTENSIONRING replacing @a
       // by the replacement rule repl
       map psi=BASERING,variablen[1..size(variablen)-1],repl,var(nvars(basering));
@@ -5805 +5805 @@
     zero[size(zero)+1]=zeroneu;
     // do now the basic transformation sending x_l -> t^-w_l*(zero_l+x_l)
-    for (l=1;l<=anzahlvariablen;l++)  
+    for (l=1;l<=anzahlvariablen;l++)
     {
       for (k=1;k<=size(i);k++)
       {
         if (l!=1) // corresponds to  x_(l-1) --  note t is the last variable
-        {        
+        {
           i[k]=substitute(i[k],var(l-1),(zeroneu[l]+var(l-1))*t^(-w[l]));
         }
@@ -5822 +5822 @@
     for (l=1;l<=ncols(i);l++)
     {
-      if (wdegs[l]<0) // if wdegs[l]==0 there is no need to divide, 
+      if (wdegs[l]<0) // if wdegs[l]==0 there is no need to divide,
       { // and we made sure that it is no positive
         i[l]=i[l]/t^(-wdegs[l]);
@@ -5828 +5828 @@
     }
     // since we want to consider i now in the ring (Q[@a]/m)[t,x_1,...,x_n]
-    // we can  reduce i modulo m, so that "constant terms" 
+    // we can  reduce i modulo m, so that "constant terms"
     // which are "zero" since they
     // are in m will disappear; simplify(...,2) then really removes them;
@@ -5835 +5835 @@
     export(i);
     export(m);
-    export(zero);    
+    export(zero);
     extensionringlist[j]=EXTENSIONRING;
     kill EXTENSIONRING;
@@ -5847 +5847 @@
 static proc ordermaximalideals (list minassi,int anzahlvariablen)
 "USAGE:      ordermaximalideals(minassi); minassi list
-ASSUME:      minassi is a list of maximal ideals (together with the information 
-             how many conjugates it has), where the first polynomial is the 
-             minimal polynomial of the last variable in the ring which is 
+ASSUME:      minassi is a list of maximal ideals (together with the information
+             how many conjugates it has), where the first polynomial is the
+             minimal polynomial of the last variable in the ring which is
              considered as a parameter
-RETURN:      list, the procedure orders the maximal ideals in minassi according 
-                   to how many new variables are needed (namely none or one) to 
-                   describe the zeros of the ideal, and accordingly to the 
+RETURN:      list, the procedure orders the maximal ideals in minassi according
+                   to how many new variables are needed (namely none or one) to
+                   describe the zeros of the ideal, and accordingly to the
                    degree of the corresponding minimal polynomial
                    l[j][1] = the minimal polynomial for the jth maximal ideal
-                   l[j][2] = list, the k+1st entry is the kth coordinate of the 
-                                   zero described by the maximal ideal in terms 
+                   l[j][2] = list, the k+1st entry is the kth coordinate of the
+                                   zero described by the maximal ideal in terms
                                    of the last variable
-                   l[j][3] = poly, the replacement for the old variable @a 
+                   l[j][3] = poly, the replacement for the old variable @a
 NOTE:        if a maximal ideal contains a variable, it is removed from the list;
              the procedure is called by findzerosAndBasictransform"
@@ -5866 +5866 @@
   int pruefer;       // is set one if a maximal ideal contains a variable
   list minassisort;  // will contain the output
-  for (j=1;j<=size(minassi);j++){minassisort[j]=0;} // initialise minassisort 
+  for (j=1;j<=size(minassi);j++){minassisort[j]=0;} // initialise minassisort
                                                     // to fix its initial length
   list zwischen;     // needed for reordering
-  list zero;         // (a_1,...,a_n)=(zero[2],...,zero[n+1]) will be 
+  list zero;         // (a_1,...,a_n)=(zero[2],...,zero[n+1]) will be
                      // a common zero of the ideal m
   poly nf;           // normalform of a variable w.r.t. m
-  poly minimalpolynomial;  // minimal polynomial for the field extension 
+  poly minimalpolynomial;  // minimal polynomial for the field extension
   poly parrep;  // the old variable @a possibly has to be replaced by a new one
-  // compute for each maximal ideal the number of new variables, which are 
-  // needed to describe its zeros -- note, a new variable is needed 
+  // compute for each maximal ideal the number of new variables, which are
+  // needed to describe its zeros -- note, a new variable is needed
   // if the first entry of minassi[j][1] is not the last variable
-  // store the value a variable reduces to in the list a; 
+  // store the value a variable reduces to in the list a;
   for (j=size(minassi);j>=1;j--)
   {
@@ -5885 +5885 @@
       minimalpolynomial=0;
     }
-    zero[1]=poly(0);         // the first entry in zero and in 
+    zero[1]=poly(0);         // the first entry in zero and in
                              // neuevariablen corresponds to the variable t,
     minassi[j][1]=std(minassi[j][1]);
@@ -5891 +5891 @@
     {
       // zero_k+1 is the normal form of the kth variable modulo m
-      zero[k+1]=reduce(var(k),minassi[j][1]); 
-      // if a variable reduces to zero, then the maximal 
+      zero[k+1]=reduce(var(k),minassi[j][1]);
+      // if a variable reduces to zero, then the maximal
       // ideal contains a variable and we can delete it
       if (zero[k+1]==0)
@@ -5899 +5899 @@
       }
     }
-    // if anzahlvariablen<nvars(basering), then the old ring 
+    // if anzahlvariablen<nvars(basering), then the old ring
     // had already an additional variable;
     // the old parameter @a then has to be replaced by parrep
@@ -5908 +5908 @@
     // if the maximal ideal contains a variable, we simply delete it
     if (pruefer==0)
-    {      
+    {
       minassisort[j]=list(minimalpolynomial,zero,parrep);
     }
-    // otherwise we store the information on a, neuevariablen 
+    // otherwise we store the information on a, neuevariablen
     // and neuvar together with the ideal
     else
@@ -5920 +5920 @@
     }
   }
-  // sort the maximal ideals ascendingly according to the 
+  // sort the maximal ideals ascendingly according to the
   // number of new variables needed to
   // express the zero of the maximal ideal
@@ -5927 +5927 @@
     l=j;
     for (k=j-1;k>=1;k--)
-    {      
+    {
       if (deg(minassisort[l][1])<deg(minassisort[k][1]))
       {
@@ -5962 +5962 @@
 static proc verticesTropicalCurve (def tp,list #)
 "USAGE:      verticesTropicalCurve(tp[,#]); tp list, # optional list
-ASSUME:      tp is represents an ideal in Z[x,y] representing a tropical 
+ASSUME:      tp is represents an ideal in Z[x,y] representing a tropical
              polynomial (in the form of the output of the procedure tropicalise)
              defining a tropical plane curve
-RETURN:      list, each entry corresponds to a vertex in the tropical plane 
+RETURN:      list, each entry corresponds to a vertex in the tropical plane
                    curve defined by tp
                    l[i][1] = x-coordinate of the ith vertex
                    l[i][2] = y-coordinate of the ith vertex
-                   l[i][3] = a polynomial whose monimials mark the vertices in 
-                             the Newton polygon corresponding to the entries in 
+                   l[i][3] = a polynomial whose monimials mark the vertices in
+                             the Newton polygon corresponding to the entries in
                              tp which take the common minimum at the ith vertex
 NOTE:      - the information in l[i][3] represents the subdivision of the Newton
-             polygon of tp (respectively a polynomial which defines tp); 
-           - if # is non-empty and #[1] is the string 'max', then in the 
-             computations minimum and maximum are exchanged; 
-           - if # is non-empty and the #[1] is not a string, only the vertices 
+             polygon of tp (respectively a polynomial which defines tp);
+           - if # is non-empty and #[1] is the string 'max', then in the
+             computations minimum and maximum are exchanged;
+           - if # is non-empty and the #[1] is not a string, only the vertices
              will be computed and the information on the Newton subdivision will
              be omitted;
-           - here the tropical polynomial is supposed to be the MINIMUM of the 
-             linear forms in tp, unless the optional input #[1] is the 
+           - here the tropical polynomial is supposed to be the MINIMUM of the
+             linear forms in tp, unless the optional input #[1] is the
              string 'max'
-           - the procedure is called from tropicalCurve and from 
+           - the procedure is called from tropicalCurve and from
              conicWithTangents"
 {
-  // if you insert a single polynomial instead of an ideal representing 
+  // if you insert a single polynomial instead of an ideal representing
   // a tropicalised polynomial,
-  // then we compute first the tropicalisation of this polynomial 
+  // then we compute first the tropicalisation of this polynomial
   // -- this feature is not documented in the above help string
   if (typeof(tp)=="poly")
@@ -5996 +5996 @@
   }
   int i,j,k,l,z; // indices
-  // make sure that no constant entry of tp has type int since that 
+  // make sure that no constant entry of tp has type int since that
   // would lead to trouble
   // when using the procedure substitute
@@ -6014 +6014 @@
   int e=1;
   option(redSB);
-  // for each triple (i,j,k) of entries in tp check if they have a 
-  // point in common and if they attain at this point the minimal 
+  // for each triple (i,j,k) of entries in tp check if they have a
+  // point in common and if they attain at this point the minimal
   // possible value for all linear forms in tp
   for (i=1;i<=size(tp)-2;i++)
@@ -6068 +6068 @@
             e++;
           }
-        }          
+        }
       }
     }
@@ -6091 +6091 @@
 static proc bunchOfLines (def tp,list #)
 "USAGE:      bunchOfLines(tp[,#]); tp list, # optional list
-ASSUME:      tp is represents an ideal in Q[x,y] representing a tropical 
+ASSUME:      tp is represents an ideal in Q[x,y] representing a tropical
              polynomial (in the form of the output of the procedure tropicalise)
              defining a bunch of ordinary lines in the plane,
              i.e. the Newton polygone is a line segment
-RETURN:      list, see the procedure tropicalCurve for an explanation of 
+RETURN:      list, see the procedure tropicalCurve for an explanation of
                    the syntax of this list
-NOTE:      - the tropical curve defined by tp will consist of a bunch of 
-             parallel lines and throughout the procedure a list with the 
-             name bunchoflines is computed, which represents these lines and 
+NOTE:      - the tropical curve defined by tp will consist of a bunch of
+             parallel lines and throughout the procedure a list with the
+             name bunchoflines is computed, which represents these lines and
              has the following interpretation:
-             list, each entry corresponds to a vertex in the tropical plane 
+             list, each entry corresponds to a vertex in the tropical plane
                    curve defined by tp
                    l[i][1] = the equation of the ith line in the tropical curve
-                   l[i][2] = a polynomial whose monimials mark the vertices in 
-                             the Newton polygon corresponding to the entries in 
+                   l[i][2] = a polynomial whose monimials mark the vertices in
+                             the Newton polygon corresponding to the entries in
                              tp which take the common minimum at the ith vertex
            - the information in l[i][2] represents the subdivision of the Newton
-             polygon of tp (respectively a polynomial which defines tp); 
-           - if # is non-empty and #[1] is the string 'max', then in the 
-             computations minimum and maximum are exchanged; 
-           - if # is non-empty and the #[1] is not a string, only the vertices 
-             will be computed and the information on the Newton subdivision 
+             polygon of tp (respectively a polynomial which defines tp);
+           - if # is non-empty and #[1] is the string 'max', then in the
+             computations minimum and maximum are exchanged;
+           - if # is non-empty and the #[1] is not a string, only the vertices
+             will be computed and the information on the Newton subdivision
              will be omitted;
-           - here the tropical polynomial is supposed to be the MINIMUM of the 
-             linear forms in tp, unless the optional input #[1] is the 
+           - here the tropical polynomial is supposed to be the MINIMUM of the
+             linear forms in tp, unless the optional input #[1] is the
              string 'max'
            - the procedure is called from tropicalCurve"
@@ -6132 +6132 @@
   intvec direction=leadexp(detropicalise(tp[1]))-leadexp(detropicalise(tp[2]));
   direction=direction/gcd(direction[1],direction[2]);
-  // change the coordinates in such a way, that the Newton polygon 
+  // change the coordinates in such a way, that the Newton polygon
   // lies on the x-axis
-  if (direction[1]==0) // there is no x-term - exchange x and y 
+  if (direction[1]==0) // there is no x-term - exchange x and y
   { // and get rid of the new y part
     for (i=1;i<=size(tp);i++)
@@ -6148 +6148 @@
     }
   }
-  // For all tuples (i,j) of entries in tp check if they attain 
+  // For all tuples (i,j) of entries in tp check if they attain
   // at their point of intersection
   // the minimal possible value for all linear forms in tp
@@ -6164 +6164 @@
       {
         vergleich=substitute(tp[l],var(1),px);
-        if (vergleich==wert)  
+        if (vergleich==wert)
         {
           newton=newton+detropicalise(oldtp[l]);
@@ -6175 +6175 @@
         e++;
       }
-    }          
+    }
   }
   // if a vertex appears several times, only its first occurence will be kept