Changeset e1f372 in git

Timestamp:

Sep 7, 2010, 7:37:52 PM (14 years ago)

Author:

Thomas Markwig <keilen@…>

Branches:

(u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')

Children:

3b614ecf39de68c3a807a600dd27a5329966b5cd

Parents:

e128fda56ac773be45f4a851d82371ff728c25a9

Message:

Procedures puiseuxExpansion and displayPuiseuxExpansion added.
For this tropicalLifting and tropicalparametrise had to be adjusted.
hnoether.lib is now needed to compute the Newton polygon of a plane curve.


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

File:

• Singular/LIB/tropical.lib (modified) (348 diffs)

Singular/LIB/tropical.lib

@@ -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
+@*  - puiseuxExpansion   computes a Newton-Puiseux expansion of a plane curve
+                         singularity 
+@*  - 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
+  puiseuxExpansion()         computes a Newton-Puiseux expansion in the plane
+  displayPuiseuxExpansion()  displays the output of puiseuxExpansion
 
 PROCEDURES FOR DRAWING TROPICAL CURVES:
@@ -107 +111 @@
   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 +119 @@
   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 +125 @@
   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
   tDetropicalise()        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
@@ -156 +160 @@
 /// - eliminatecomponents
 /// - findzerosAndBasictransform
-/// - ordermaximalideals
+/// - ordermaximalideals 
 /// - verticesTropicalCurve
 /// - bunchOfLines
@@ -202 +206 @@
 LIB "primdec.lib";
 LIB "absfact.lib";
+LIB "hnoether.lib";
 //////////////////////////////////////////////////////////////////////////////
 
 ///////////////////////////////////////////////////////////////////////////////
-/// 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
-@*         'noResubst'         : avoids the computation of the resubstitution
+@*         'puiseux'            : n=1 and i is generated by one equation
+@*         'noResubst'          : avoids the computation of the resubstitution
 RETURN:  IF THE OPTION 'findAll' WAS NOT SET THEN:
 @*       list, containing one lifting of the given point (w_1/w_0,...,w_n/w_0)
-               in the tropical variety of i to a point in V(i) over Puiseux
+               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:
@@ -249 +255 @@
 @*       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"
@@ -331 +337 @@
   int j,k,l,jj,kk;  // index variables
   // work through the optionional parameters
-  int isprime,iszerodim,isintrop,gfanold,findall,noabs,nogfan,noresubst;
+  int isprime,iszerodim,isintrop,gfanold,findall,noabs,nogfan,noresubst,puiseux;
   for (j=1;j<=size(#);j++)
   {
@@ -358 +364 @@
       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
+    if (#[j]=="puiseux")
+    {
+      int puiseuxgood=0;
+      // test, if the option puiseux makes sense, i.e. we are considering a plane curve
+      if ((size(i)==1) and (nvars(basering)==2))
+      {
+        puiseuxgood=1;
+      }
+      // the case, where the base field has a parameter and a minimal polynomial is
+      // treated by an additional variable (which should be the last variable)
+      // and an ideal containing the minimal polynomial as first entry
+      if ((size(i)==2) and (nvars(basering)==3))
+      {
+        // check if the first entry is the minimal polynomial
+        poly mpcheck=i[1];
+        if (substitute(mpcheck,var(1),0,var(2),0)==mpcheck)
+        {
+          puiseuxgood=1;
+        }
+        kill mpcheck;
+      }
+      if (puiseuxgood==0)
+      {
+        ERROR("The option puiseux is not allowed for this ring. See: help tropicalLifting; for more information");
+      }
+      puiseux=1;
+      nogfan=1;  // if puiseux is set, then gfan should not be used
+    }
+    // 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")
@@ -371 +405 @@
     }
   }
-  // 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
@@ -385 +419 @@
   {
     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)
@@ -392 +426 @@
   }
   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];
@@ -402 +436 @@
     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++)
@@ -428 +462 @@
   {
     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++)
@@ -454 +488 @@
     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;
@@ -493 +527 @@
   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
@@ -501 +535 @@
     if (noabs==1) // do not use absolute primary decomposition
     {
-      list TP=list(tropicalparametriseNoabs(i,w,ordnung,gfanold,nogfan,ini));
+      list TP=list(tropicalparametriseNoabs(i,w,ordnung,gfanold,nogfan,puiseux,ini));
     }
     else // use absolute primary decomposition
     {
-      list TP=tropicalparametrise(i,w,ordnung,gfanold,findall,nogfan,ini);
+      list TP=tropicalparametrise(i,w,ordnung,gfanold,findall,nogfan,puiseux,ini);
     }
     // 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
@@ -534 +568 @@
         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
@@ -545 +579 @@
           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];
@@ -590 +624 @@
       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
@@ -611 +645 @@
         */
         // 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;
@@ -622 +656 @@
           // 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
@@ -629 +663 @@
           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)
@@ -642 +676 @@
           }
           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)
@@ -663 +697 @@
       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
@@ -675 +709 @@
       "The procedure will be restarted with the option 'findAll'.";
       "Go on by hitting RETURN!";
-      findall=1;
+      findall=1;    
       noabs=0;
       setring CUTDOWNRING;
@@ -681 +715 @@
       "i";i;
       "ini";tInitialIdeal(i,w,1);
-
+      
 /*
       setring GRUNDRING;
@@ -699 +733 @@
     }
   }
-  // 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)
@@ -708 +742 @@
   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
@@ -752 +786 @@
    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;
@@ -780 +814 @@
    // 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;
@@ -835 +869 @@
       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]]";  
       }
     }
@@ -872 +906 @@
       }
       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+">";
-      }
+      }      
     }
     "";
@@ -909 +943 @@
       }
     }
-  }
+  }      
 }
 example
@@ -921 +955 @@
 }
 
+proc puiseuxExpansion (poly f,int n,list #)
+"USAGE:  puiseuxExpansion(f,n,#); f poly, n int, # list
+ASSUME:  f is a polynomial in two variables and the base field is either
+         the field of rational numbers or a finite extension thereof;
+         monomial ordering is assumed to be local;
+         the optional parameter # can be the string 'subst'
+RETURN:  list, where each entry of the list l describes the Newton-Puiseux 
+@*             parametrisations of one branch of the plane curve singularity 
+@*             at the origin defined by f; only the first n terms of each 
+@*             parametetrisation are computed
+@*             l[i][1] = is a ring
+@*             l[i][2] = int
+@*             l[i][3] = list
+@*
+@*       WE NOW DESCRIBE THE LIST ENTRIES l[i] IN MORE DETAIL: 
+@*       - the ring l[i][1] contains an ideal LIFT and the Newton-Puiseux
+           parametrisation of the branch is given by x=t^N and y=LIFT[1],
+           where N=l[i][2]
+@*       - if the base field had a parameter and a minimal polynomial, then
+           the new base field will have a parameter and a new minimal polynomial,
+           and LIFT[2] describes how the old parameter can be computed from the new one
+@*       - if the option subst was set l[i][3] contains the polynomial where
+           y has been substituted by y(t^{1/N})
+REMARK:  - it is best to use the procedure displayPuiseuxExpansion to 
+           display the result
+@*       - the procedure requires the @sc{Singular} procedure absPrimdecGTZ to be
+           present in the package primdec.lib
+EXAMPLE:   example puiseuxExpansion;   shows an example"
+{
+  if (char(basering)!=0)
+  {
+    ERROR("In positive characteristic a Puiseux expansion will not in general exist!");
+  }
+  if ((npars(basering)>1) or ((npars(basering)==1) and (minpoly==0)))
+  {
+    ERROR("The procedure is not implemented for this base field!");
+  }
+  if (nvars(basering)!=2)
+  {
+    ERROR("The base ring should depend on exactly two variables.");
+  }
+  // if the ordering is not local, change to a local ordering
+  if ((1<var(1)) or (1<var(2)))
+  {
+    def GLOBALRING=basering;
+    execute("ring LOCALRING=("+charstr(basering)+"),("+varstr(basering)+"),ds;");
+    poly f=imap(GLOBALRING,f);
+  }
+  // check if a substitution is necessary
+  int noResubst;
+  if (size(#)>1)
+  {
+    if (#[1]=="subst")
+    {
+      noResubst=0;
+    }
+  }
+  // compute the Newton polygon 
+  int jj,zw;
+  intvec w;
+  int ggteiler;
+  list NewtP=newtonpoly(f);
+  list tls;
+  list pexp;
+  // if the base field has a minimal polynomial change the base ring and the ideal
+  if (minpoly!=0)
+  {
+    poly mp=minpoly;
+    def OLDRING=basering;
+    execute("ring NEWRING=0,("+varstr(basering)+","+parstr(basering)+"),ds;");
+    ideal I=imap(OLDRING,mp),imap(OLDRING,f);
+  }
+  else
+  {
+    ideal I=f;
+  }
+  // for each facet of the Newton polygon compute the corresponding parametrisations
+  // using tropicalLifting with the option "puiseux" which avoids gfan
+  for (jj=1;jj<=size(NewtP)-1;jj++)
+  {
+    w=NewtP[jj]-NewtP[jj+1];
+    ggteiler=gcd(w[1],w[2]);
+    zw=w[1]/ggteiler;
+    w[1]=w[2]/ggteiler;
+    w[2]=zw;
+    // if we have introduced a third variable for the parameter, then w needs a third component
+    if (nvars(basering)==3)
+    {
+      w[3]=0;
+    }
+    if (noResubst==0)
+    {
+      tls=tropicalLifting(I,w,n,"findAll","puiseux");
+    }
+    else
+    {
+      tls=tropicalLifting(I,w,n,"findAll","puiseux","noResubst");
+    }
+    pexp=pexp+tls;
+  }
+  // kill rings that are no longer needed
+  if (defined(NEWRING))
+  {
+    setring OLDRING;
+    kill NEWRING;
+  }  
+  if (defined(GLOBALRING))
+  {
+    setring GLOBALRING;
+    kill LOCALRING;
+  }  
+  // remove the third entry in the list of parametrisations since we know
+  // that none of the exponents in the parametrisation will be negative
+  for (jj=1;jj<=size(pexp);jj++)
+  {
+    pexp[jj]=delete(pexp[jj],3);
+  }
+  return(pexp);
+}
+example
+{
+   "EXAMPLE:";
+   echo=2;
+   ring r=0,(x,y),ds;
+   poly f=x2-y4+x5y7;
+   puiseuxExpansion(puiseuxExpansion(f,3));
+}
+
+proc displayPuiseuxExpansion (list puiseux,list #)
+"USAGE:    displayPuiseuxExpansion(puiseux[,#]); puiseux list, # list
+ASSUME:    puiseux is the output of puiseuxExpansion; the optional parameter
+           # can be the string 'subst'
+RETURN:    none
+NOTE:      - the procedure displays the output of the procedure puiseuxExpansion
+@*         - if the optional parameter 'subst' is given, then the expansion is
+             substituted into the polynomial and the result is displayed
+@*         - if the base field had a parameter and a minimal polynomial, then the
+             new base field will have a parameter and a minimal polynomial;
+             var(2) is the old parameter and it is displayed how the old parameter
+             can be computed from the new one
+EXAMPLE:   example displayPuiseuxExpansion;   shows an example"
+{
+  int j;
+  // if the procedure has to display more than one expansion
+  if (typeof(puiseux[1])=="list")
+  {
+    for (j=1;j<=size(puiseux);j++)
+    {
+      "=============================";
+      string(j)+". Expansion:";
+      "";
+      displayPuiseuxExpansion(puiseux[j],#);
+      "";
+    }
+  }
+  // if the procedure has to display only one expansion
+  else
+  {
+    list variablen;
+    for (j=2;j<=nvars(basering);j++)
+    {
+      variablen[j-1]=string(var(j));
+    }
+    def LIFTRing=puiseux[1];
+    int N=puiseux[2];
+    string LIFTpar=parstr(LIFTRing);
+    string Kstring="Q";
+    setring LIFTRing;
+    "The Puiseux expansion lives in the ring";
+    if ((size(LIFTpar)==0) and (N==1))
+    {
+      Kstring+"[[t]]"; 
+    }
+    if ((size(LIFTpar)==0) and (N!=1))
+    {
+      Kstring+"[[t^(1/"+string(N)+")]]"; 
+    }
+    if ((size(LIFTpar)!=0) and (N!=1))
+    {    
+      Kstring+"["+LIFTpar+"]/"+string(minpoly)+"[[t^(1/"+string(N)+")]]";  
+    }
+    if ((size(LIFTpar)!=0) and (N==1))
+    {    
+      Kstring+"["+LIFTpar+"]/"+string(minpoly)+"[[t]]";  
+    }
+    "";
+    "The expansion has the form:";
+    for (j=1;j<=size(LIFT);j++)
+    {
+      if (ncols(LIFT)==size(variablen))
+      {
+        variablen[j]+"="+displaypoly(LIFT[j],N,0,1);
+      }
+      else
+      {
+        "var("+string(j)+")="+displaypoly(LIFT[j],N,0,1);
+      }
+    }
+    if (size(#)>0)
+    {
+      if (#[1]=="subst")
+      {
+        "";
+        "Substituting the expansion into the polynomial gives:";
+        "f="+puiseux[3][size(puiseux[3])];
+      }
+    }
+  }      
+}
+example
+{
+   "EXAMPLE:";
+   echo=2;
+   ring r=0,(x,y),ds;
+   poly f=x2-y4+x5y7;
+   displayPuiseuxExpansion(puiseuxExpansion(f,3));
+}
 
 ///////////////////////////////////////////////////////////////////////////////
-/// 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"
@@ -979 +1230 @@
     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;
@@ -998 +1249 @@
   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.
@@ -1008 +1259 @@
     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
@@ -1027 +1278 @@
     {
       bb=koeffizienten(tp[i],2);
-    }
+    }    
   }
   if ((aa!=0) or (bb!=0))
@@ -1036 +1287 @@
     }
   }
-  // 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
@@ -1046 +1297 @@
     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)
     {
@@ -1067 +1318 @@
       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
@@ -1097 +1348 @@
     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++)
     {
@@ -1113 +1364 @@
         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])))
           {
@@ -1119 +1370 @@
             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);
@@ -1164 +1415 @@
     }
   }
-  // 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.
@@ -1183 +1434 @@
   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
       {
@@ -1198 +1449 @@
       }
       // 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
@@ -1230 +1481 @@
     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;
@@ -1236 +1487 @@
   {
     // 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;
   }
@@ -1264 +1515 @@
     }
   }
-  // 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.
@@ -1281 +1532 @@
 // 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];
@@ -1309 +1560 @@
 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"
@@ -1348 +1599 @@
   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!");      
     }
     // if the characteristic of the base field is not 0 then replace the base field
@@ -1371 +1622 @@
       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\\{";
       }
@@ -1384 +1635 @@
       for (j=1;j<=size(f);j++)
       {
-        texf=texf+texPolynomial(f[j]);
+        texf=texf+texPolynomial(f[j]);    
         if (j<size(f))
         {
@@ -1393 +1644 @@
           texf=texf+"\\}";
         }
-      }
+      }    
       list graph=tropicalCurve(f,#); // the graph of the tropical polynomial f
     }
@@ -1411 +1662 @@
 \\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
@@ -1449 +1700 @@
 
    \\begin{center}
-       "+texDrawNewtonSubdivision(graph,#)+"
+       "+texDrawNewtonSubdivision(graph,#)+" 
    \\end{center}
 \\end{document}";
@@ -1456 +1707 @@
     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
@@ -1483 +1734 @@
 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"
@@ -1514 +1765 @@
   { // write the tropical polynomial defined by f
     if (size(#)==0)
-    {
+    {      
       texf="\\min\\{";
     }
@@ -1523 +1774 @@
     for (j=1;j<=size(f);j++)
     {
-      texf=texf+texPolynomial(f[j]);
+      texf=texf+texPolynomial(f[j]);    
       if (j<size(f))
       {
@@ -1532 +1783 @@
         texf=texf+"\\}";
       }
-    }
+    }    
     list graph=tropicalCurve(f,#); // the graph of the tropical polynomial f
   }
@@ -1540 +1791 @@
    \\parindent0cm
    \\begin{center}
-      \\large\\bf The Newtonsubdivison of
+      \\large\\bf The Newtonsubdivison of 
       \\begin{displaymath}
           f="+texf+"
@@ -1548 +1799 @@
 
    \\begin{center}
-"+texDrawNewtonSubdivision(graph)+
+"+texDrawNewtonSubdivision(graph)+  
 "   \\end{center}
 
@@ -1554 +1805 @@
   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);
 }
@@ -1579 +1830 @@
 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"
@@ -1618 +1869 @@
     {
       if (typeof(f[1])=="list")
-      {
+      {        
         list graph=f;
       }
@@ -1630 +1881 @@
         {
           ERROR("This is no valid input.");
-        }
+        }        
       }
     }
@@ -1647 +1898 @@
   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)
@@ -1659 +1910 @@
   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
@@ -1684 +1935 @@
             {
               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;
@@ -1692 +1943 @@
         }
       }
-      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
     }
@@ -1700 +1951 @@
     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++;
@@ -1710 +1961 @@
       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
       }
@@ -1719 +1970 @@
     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];
@@ -1735 +1986 @@
       }
       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);   
   }
 }
@@ -1770 +2021 @@
 // 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);
@@ -1784 +2035 @@
 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
@@ -1791 +2042 @@
                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"
@@ -1852 +2103 @@
 
 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"
@@ -1890 +2141 @@
    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");
@@ -1900 +2151 @@
    poly h=x22y11+x19y10+x17y9+x16y9+x12y7+x9y6+x7y5+x2y3+x14y8;
 // its j-invariant is
-   jInvariant(h);
+   jInvariant(h);  
 }
 
@@ -1919 +2170 @@
 @*                 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
@@ -1943 +2194 @@
   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++)
@@ -1964 +2215 @@
   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++)
@@ -2040 +2291 @@
    We consider the concic through the following five points:
    \\begin{displaymath}
-";
+";  
   string texf=texDrawTropical(graphf,list("",scalefactor));
   for (i=1;i<=size(points);i++)
@@ -2077 +2328 @@
 \\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));
@@ -2107 +2358 @@
 // 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
@@ -2139 +2390 @@
 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"
@@ -2164 +2415 @@
     {
       tropicalf[i]=tropicalf[i]+exp[j]*var(j);
-    }
+    }    
     f=f-lead(f);
   }
@@ -2204 +2455 @@
 /////////////////////////////////////////////////////////////////////////
 
-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"
@@ -2218 +2469 @@
   // 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)
   {
@@ -2234 +2485 @@
         initialf=initialf+lead(f);
       }
-    }
+    }    
     f=f-lead(f);
   }
@@ -2254 +2505 @@
 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!
@@ -2282 +2533 @@
   // ... 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;
@@ -2293 +2544 @@
   }
   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);
@@ -2548 +2799 @@
 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
@@ -2569 +2820 @@
     \\end{texdraw}";
   return(texdrawtp);
-}
+}  
 example
 {
@@ -2586 +2837 @@
 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
+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
-@*       - 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
+@*       - 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 the further optional entry of type poly
-@*       - one can add a string as last opional argument to the list #;
-           it can be used to insert further texdraw commands (e.g. to have
-           a lighter image as when called from inside conicWithTangents);
+@*       - one can add a string as last opional argument to the list #; 
+           it can be used to insert further texdraw commands (e.g. to have 
+           a lighter image as when called from inside conicWithTangents); 
 @*       - the list # is optional and may as well be empty
 EXAMPLE:     example texDrawTropical;   shows an example"
 {
-  // there is one possible argument, which is not explained to the user;
+  // there is one possible argument, which is not explained to the user; 
   // it is used to draw several tropical curves; there we want to suppress
-  // the weights sometimes; this is done by handing over the string "noweights"
-  int i,j;
+  // the weights sometimes; this is done by handing over the string "noweights"  
+  int i,j;  
   int noweights; // controls if weights should be drawn or not
   for (i=1;i<=size(#);i++)
@@ -2616 +2867 @@
     }
   }
-  // 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());
@@ -2636 +2887 @@
     }
     // 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;
@@ -2667 +2918 @@
   int nachkomma=2; // number of decimals for the scalefactor
   number sf=1; // correction factor for scalefactor
-  // if no scale factor was handed over to the procedure, use the
+  // if no scale factor was handed over to the procedure, use the 
   // one computed by minScaleFactor;
   // check first if a scale factor has been handed over
@@ -2675 +2926 @@
   {
     // if the scalefactor as polynomial was handed over, get it
-    if (typeof(#[i])=="poly")
+    if (typeof(#[i])=="poly") 
     {
       poly scalefactor=#[2];
       scfpresent=1;
     }
-    // if the procedure is called for drawing more than one tropical curve
+    // if the procedure is called for drawing more than one tropical curve 
     // then scalefactor,sf,nachkomma,minx,miny,maxx,maxy,centerx,centery
     // has been handed over to the procedure
@@ -2697 +2948 @@
     }
     i++;
-  }
+  }    
   // if no scalefactor was handed over we take the one computed in SCF
   if (scfpresent==0)
@@ -2712 +2963 @@
   {
     // if the curve is a bunch of lines no vertex has to be drawn
-    if (bunchoflines==0)
+    if (bunchoflines==0) 
     {
       texdrawtp=texdrawtp+"
@@ -2718 +2969 @@
     }
     // 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)+")";
@@ -2736 +2987 @@
     // 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+"
@@ -2836 +3087 @@
   // check if scaling is necessary
   if (scalefactor<1)
-  {
+  {    
     subdivision=subdivision+"
        \\relunitscale"+ decimal(scalefactor);
@@ -2844 +3095 @@
   {
     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])+")
 
@@ -2855 +3106 @@
   {
     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])+")";
   }
@@ -2866 +3117 @@
       {
         if (scalefactor > 2)
-        {
+        {      
           subdivision=subdivision+"
         \\move ("+string(i)+" "+string(j)+") \\fcir f:0.6 r:"+decimal(2/(10*scalefactor),size(string(int(scalefactor)))+1);
@@ -2876 +3127 @@
         }
       }
-    }
+    } 
     if ((shiftvector[1]!=0) or (shiftvector[2]!=0))
     {
@@ -2883 +3134 @@
     }
   }
-  // deal with the pathological cases
+  // deal with the pathological cases 
   if (size(boundary)==1) // then the Newton polytope is a point
   {
@@ -2938 +3189 @@
   {
     if (scalefactor > 2)
-    {
+    {      
       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);
     }
@@ -2946 +3197 @@
     {
       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/(16*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+"
@@ -2967 +3218 @@
    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);
 }
@@ -2975 +3226 @@
 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"
@@ -2990 +3241 @@
    ";
   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++)
@@ -3000 +3251 @@
     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
@@ -3033 +3284 @@
   {
     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";
   }
@@ -3040 +3291 @@
   {
     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])+")";
   }
@@ -3047 +3298 @@
   {
     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";
   }
@@ -3056 +3307 @@
    "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);
@@ -3068 +3319 @@
 
 ///////////////////////////////////////////////////////////////////////////////
-/// Auxilary Procedures
+/// Auxilary Procedures 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -3074 +3325 @@
 "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;
@@ -3114 +3365 @@
 {
   // 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);
@@ -3124 +3375 @@
   // 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)
@@ -3143 +3394 @@
         initialf=initialf+koef*leadmonom(f);
       }
-    }
+    }    
     f=f-lead(f);
   }
@@ -3168 +3419 @@
 {
   // 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
@@ -3179 +3430 @@
   // keep only the largest ones
   int vglgewicht;
-  f=f-lead(f);
+  f=f-lead(f);  
   while (f!=0)
   {
@@ -3197 +3448 @@
         initialf=initialf+koef*leadmonom(f);
       }
-    }
+    }    
     f=f-lead(f);
   }
@@ -3216 +3467 @@
 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"
@@ -3245 +3496 @@
 /////////////////////////////////////////////////////////////////////////
 
-proc detropicalise (def p)
+proc detropicalise (def p) 
 "USAGE:   detropicalise(f); f poly or f list
-ASSUME:   if f is of type poly then t is a linear polynomial with
-          an arbitrary constant term and positive integer coefficients
+ASSUME:   if f is of type poly then t is a linear polynomial with 
+          an arbitrary constant term and positive integer coefficients 
           as further coefficients;
 @*        if f is of type list then f is a list of polynomials of
           the type just described in before
 RETURN:   poly, the detropicalisation of f ignoring the constant parts
-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"
@@ -3261 +3512 @@
   {
     if (leadmonom(p)!=1)
-    {
+    { 
       dtp=dtp*leadmonom(p)^int(leadcoef(p));
     }
@@ -3278 +3529 @@
 /////////////////////////////////////////////////////////////////////////
 
-proc tDetropicalise (def p)
+proc tDetropicalise (def p) 
 "USAGE:   tDetropicalise(f); f poly or f list
-ASSUME:   if f is of type poly then f is a linear polynomial with an
-          integer constant term and positive integer coefficients
+ASSUME:   if f is of type poly then f is a linear polynomial with an 
+          integer constant term and positive integer coefficients 
           as further coefficients;
 @*        if f is of type list then it is a list of polynomials of
-          the type just described in before
+          the type just described in before  
 RETURN:   poly, the detropicalisation of f over the field Q(t)
 NOTE:     the output will be a term where the coeffiecient is a Laurent
@@ -3293 +3544 @@
   if (typeof(p)=="list")
   {
-    int i;
+    int i;    
     for (i=1;i<=size(p);i++)
     {
@@ -3305 +3556 @@
     {
       if (leadmonom(p)!=1)
-      {
+      { 
         dtp=dtp*leadmonom(p)^int(leadcoef(p));
       }
@@ -3363 +3614 @@
 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
@@ -3417 +3668 @@
    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 ...
@@ -3438 +3689 @@
 
 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"
@@ -3460 +3711 @@
   {
     if (size(#)!=0)
-    {
+    {      
       k=random(0,1);
     }
     if (k==0)
-    {
+    {      
       j=random(ug,og);
       randomPolynomial=randomPolynomial+t^j*m[i];
@@ -3494 +3745 @@
 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*");  
 }
 
@@ -3551 +3802 @@
 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;
@@ -3592 +3843 @@
   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;
@@ -3603 +3854 @@
   {
     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;
@@ -3625 +3876 @@
         //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];
@@ -3636 +3887 @@
           setring BASERING;
           winprim=1; // and stop the checking
-        }
+        } 
         j1=j1+1;  //else we look at the next associated prime
       }
@@ -3643 +3894 @@
     {
       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);
@@ -3682 +3933 @@
   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
@@ -3694 +3945 @@
       {
         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;
@@ -3712 +3963 @@
     {
       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
         {
@@ -3736 +3987 @@
       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
@@ -3749 +4000 @@
     {
       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;
@@ -3763 +4014 @@
     {
       // 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++)
@@ -3792 +4043 @@
           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
@@ -3805 +4056 @@
         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);
@@ -3845 +4096 @@
   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
@@ -3865 +4116 @@
     {
       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.
@@ -3893 +4144 @@
   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]);
@@ -3909 +4160 @@
       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))
@@ -3934 +4185 @@
     }
   //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;
@@ -3942 +4193 @@
     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;
@@ -3955 +4206 @@
   {
     // 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);
@@ -3962 +4213 @@
     // 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++)
@@ -3982 +4233 @@
       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);
@@ -4022 +4273 @@
       }
     //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;
@@ -4030 +4281 @@
       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;
@@ -4039 +4290 @@
     //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
@@ -4062 +4313 @@
             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
@@ -4073 +4324 @@
         export(ini);
         export(repl);
-        return(list(BASERINGLESS2,wvecp));
+        return(list(BASERINGLESS2,wvecp)); 
       }
     }
@@ -4082 +4333 @@
 /////////////////////////////////////////////////////////////////////////
 
-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;
+static proc tropicalparametriseNoabs (ideal i,intvec ww,int ordnung,int gfanold,int nogfan,int puiseux,list #)
+"USAGE:  tropicalparametriseNoabs(i,tw,ord,gf,ng,pu[,#]); i ideal, tw intvec, ord int, gf,ng,pu 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; 
          - 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 
+         - pu is 1 if n=1 and i is generated by one polynomial and newtonpoly is used to find a
+           point in the tropical variety instead of gfan
 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
@@ -4107 +4360 @@
            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"
 {
@@ -4124 +4377 @@
   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
@@ -4130 +4383 @@
     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);
@@ -4137 +4390 @@
   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);
@@ -4144 +4397 @@
     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);
@@ -4166 +4419 @@
     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 !!!
@@ -4190 +4443 @@
     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++;
@@ -4209 +4462 @@
   }
   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++)
@@ -4215 +4468 @@
     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
+    // else we have to use gfan
     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
@@ -4260 +4514 @@
         write(":a /tmp/gfaninput","{"+string(i)+"}");
       }
-      else
+      else  
       {
         // write the ideal to a file which gfan takes as input and call gfan
@@ -4274 +4528 @@
         else
         {
-//      system("sh","gfan_tropicalstartingcone < /tmp/gfaninput > /tmp/gfantropstcone");
-//      system("sh","gfan_tropicaltraverse < /tmp/gfantropstcone > /tmp/gfanoutput");
+//          system("sh","gfan_tropicalstartingcone < /tmp/gfaninput > /tmp/gfantropstcone");
+//          system("sh","gfan_tropicaltraverse < /tmp/gfantropstcone > /tmp/gfanoutput");
           system("sh","gfan_tropicalbasis < /tmp/gfaninput > /tmp/gfanbasis");
           system("sh","gfan_tropicalintersection < /tmp/gfanbasis > /tmp/gfanoutput");
@@ -4281 +4535 @@
         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;
@@ -4294 +4548 @@
         "IF YOU WANT wneu TO BE TESTED, THEN SET goon=0;";
         ~
-          // THIS IS NOT NECESSARY !!!! IF WE COMPUTE NOT ONLY THE
-          // TROPICAL PREVARIETY
-          // test, if wneu really is in the tropical variety
+        // THIS IS NOT NECESSARY !!!! IF WE COMPUTE NOT ONLY THE
+        // TROPICAL PREVARIETY
+        // test, if wneu really is in the tropical variety    
         while (goon==0)
         {
@@ -4303 +4557 @@
             "CHOOSE A DIFFERENT RAY";
             ~
-              }
+          }
           else
           {
@@ -4313 +4567 @@
       {
         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
@@ -4322 +4576 @@
     else // if gfan is NOT executed
     {
-      "Set intvec wneu!";
-      ~
-    }
-  }
-  // if we have not yet computed our parametrisation
+      // if puiseux is set, then we are in the case of a plane curve and can use the command newtonpoly
+      if (puiseux==1)
+      {
+        list NewtP=newtonpoly(i[1]);
+        wneu=NewtP[1]-NewtP[2];
+        int ggteiler=gcd(wneu[1],wneu[2]);
+        wneu[1]=-wneu[1]/ggteiler;
+        wneu[2]=wneu[2]/ggteiler;
+        if (wneu[1]>0)
+        {
+          wneu=-wneu;
+        }
+        kill NewtP,ggteiler;
+      }
+      else // set wneu by hand
+      {
+        "Set intvec wneu!";
+        ~
+      }
+    }    
+  }
+  // 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
+    list PARALIST=tropicalparametriseNoabs(i,wneu,ordnung-1,gfanold,nogfan,puiseux,anzahlvariablen,gesamt_m);
+    // 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
@@ -4347 +4618 @@
     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)
@@ -4354 +4625 @@
       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)
@@ -4368 +4639 @@
     }
   }
-  // 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
@@ -4374 +4645 @@
     // 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))
@@ -4392 +4663 @@
     }
     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++)
@@ -4401 +4672 @@
     }
   }
-  // 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
   }
@@ -4412 +4683 @@
     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));
@@ -4435 +4706 @@
 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")
@@ -4460 +4731 @@
     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);
@@ -4467 +4738 @@
   {
     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);
   }
@@ -4480 +4751 @@
   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;
@@ -4499 +4770 @@
     }
   }
-  m=eliminate(m,elimvars);
-  export(a);
+  m=eliminate(m,elimvars);  
+  export(a);  
   export(m);
   list m_ring=INITIALRING,neuvar,neuevariablen;
@@ -4512 +4783 @@
 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
@@ -4524 +4795 @@
                       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'"
@@ -4544 +4815 @@
     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
@@ -4559 +4830 @@
   // 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;
@@ -4581 +4852 @@
     // 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)
@@ -4596 +4867 @@
       else
       {
-        phiideal[j-1]=0;
+        phiideal[j-1]=0;  
       }
     }
@@ -4603 +4874 @@
       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
@@ -4610 +4881 @@
     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++;
@@ -4627 +4898 @@
     {
       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]));
       }
@@ -4639 +4910 @@
   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
@@ -4671 +4942 @@
 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"
@@ -4687 +4958 @@
     ideal tin=tInitialIdeal(i,w,1);
   }
-
+  
   int j;
   ideal variablen;
@@ -4719 +4990 @@
   def BASERING=basering;
   if (anzahlvariablen<nvars(basering))
-  {
+  {   
     execute("ring TINRING=("+charstr(basering)+","+string(Parameter)+"),("+string(variablen)+"),dp;");
   }
@@ -4729 +5000 @@
   poly monom=imap(BASERING,monom);
   return(radicalMemberShip(monom,tin));
-}
+}  
 
 /////////////////////////////////////////////////////////////////////////
@@ -4735 +5006 @@
 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
@@ -4758 +5029 @@
 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"
@@ -4816 +5087 @@
 "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;
@@ -4834 +5105 @@
   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
@@ -4859 +5130 @@
     {
       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)
@@ -4865 +5136 @@
         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;
         }
@@ -4878 +5149 @@
         }
       }
-      // 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;
@@ -4889 +5160 @@
         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;
@@ -4900 +5171 @@
     // 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
@@ -4912 +5183 @@
     }
   }
-  // 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
@@ -4919 +5190 @@
     l=j;
     for (k=j-1;k>=1;k--)
-    {
+    {      
       if (minassisort[l][2]<minassisort[k][2])
       {
@@ -4937 +5208 @@
 "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"
 {
@@ -4955 +5226 @@
   {
     if (koeffizienten[j-ord(p)+1]!=0)
-    {
+    {      
       if ((j-(N*wj)/w1)==0)
       {
@@ -5005 +5276 @@
 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"
@@ -5077 +5348 @@
 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
@@ -5103 +5374 @@
       ideal i=imap(BASERING,i);
     }
-  }
+  }  
   else
   {
@@ -5116 +5387 @@
   }
   // 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)
@@ -5133 +5404 @@
   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);
@@ -5143 +5414 @@
 /// - 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
+static proc tropicalparametrise (ideal i,intvec ww,int ordnung,int gfanold,int findall,int nogfan,int puiseux,list #)
+"USAGE:  tropicalparametrise(i,tw,ord,gf,fa,ng,pu[,#]); i ideal, tw intvec, ord int, gf,fa,ng,pu 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 
            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
          - ng is 1 if gfan should not be executed
+         - pu is 1 if n=1 and i is generated by one polynomial and newtonpoly is used to find a
+           point in the tropical variety instead of gfan
 RETURN:  list, l[1] = ring K[@a]/m[[t]]
                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"
 {
@@ -5185 +5458 @@
   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
@@ -5200 +5473 @@
   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
@@ -5215 +5488 @@
   }
   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
@@ -5226 +5499 @@
   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++)
@@ -5232 +5505 @@
     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
@@ -5312 +5585 @@
             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 -";
@@ -5319 +5592 @@
             "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)
             {
@@ -5339 +5612 @@
           {
             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
@@ -5349 +5622 @@
         else // if gfan is NOT executed
         {
-          if (findall==1)
+          // if puiseux is set, then we are in the case of a plane curve and can use the command newtonpoly
+          if (puiseux==1)
           {
-            "Set wneulist!";
-            ~
+            if (nvars(basering)>2) // if the basering has a parameter
+            { // we have to pass to a ring with two variables to compute the newtonpoly
+              def PRENPRing=basering;
+              poly NPpoly=i[size(i)];
+              ring NPRING=(0,@a),(x(1),t),ds;
+              poly NPpoly=imap(PRENPRing,NPpoly);
+              list NewtP=newtonpoly(NPpoly);
+              setring PRENPRing;
+              kill NPRING;
+            }
+            else
+            {              
+              list NewtP=newtonpoly(i[1]);
+            }
+            for (jjj=1;jjj<=size(NewtP)-1;jjj++)
+            {
+              wneu=NewtP[jjj]-NewtP[jjj+1];
+              int ggteiler=gcd(wneu[1],wneu[2]);
+              wneu[1]=-wneu[1]/ggteiler;
+              wneu[2]=wneu[2]/ggteiler;
+              if (wneu[1]>0)
+              {
+                wneu=-wneu;
+              }
+              if (nvars(basering)>2)
+              {       
+                wneu[3]=0;
+              }
+              wneulist[jjj]=wneu;
+            }  
+            kill NewtP,ggteiler;
           }
-          else
+          else // we have to set the points in the tropical variety by hand
           {
-            "Set intvec wneu!";
-            ~
-            wneulist[1]=wneu;
-         }
+            if (findall==1)
+            {
+              "Set wneulist!";
+              ~
+            }
+            else
+            { 
+              "Set intvec wneu!";
+              ~
+              wneulist[1]=wneu;
+            }
+          }
         }
       }
-      // 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++)
         {
           wneu=wneulist[kk];
-          PARALIST=tropicalparametrise(i,wneu,ordnung-1,gfanold,findall,nogfan,anzahlvariablen,zero);
-          // the output will be a ring, in which the
+          PARALIST=tropicalparametrise(i,wneu,ordnung-1,gfanold,findall,nogfan,puiseux,anzahlvariablen,zero);
+          // 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)
@@ -5396 +5707 @@
               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)
@@ -5416 +5727 @@
         }
       }
-      // 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))
@@ -5439 +5750 @@
         }
         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++)
@@ -5453 +5764 @@
         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
         }
@@ -5473 +5784 @@
           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)
@@ -5491 +5802 @@
     kill TRRING;
   }
-  // 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
+  if (nogfan!=1)
+  {
+    // 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 
   // rings (with the parametrisation ideal)
   // and an integer N such that t should be replaced by t^1/N
@@ -5503 +5817 @@
 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
@@ -5512 +5826 @@
                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"
 {
@@ -5529 +5843 @@
   // 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));
@@ -5576 +5890 @@
     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);
@@ -5582 +5896 @@
     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)
@@ -5605 +5919 @@
       {
         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)
@@ -5628 +5942 @@
       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
@@ -5665 +5979 @@
         }
         else
-        {
+        {   
           execute("ring SATURATERING=("+charstr(basering)+"),("+varstr(basering)+"),("+ordstr(basering)+");");
           ideal i=imap(BASERING,i);
@@ -5676 +5990 @@
     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
@@ -5693 +6007 @@
       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
       }
@@ -5711 +6025 @@
     }
     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++)
@@ -5717 +6031 @@
       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)
     {
@@ -5726 +6040 @@
     {
       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);
@@ -5745 +6059 @@
 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"
 {
@@ -5787 +6101 @@
     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);
@@ -5795 +6109 @@
     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;
@@ -5825 +6139 @@
   for (j=1;j<=size(maximalideals);j++)
   {
-    // check fort the jth maximal ideal a field extension is necessary;
+    // check if for 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;  
       }
     }
@@ -5869 +6183 @@
     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)
@@ -5884 +6198 @@
     {
       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));
@@ -5906 +6220 @@
     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]));
         }
@@ -5923 +6237 @@
     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]);
@@ -5929 +6243 @@
     }
     // 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;
@@ -5936 +6250 @@
     export(i);
     export(m);
-    export(zero);
+    export(zero);    
     extensionringlist[j]=EXTENSIONRING;
     kill EXTENSIONRING;
@@ -5948 +6262 @@
 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"
@@ -5967 +6281 @@
   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--)
   {
@@ -5986 +6300 @@
       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]);
@@ -5992 +6306 @@
     {
       // 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)
@@ -6000 +6314 @@
       }
     }
-    // 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
@@ -6009 +6323 @@
     // 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
@@ -6021 +6335 @@
     }
   }
-  // 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
@@ -6028 +6342 @@
     l=j;
     for (k=j-1;k>=1;k--)
-    {
+    {      
       if (deg(minassisort[l][1])<deg(minassisort[k][1]))
       {
@@ -6063 +6377 @@
 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")
@@ -6097 +6411 @@
   }
   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
@@ -6115 +6429 @@
   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++)
@@ -6169 +6483 @@
             e++;
           }
-        }
+        }          
       }
     }
@@ -6192 +6506 @@
 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"
@@ -6233 +6547 @@
   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++)
@@ -6249 +6563 @@
     }
   }
-  // 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
@@ -6265 +6579 @@
       {
         vergleich=substitute(tp[l],var(1),px);
-        if (vergleich==wert)
+        if (vergleich==wert)  
         {
           newton=newton+detropicalise(oldtp[l]);
@@ -6276 +6590 @@
         e++;
       }
-    }
+    }          
   }
   // if a vertex appears several times, only its first occurence will be kept
@@ -6283 +6597 @@
     for (j=i-1;j>=1;j--)
     {
-      if (bunchoflines[i][1]==bunchoflines[j][1])
+      if (bunchoflines[i][1]==bunchoflines[j][1]) 
       {
         bunchoflines=delete(bunchoflines,i);
@@ -6290 +6604 @@
     }
   }
-  // sort the lines in an descending way according to the leading
+  // sort the lines in an descending way according to the leading 
   // exponent of the polynomial
   // defining the Newton polygone
@@ -6325 +6639 @@
     xc=substitute(bunchoflines[i][1]-cc,var(2),0,var(1),1);
     yc=substitute(bunchoflines[i][1]-cc,var(2),1,var(1),0);
-    if (xc!=0) // then there is a point on the line with y-coordinate zero
+        if (xc!=0) // then there is a point on the line with y-coordinate zero
     {
       gr[1]=-cc/leadcoef(xc);
       gr[2]=0;
     }
-    else // if there is no point with y-coordinate zero, then
+    else // if there is no point with y-coordinate zero, then 
     { // there is point with x-coordinate zero
       gr[1]=0;
@@ -6347 +6661 @@
 
 static proc clearintmat (intmat vv)
-"USAGE:      clearintmat(vv); vv intmat
-ASSUME:      all entries of the first column of vv are non-negative,
+"USAGE:      clearintmat(vv); vv intmat 
+ASSUME:      all entries of the first column of vv are non-negative, 
              not all entries are zero unless vv has only one column
-RETURN:      intmat, vv has been ordered in an ascending way by the entries
-                     of the first row;
-                     if an entry in the first row occurs several times, the
-                     entries in the second row have been added and only one
+RETURN:      intmat, vv has been ordered in an ascending way by the entries 
+                     of the first row; 
+                     if an entry in the first row occurs several times, the 
+                     entries in the second row have been added and only one 
                      row has been kept;
-                     colums with a zero in the first row have been removed
+                     colums with a zero in the first row have been removed 
                      unless vv has only one column
 NOTE:        called by tropicalCurve"
@@ -6362 +6676 @@
   for (int i=ncols(vv)-1;i>=1;i--)
   {
-    if (vv[1,i]==vv[1,i+1])
+    if (vv[1,i]==vv[1,i+1]) 
     {
       vv[2,i]=vv[2,i]+vv[2,i+1];
@@ -6394 +6708 @@
         k++;
       }
-      else
+      else 
       {
         stop=1;
@@ -6422 +6736 @@
 static proc sortintmat (intmat vv)
 "USAGE:      sortintmat(vv); vv intmat
-RETURN:      intmat, the columns of vv have been ordered in an ascending
+RETURN:      intmat, the columns of vv have been ordered in an ascending 
                      way by the first entry
 NOTE:        called by clearintmat"
@@ -6476 +6790 @@
   {
     int m=nrows(M);
-
+    
   }
   else
@@ -6492 +6806 @@
 static proc minInIntvec (intvec v)
 "USAGE:      minInIntvec(v); v intvec
-RETURN:      list, first entry is the minimal value in v, second entry
+RETURN:      list, first entry is the minimal value in v, second entry 
                    is its position in v
 NOTE:        called by sortintmat"
@@ -6529 +6843 @@
 static proc sortlist (list v,int pos)
 "USAGE:      sortlist(v,pos); v list, pos int
-RETURN:      list, the list L ordered in an ascending way according
+RETURN:      list, the list L ordered in an ascending way according 
                    to the pos-th entries
 NOTE:        called by tropicalCurve"
@@ -6568 +6882 @@
 static proc vergleiche (poly wert,poly vglwert,list #)
 "USAGE:      vergleiche(wert,vglwert,liste), wert, vglwert poly, liste list
-RETURN:      int, if list contains a string as first entry then 1
-                  is returned if wert is at most vglwert and 0 if wert is
+RETURN:      int, if list contains a string as first entry then 1 
+                  is returned if wert is at most vglwert and 0 if wert is 
                   larger than vglwert, if liste is anything else 1 is returned if
                   wert is at least vglwert and 0 if wert s less than vglwert"
@@ -6601 +6915 @@
 static proc koeffizienten (poly f,int k)
 "USAGE:      koeffizienten(f,k)  f poly, k int
-ASSUME:      f=a*x+b*y+c is a linear polynomial in two variables,
+ASSUME:      f=a*x+b*y+c is a linear polynomial in two variables, 
              k is either 0, 1 or 2
 RETURN:      poly, one of the coefficients of f, depending on the value of k:
@@ -6614 +6928 @@
     return(c);
   }
-  f=f-c;
+  f=f-c;  
   if (k==1)
   {
     return(substitute(f,var(1),1,var(2),0));
-  }
+  }    
   else
   {
     return(substitute(f,var(1),0,var(2),1));
-  }
+  }    
 }
 
@@ -6660 +6974 @@
 ASSUME:      AA has three entries representing decimal numbers a, b and c
 RETURN:      list, containing strings representing the numbers a and b scaled
-                   down so that the absolute maximum of the two is no
+                   down so that the absolute maximum of the two is no 
                    larger than c
 NOTE:        the procedure is called by texDrawTropical"
@@ -6713 +7027 @@
 static proc decimal (poly n,list #)
 "USAGE:      decimal(f[,#]); f poly, # list
-ASSUME:      f is a polynomial in Q[x_1,...,x_n], and # is either empty
+ASSUME:      f is a polynomial in Q[x_1,...,x_n], and # is either empty 
              or #[1] is a positive integer
-RETURN:      string, a decimal expansion of the leading coefficient of f up
+RETURN:      string, a decimal expansion of the leading coefficient of f up 
                      to order two respectively #[1]
-NOTE:        the procedure is called by texDrawTropical and conicWithTangents
+NOTE:        the procedure is called by texDrawTropical and conicWithTangents 
              and f will actually be a number"
 {
@@ -6744 +7058 @@
       }
       for (j=i;j<=i+nachkomma;j++)
-      {
+      {        
         news=news+s[j];
       }
@@ -6776 +7090 @@
   }
   return(0);
-}
+}      
 
 /////////////////////////////////////////////////////////////////////////
@@ -6792 +7106 @@
   {
     return("");
-
+    
   }
   if (i==1)
@@ -6851 +7165 @@
       k=j+2;
       while (k<=size(F) and ((F[k]=="0") or (F[k]=="1") or (F[k]=="2") or (F[k]=="3") or
-                                (F[k]=="4") or (F[k]=="5") or (F[k]=="6") or (F[k]=="7") or (F[k]=="8")
+                                (F[k]=="4") or (F[k]=="5") or (F[k]=="6") or (F[k]=="7") or (F[k]=="8") 
                              or (F[k]=="9")))
       {
@@ -6865 +7179 @@
       k=j+2;
       while (k<=size(F) and ((F[k]=="0") or (F[k]=="1") or (F[k]=="2") or (F[k]=="3") or
-                                (F[k]=="4") or (F[k]=="5") or (F[k]=="6") or (F[k]=="7") or (F[k]=="8")
+                                (F[k]=="4") or (F[k]=="5") or (F[k]=="6") or (F[k]=="7") or (F[k]=="8") 
                              or (F[k]=="9")))
       {
@@ -6878 +7192 @@
       F=stringdelete(F,j);
       j--;
-    }
+    }      
   }
   short=altshort;
   return(F);
 }
-
+  
 /////////////////////////////////////////////////////////////////////////
 
 static proc texcoefficient (poly f,list #)
 "USAGE:      texcoefficient(f[,#]); f poly, # optional list
-RETURN:      string, the tex command representing the leading coefficient
+RETURN:      string, the tex command representing the leading coefficient 
                      of f using \frac as coefficient
-NOTE:        if # is non-empty, then the cdot at the end is omitted;
+NOTE:        if # is non-empty, then the cdot at the end is omitted; 
              this is needed for the constant term"
 {
@@ -6922 +7236 @@
   }
   if (size(koeffizient)>5)
-  {
+  {    
     string tfractest=koeffizient[2..6];
     if (tfractest=="tfrac")
@@ -7009 +7323 @@
 static proc coordinatechange (poly f,intmat A,intvec v)
 "USAGE:   coordinatechange(f,A,v);  f poly, A intmat, v intvec
-ASSUME:   f is a polynomial in two variables, A is a 2x2
+ASSUME:   f is a polynomial in two variables, A is a 2x2 
           integer matrix, and v is an integer vector with 2 entries
 RETURN:   poly, the polynomial transformed by (x,y)->A*(x,y)+v
@@ -7031 +7345 @@
 "USAGE:      weierstrassFormOfACubic(wf[,#]); wf poly, # list
 ASSUME:      poly is a cubic polynomial
-RETURN:      poly, the Weierstrass normal form of the cubic, 0 if poly is
+RETURN:      poly, the Weierstrass normal form of the cubic, 0 if poly is 
                    not a cubic
 NOTE:        - the algorithm for the coefficients of the Weierstrass form is due
                to Fernando Rodriguez Villegas, villegas@math.utexas.edu
-             - if an additional argument # is given, the simplified Weierstrass
+             - if an additional argument # is given, the simplified Weierstrass 
                form is computed
              - the procedure is called by weierstrassForm
-             - the characteristic of the base field should not be 2 or 3
+             - the characteristic of the base field should not be 2 or 3 
                if # is non-empty"
 {
@@ -7052 +7366 @@
     return (f);
   }
-  // compute the coefficients a1,a2,a3,a4, and a6 of the Weierstrass
+  // compute the coefficients a1,a2,a3,a4, and a6 of the Weierstrass 
   // form y^2+a1xy+a3y=x^3+a2x^2+a4x+a6
   poly a1=r1;
@@ -7059 +7373 @@
   poly a4=((-3*t0*r0+s0^2)*q1+(-3*s1*s0*q0+s1*r0^2))*q3
     +(t0*r0*q2^2+(s1*s0*q1+((-3*t0*r2+s1^2)*q0+s0*r0*r2))*q2
-      +(t0*r2*q1^2+s1*r0*r2*q1+s0*r2^2*q0));
+      +(t0*r2*q1^2+s1*r0*r2*q1+s0*r2^2*q0)); 
   poly a6=(-27*t0^2*q0^2+(9*t0*s0*r0-s0^3)*q0-t0*r0^3)*q3^2+
-        (((9*t0^2*q0-t0*s0*r0)*q1+((-3*t0*s0*r1+(3*t0*s1*r0+
-        2*s1*s0^2))*q0+(t0*r0^2*r1-s1*s0*r0^2)))*q2+(-t0^2*q1^3
-        +(t0*s0*r1+(2*t0*s1*r0-s1*s0^2))*q1^2+((3*t0*s0*r2+
-        (-3*t0*s1*r1+2*s1^2*s0))*q0+((2*t0*r0^2-s0^2*r0)*r2+
-        (-t0*r0*r1^2+s1*s0*r0*r1-s1^2*r0^2)))*q1+((9*t0*s1*r2-
-        s1^3)*q0^2+(((-3*t0*r0+s0^2)*r1-s1*s0*r0)*r2+(t0*r1^3
-        -s1*s0*r1^2+s1^2*r0*r1))*q0)))*q3+(-t0^2*q0*q2^3+
-        (-t0*s1*r0*q1+((2*t0*s0*r2+(t0*s1*r1-s1^2*s0))*q0-
-        t0*r0^2*r2))*q2^2+(-t0*s0*r2*q1^2+(-t0*s1*r2*q0+
-        (t0*r0*r1-s1*s0*r0)*r2)*q1+((2*t0*r0-s0^2)*r2^2+
-        (-t0*r1^2+s1*s0*r1-s1^2*r0)*r2)*q0)*q2+
-        (-t0*r0*r2^2*q1^2+(t0*r1-s1*s0)*r2^2*q0*q1-
+        (((9*t0^2*q0-t0*s0*r0)*q1+((-3*t0*s0*r1+(3*t0*s1*r0+
+        2*s1*s0^2))*q0+(t0*r0^2*r1-s1*s0*r0^2)))*q2+(-t0^2*q1^3
+        +(t0*s0*r1+(2*t0*s1*r0-s1*s0^2))*q1^2+((3*t0*s0*r2+
+        (-3*t0*s1*r1+2*s1^2*s0))*q0+((2*t0*r0^2-s0^2*r0)*r2+
+        (-t0*r0*r1^2+s1*s0*r0*r1-s1^2*r0^2)))*q1+((9*t0*s1*r2-
+        s1^3)*q0^2+(((-3*t0*r0+s0^2)*r1-s1*s0*r0)*r2+(t0*r1^3
+        -s1*s0*r1^2+s1^2*r0*r1))*q0)))*q3+(-t0^2*q0*q2^3+
+        (-t0*s1*r0*q1+((2*t0*s0*r2+(t0*s1*r1-s1^2*s0))*q0-
+        t0*r0^2*r2))*q2^2+(-t0*s0*r2*q1^2+(-t0*s1*r2*q0+
+        (t0*r0*r1-s1*s0*r0)*r2)*q1+((2*t0*r0-s0^2)*r2^2+
+        (-t0*r1^2+s1*s0*r1-s1^2*r0)*r2)*q0)*q2+
+        (-t0*r0*r2^2*q1^2+(t0*r1-s1*s0)*r2^2*q0*q1-
      t0*r2^3*q0^2));
   poly b2=a1^2+4*a2;
@@ -7124 +7438 @@
         i.e. a polynomial of the form a+bx+cx2+dy+exy+fx2y+gy2+hxy2+ix2y2
 RETURN: poly, a Weierstrass form of the elliptic curve defined by poly
-NOTE:   - the algorithm is based on the paper Sang Yook An, Seog Young Kim,
-          David C. Marshall, Susan H. Marshall, William G. McCallum and
-          Alexander R. Perlis: Jacobians of Genus One Curves. Journal of Number
+NOTE:   - the algorithm is based on the paper Sang Yook An, Seog Young Kim, 
+          David C. Marshall, Susan H. Marshall, William G. McCallum and 
+          Alexander R. Perlis: Jacobians of Genus One Curves. Journal of Number 
           Theory 90,2 (2001), 304-315.
         - the procedure is called by weierstrassForm
@@ -7135 +7449 @@
   // define P1xP1 as quadric in P3
   matrix A[4][4]=0,0,0,1/2,0,0,1/2,0,0,1/2,0,0,1/2,0,0,0;
-  // define the image of the (2,2)-curve under the Segre embedding
+  // define the image of the (2,2)-curve under the Segre embedding 
   // as quadric which should be
   // intersected with the image of P1xP1
   matrix B[4][4]=A00,A10/2,A01/2,0,A10/2,A20,A11/2,A21/2,A01/2,A11/2,A02,A12/2,0,A21/2,A12/2,A22;
-  // compute the coefficients of the Weierstrass form of
+  // compute the coefficients of the Weierstrass form of 
   // the input polynomial and its j-invariant
   poly a=det(x*A+B);
@@ -7152 +7466 @@
 
 static proc jInvariantOfACubic (poly f,list #)
-"USAGE:      jInvariantOfACubic(f[,#]); f poly, # list
+"USAGE:      jInvariantOfACubic(f[,#]); f poly, # list 
 ASSUME:      poly is a cubic polynomial defining an elliptic curve
 RETURN:      poly, the j-invariant of the elliptic curve defined by poly
 NOTE:        - if the base field is Q(t) an optional argument # may be given;
-               then the algorithm only computes the negative of the order
+               then the algorithm only computes the negative of the order 
                of the j-invariant"
 {
@@ -7163 +7477 @@
     ERROR("The input polynomial is not a cubic!");
   }
-  // compute first the Weierstrass form of the cubic
+  // compute first the Weierstrass form of the cubic 
   // - this does not change the j-invariant
   f=weierstrassFormOfACubic(f);
@@ -7181 +7495 @@
     ERROR("The input is a rational curve and has no j-invariant!");
   }
-  if (size(#)>0) // if the optional argument is given, then only the
+  if (size(#)>0) // if the optional argument is given, then only the 
   { // negative of the order is computed
     int zaehler=3*simplifyToOrder(c4)[1];
@@ -7197 +7511 @@
 
 static proc jInvariantOfA2x2Curve (poly f,list #)
-"USAGE: jInvariantOfA2x2Curve(f[,#]); f poly, # list
+"USAGE: jInvariantOfA2x2Curve(f[,#]); f poly, # list 
 ASSUME: poly, is a polynomial defining an elliptic curve of type (2,2) on P^1xP^1
              i.e. a polynomial of the form a+bx+cx2+dy+exy+fx2y+gy2+hxy2+ix2y2
 RETURN: poly, the j-invariant of the elliptic curve defined by poly
 NOTE:   - if the base field is Q(t) an optional argument # may be given;
-          then the algorithm only computes the negative of the order of the
+          then the algorithm only computes the negative of the order of the 
           j-invariant
         - the characteristic should not be 2 or 3
@@ -7215 +7529 @@
   // intersected with the image of P1xP1
   matrix B[4][4]=A00,A10/2,A01/2,0,A10/2,A20,A11/2,A21/2,A01/2,A11/2,A02,A12/2,0,A21/2,A12/2,A22;
-  // compute the coefficients of the Weierstrass form of
+  // compute the coefficients of the Weierstrass form of 
   // the input polynomial and its j-invariant
   poly a=det(var(1)*A+B);
@@ -7231 +7545 @@
     ERROR("The input is a rational curve and has no j-invariant!");
   }
-  if (size(#)>0) // if the optional argument is given,
+  if (size(#)>0) // if the optional argument is given, 
   { // then only the negative of the order is computed
     int zaehler=simplifyToOrder(jinvnum)[1];
@@ -7247 +7561 @@
 
 static proc jInvariantOfA4x2Curve (poly f,list #)
-"USAGE:      jInvariantOfA4x2Curve(f[,#]); f poly, # list
+"USAGE:      jInvariantOfA4x2Curve(f[,#]); f poly, # list 
 ASSUME:      poly, is a polynomial defining an elliptic curve of type (4,2),
              i.e. a polynomial of the form a+bx+cx2+dx3+ex4+fy+gxy+hx2y+iy2
 RETURN:      poly, the j-invariant of the elliptic curve defined by poly
 NOTE:        - if the base field is Q(t) an optional argument # may be given;
-               then the algorithm only computes the negative of the order
+               then the algorithm only computes the negative of the order 
                of the j-invariant
              - the characteristic should not be 2 or 3
-             - the procedure is not called at all, it is just stored
+             - the procedure is not called at all, it is just stored 
                for the purpose of comparison"
 {
@@ -7275 +7589 @@
   poly c4cube=c4^3;
   poly jdenom=c4cube-c6^2;
-  if (size(#)>0) // if the optional argument is given,
+  if (size(#)>0) // if the optional argument is given, 
   { // then only the negative of the order is computed
     int zaehler=3*simplifyToOrder(c4)[1];
@@ -7290 +7604 @@
 
 static proc jInvariantOfAPuiseuxCubic (poly f,list #)
-"USAGE:  jInvariantOfAPuiseuxCubic(f[,#]); f poly, # list
-ASSUME:  poly is a cubic polynomial over Q(t) defining an elliptic curve
+"USAGE:  jInvariantOfAPuiseuxCubic(f[,#]); f poly, # list 
+ASSUME:  poly is a cubic polynomial over Q(t) defining an elliptic curve 
          and # is empty
-RETURN:  list, containing two polynomials whose ratio is the j-invariant
+RETURN:  list, containing two polynomials whose ratio is the j-invariant 
                of the  elliptic curve defined by poly
-ASSUME:  poly is a cubic polynomial over Q(t) defining an elliptic curve
+ASSUME:  poly is a cubic polynomial over Q(t) defining an elliptic curve 
          and # is non-empty
 RETURN:  int, the order of the j-invariant of the elliptic curve defined by poly
@@ -7304 +7618 @@
     ERROR("The input polynomial is not a cubic!");
   }
-  // compute first the Weierstrass form of the cubic
+  // compute first the Weierstrass form of the cubic 
   // - this does not change the j-invariant
   f=weierstrassFormOfACubic(f);
@@ -7329 +7643 @@
     ERROR("The input is a rational curve and has no j-invariant!");
   }
-  if (size(#)>0) // if the optional argument is given,
+  if (size(#)>0) // if the optional argument is given, 
   { // then only the negative of the order is computed
     int zaehler=3*simplifyToOrder(c4)[1];
@@ -7372 +7686 @@
 /*
 
-/// Note, only the following procedures need further examples
+/// Note, only the following procedures need further examples 
 /// (the others are too simple):
 /// A) tropicalLifting (best tested via displayTropicalLifting)
@@ -7403 +7717 @@
 // Example 3 - the ideal is not zero dimensional
 // --------------------------------------------------------
-ring r1=0,(t,x,y),dp;
+ring r1=0,(t,x,y),dp; 
 poly f=(9t27-12t26-5t25+21t24+35t23-51t22-40t21+87t20+56t19-94t18-62t17+92t16+56t15-70t14-42t13+38t12+28t11+18t10-50t9-48t8+40t7+36t6-16t5-12t4+4t2)*x2+(-9t24+12t23-4t22-42t20+28t19+30t18-20t17-54t16+16t15+48t14-16t12+8t11-18t10-26t9+30t8+20t7-24t6+4t5+28t4-8t3-16t2+4)*xy+(6t16-10t15-2t14+16t13+4t12-18t11-10t10+24t9+6t8-20t7+8t6+8t5-20t4-4t3+12t2+4t-4)*y2+(-9t28+3t27+8t26-4t25-45t24-6t23+42t22+30t21-94t20-40t19+68t18+82t17-38t16-60t15+26t14+36t13-22t12-20t11+4t10+4t9+12t8+8t7-8t6-8t5+4t4)*x+(9t27-21t26+16t25+14t24+12t23-61t22+27t21+80t20-19t19-100t18+26t17+96t16-24t15-84t14+44t12-2t11-18t10+2t9+40t8+4t7-32t6-12t5+4t3+12t2-4)*y+(9t27-12t26+4t25+36t23-18t22-28t21-2t20+54t19+14t18-52t17-44t16+24t15+40t14-4t13-12t12+4t11-4t10-4t9+4t8);
 f;
@@ -7589 +7903 @@
 poly f=t*(x7+y7+1)+1/t*(x4+y4+x2+y2+x3y+xy3)+1/t7*x2y2;
 list graph=tropicalCurve(f);
-graph;
+graph; 
 size(graph)-1;
 drawTropicalCurve(graph);
@@ -7658 +7972 @@
 proc drawTwoTropicalCurves (list ff,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"
@@ -7699 +8013 @@
   int i,j;
   for (i=1;i<=size(ff);i++)
-  {
-    def f=ff[i];
+  {    
+    def f=ff[i];    
     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)
@@ -7715 +8029 @@
     {
       if (size(#)==0)
-      {
+      {      
         texf="\\min\\{";
       }
@@ -7724 +8038 @@
       for (j=1;j<=size(f);j++)
       {
-        texf=texf+texPolynomial(f[j]);
+        texf=texf+texPolynomial(f[j]);    
         if (j<size(f))
         {
@@ -7733 +8047 @@
           texf=texf+"\\}";
         }
-      }
+      }    
       graph=tropicalCurve(f,#); // the graph of the tropical polynomial f
       // detropicalise ff[i]
@@ -7755 +8069 @@
   list verticess;
   for (i=1;i<=size(ff);i++)
-  {
+  {    
     graph=graphs[i];
     for (j=1;j<=size(graph)-2;j++)
@@ -7772 +8086 @@
 \\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}
@@ -7791 +8105 @@
   string fname;
   for (i=1;i<=size(ff);i++)
-  {
+  {    
     if (i==1)
     {
@@ -7801 +8115 @@
     }
     TEXBILD=TEXBILD+"
-    The vertices of the tropical curve
+    The vertices of the tropical curve 
     \\begin{center}
       \\begin{math}
@@ -7825 +8139 @@
   string TDT;
   for (i=1;i<=size(ff);i++)
-  {
+  {    
     #[size(#)+1]="\\setgray "+decimal(1-(number(i)/(size(ff)+1)))+"
 ";
@@ -7840 +8154 @@
       #=delete(#,1);
     }
-  }
+  }  
   // add lattice points if the scalefactor is >= 1/2
   // and was not handed over
@@ -7896 +8210 @@
 
    \\begin{center}
-       "+texDrawNewtonSubdivision(graphs[i],oldsharp)+"
+       "+texDrawNewtonSubdivision(graphs[i],oldsharp)+" 
    \\end{center}
 
@@ -7908 +8222 @@
     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
@@ -7934 +8248 @@
 {
   list graph;
-  int j,i,k;
-  poly minx,miny,maxx,maxy;
-  poly minX,minY,maxX,maxY;
+  int j,i,k;  
+  poly minx,miny,maxx,maxy;  
+  poly minX,minY,maxX,maxY;  
   poly maxdiffx,maxdiffy;
   poly centerx,centery;
@@ -7944 +8258 @@
   list SFCS;
   for (k=1;k<=size(graphs);k++)
-  {
+  {    
     graph=graphs[k];
     // find the minimal and maximal coordinates of vertices
@@ -8007 +8321 @@
       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)
@@ -8054 +8368 @@
 }
 
+
+
+
+