Context Navigation

← Previous Change
Next Change →

tropical.lib

Timestamp:

Apr 14, 2009, 2:00:15 PM (14 years ago)

Author:

Hans Schönemann <hannes@…>

Branches:

(u'spielwiese', '8e0ad00ce244dfd0756200662572aef8402f13d5')

Children:

334c21f9e573112667d39f4cd9dcad9c7b19a50c

Parents:

2c3a5db391a25c28449b80c5f27e1dd77ed2c30f

Message:

*hannes: format


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

File:

: 1 edited

Singular/LIB/tropical.lib (modified) (324 diffs)

Legend:

: Unmodified
: Added
: Removed

Singular/LIB/tropical.lib

-                      r2c3a5d
+                      r3360fb
 version="$Id: tropical.lib,v 1.14 2009-04-08 12:42:19 seelisch Exp $";
+version="$Id: tropical.lib,v 1.15 2009-04-14 12:00:15 Singular Exp $";
 category="Tropical Geometry";
 info="
 …
 @*               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 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
+  Moreover, in 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
   cause any restriction.
   If, however, for some reason you prefer to work with general vi, then you
   have to pass right away to the tropicalisation of the equations, whereever
+  If, however, for some reason you prefer to work with general vi, then you
+  have to pass right away to the tropicalisation of the equations, whereever
   this is allowed -- these are linear polynomials where the constant coefficient
   corresponds to the valuation of the original coefficient and where
   the non-constant coefficient correspond to the exponents of the monomials,
   thus they may be rational numbers respectively negative numbers:
+  corresponds to the valuation of the original coefficient and where
+  the non-constant coefficient correspond to the exponents of the monomials,
+  thus they may be rational numbers respectively negative numbers:
   e.g. if f=t^{1/2}*x^{-2}*y^3+2t*x*y+4  then  trop(f)=min{1/2-2x+3y,1+x+y,0}.
   The main tools provided in this library are as follows:
 @*  - tropicalLifting    implements the constructive proof of the Theorem of
                          Newton-Kapranov and constructs a point in the variety
                          over C{{t}} corresponding to a given point in the
                          corresponding tropical variety associated to an
                          ideal I; the generators of I have to be in the
                          polynomial ring Q[t,x1,...,xn] considered as a
                          subring of C{{t}}[x1,...,xn]; a solution will be
                          constructed up to given order; note that several
+@*  - tropicalLifting    implements the constructive proof of the Theorem of
+                         Newton-Kapranov and constructs a point in the variety
+                         over C{{t}} corresponding to a given point in the
+                         corresponding tropical variety associated to an
+                         ideal I; the generators of I have to be in the
+                         polynomial ring Q[t,x1,...,xn] considered as a
+                         subring of C{{t}}[x1,...,xn]; a solution will be
+                         constructed up to given order; note that several
                          field extensions of Q might be necessary throughout
                          the intermediate computations; the procedures use
                          the external program gfan
 @*  - drawTropicalCurve  visualises a tropical plane curve either given by a
                          polynomial in Q(t)[x,y] or by a list of linear
                          polynomials of the form ax+by+c with a,b in Z and c
+@*  - drawTropicalCurve  visualises a tropical plane curve either given by a
+                         polynomial in Q(t)[x,y] or by a list of linear
+                         polynomials of the form ax+by+c with a,b in Z and c
                          in Q; latex must be installed on your computer
 @*  - tropicalJInvariant computes the tropical j-invaiant of a tropical
+@*  - tropicalJInvariant computes the tropical j-invaiant of a tropical
                          elliptic curve
 @*  - jInvariant         computes the j-invariant of an elliptic curve
 @*  - weierstrassForm     computes the Weierstrass form of an elliptic curve
+@*  - weierstrassForm     computes the Weierstrass form of an elliptic curve
 PROCEDURES FOR TROPICAL LIFTING:
   tropicalLifting          computes a point in the tropical variety
+  tropicalLifting          computes a point in the tropical variety
   displayTropicalLifting   displays the output of tropicalLifting
 …
   tropicalise        computes the tropicalisation of a polynomial
   tropicaliseSet     computes the tropicalisation several polynomials
   tInitialForm       computes the tInitial form of a poly in Q[t,x_1,...,x_n]
+  tInitialForm       computes the tInitial form of a poly in Q[t,x_1,...,x_n]
   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]
+  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]
 PROCEDURES FOR LATEX CONVERSION:
   texNumber          outputs the texcommand for the leading coefficient of poly
   texPolynomial      outputs the texcommand for the polynomial poly
+  texPolynomial      outputs the texcommand for the polynomial poly
   texMatrix          outputs the texcommand for the matrix
   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
 …
   radicalMemberShip     checks radical membership
   tInitialFormPar       computes the t-initial form of poly in Q(t)[x_1,...,x_n]
   tInitialFormParMax    same as tInitialFormPar, but uses maximum
+  tInitialFormParMax    same as tInitialFormPar, but uses maximum
   solveTInitialFormPar  displays approximated solution of a 0-dim ideal
   detropicalise         computes the detropicalisation of a linear form
   dualConic             computes the dual of an affine plane conic
+  dualConic             computes the dual of an affine plane conic
   parameterSubstitute   substitutes in the poly the parameter t by t^N
   tropicalSubst         makes certain substitutions in a tropical polynomial
 …
 /// - eliminatecomponents
 /// - findzerosAndBasictransform
 /// - ordermaximalideals
+/// - ordermaximalideals
 /// - verticesTropicalCurve
 /// - bunchOfLines
 …
 ///////////////////////////////////////////////////////////////////////////////
 /// 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
 …
 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:
 …
 @*       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 Singular procedure absPrimdecGTZ to be
+@*       - the procedure requires the Singular procedure absPrimdecGTZ to be
            present in the package primdec.lib, unless the option 'noAbs' is set;
            but even if absPrimdecGTZ is present it might be necessary to set
            the option 'noAbs' in order to avoid the costly absolute primary
            decomposition; the side effect is that the field extension which is
+           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 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"
 …
       noabs=1;
+    }
     // this option is not documented -- it prevents the execution of gfan and
     // just asks for wneu to be inserted -- it can be used to check problems
     // with the precedure without calling gfan, if wneu is know from previous
+    // this option is not documented -- it prevents the execution of gfan and
+    // just asks for wneu to be inserted -- it can be used to check problems
+    // with the precedure without calling gfan, if wneu is know from previous
     // computations
     if (#[j]=="noGfan")
 …
+    }
+  }
   // 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
 …
+  {
     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)
 …
+  }
   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];
 …
     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++)
 …
+  {
     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++)
 …
     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;
 …
   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
 …
     // 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
 …
         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
 …
           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];
 …
       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
 …
         */
         // 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;
 …
           // 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
 …
           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)
 …
+          }
           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)
 …
       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
 …
       "The procedure will be restarted with the option 'findAll'.";
       "Go on by hitting RETURN!";
       findall=1;
+      findall=1;
       noabs=0;
       setring CUTDOWNRING;
 …
       "i";i;
       "ini";tInitialIdeal(i,w,1);
 /*
       setring GRUNDRING;
 …
+    }
+  }
   // 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)
 …
   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
 …
    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;
 …
    // 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;
 …
       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]]";
+      }
+    }
 …
+      }
       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+">";
+      }
+      }
+    }
     "";
 …
+      }
+    }
+  }
+  }
+}
 example
 …
 ///////////////////////////////////////////////////////////////////////////////
 /// 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"
 …
     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;
 …
   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.
 …
     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
 …
+    {
       bb=koeffizienten(tp[i],2);
+    }
+    }
+  }
   if ((aa!=0) or (bb!=0))
 …
+    }
+  }
   // 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
 …
     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)
+    {
 …
       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
 …
     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++)
+    {
 …
         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])))
+          {
 …
             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);
 …
+    }
+  }
   // 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.
 …
   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
+      {
 …
+      }
       // 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
 …
     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;
 …
+  {
     // 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;
+  }
 …
+    }
+  }
   // 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.
 …
 // 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];
 …
 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"
 …
   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)
 …
       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\\{";
+      }
 …
       for (j=1;j<=size(f);j++)
+      {
         texf=texf+texPolynomial(f[j]);
+        texf=texf+texPolynomial(f[j]);
         if (j<size(f))
+        {
 …
           texf=texf+"\\}";
+        }
+      }
+      }
       list graph=tropicalCurve(f,#); // the graph of the tropical polynomial f
+    }
 …
 \\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
 …
    \\begin{center}
        "+texDrawNewtonSubdivision(graph,#)+"
+       "+texDrawNewtonSubdivision(graph,#)+"
    \\end{center}
 \\end{document}";
 …
     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
 …
 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"
 …
   { // write the tropical polynomial defined by f
     if (size(#)==0)
+    {
+    {
       texf="\\min\\{";
+    }
 …
     for (j=1;j<=size(f);j++)
+    {
       texf=texf+texPolynomial(f[j]);
+      texf=texf+texPolynomial(f[j]);
       if (j<size(f))
+      {
 …
         texf=texf+"\\}";
+      }
+    }
+    }
     list graph=tropicalCurve(f,#); // the graph of the tropical polynomial f
+  }
 …
    \\parindent0cm
    \\begin{center}
       \\large\\bf The Newtonsubdivison of
+      \\large\\bf The Newtonsubdivison of
       \\begin{displaymath}
           f="+texf+"
 …
    \\begin{center}
 "+texDrawNewtonSubdivision(graph)+
+"+texDrawNewtonSubdivision(graph)+
 "   \\end{center}
 …
   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);
+}
 …
 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"
 …
+    {
       if (typeof(f[1])=="list")
+      {
+      {
         list graph=f;
+      }
 …
+        {
           ERROR("This is no valid input.");
+        }
+        }
+      }
+    }
 …
   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)
 …
   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
 …
+            {
               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;
 …
+        }
+      }
       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
+    }
 …
     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++;
 …
       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
+      }
 …
     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];
 …
+      }
       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);
+  }
+}
 …
 // 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);
 …
 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
 …
                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"
 …
 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"
 …
    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");
 …
    poly h=x22y11+x19y10+x17y9+x16y9+x12y7+x9y6+x7y5+x2y3+x14y8;
 // its j-invariant is
    jInvariant(h);
+   jInvariant(h);
+}
 …
 @*                 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
 …
   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++)
 …
   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++)
 …
    We consider the concic through the following five points:
    \\begin{displaymath}
 ";
+";
   string texf=texDrawTropical(graphf,list("",scalefactor));
   for (i=1;i<=size(points);i++)
 …
 \\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));
 …
 // 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
 …
 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"
 …
+    {
       tropicalf[i]=tropicalf[i]+exp[j]*var(j);
+    }
+    }
     f=f-lead(f);
+  }
 …
 /////////////////////////////////////////////////////////////////////////
 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"
 …
   // 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)
+  {
 …
         initialf=initialf+lead(f);
+      }
+    }
+    }
     f=f-lead(f);
+  }
 …
 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!
 …
   // ... 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+1;
 …
+  }
   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);
 …
 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
 …
     \\end{texdraw}";
   return(texdrawtp);
+}
+}
 example
+{
 …
 ASSUME:  graph is the output of tropicalCurve
 RETURN:  string, the texdraw code of the tropical plane curve encoded by graph
 NOTE:    - if the list # is non-empty, the first entry should be a string;
            if this string is 'max', then the tropical curve is considered
            with respect to the maximum; otherwise the curve is considered
            with respect to the minimum and the string can be used to insert
+NOTE:    - if the list # is non-empty, the first entry should be a string;
+           if this string is 'max', then the tropical curve is considered
+           with respect to the maximum; otherwise the curve is considered
+           with respect to the minimum and the string can be used to insert
            further texdraw commands (e.g. to have a lighter image as when called
            from inside conicWithTangents);
 @*       - the procedure computes a scalefactor for the texdraw command which
            should help to display the curve in the right way; this may,
            however, be a bad idea if several texDrawTropical outputs are
            put together to form one image; the scalefactor can be prescribed
+           from inside conicWithTangents);
+@*       - the procedure computes a scalefactor for the texdraw command which
+           should help to display the curve in the right way; this may,
+           however, be a bad idea if several texDrawTropical outputs are
+           put together to form one image; the scalefactor can be prescribed
            by a second optional entry of type poly
 @*       - the list # is optional and may as well be empty
 …
+{
   int i,j;
   // deal first with the pathological case that
+  // deal first with the pathological case that
   // the input polynomial was a monomial
   // and does therefore not define a tropical curve,
   // and check if the Newton polytope is
+  // and does therefore not define a tropical curve,
+  // and check if the Newton polytope is
   // a line segment so that the curve defines a bunch of lines
   int bunchoflines;
   // if the boundary of the Newton polytope consists of a single point
   if (size(graph[size(graph)][1])==1)
+  if (size(graph[size(graph)][1])==1)
+  {
     return(string());
 …
+    }
     // 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;
 …
   // go on with the case that a tropical curve is defined
   if (size(#)==0)
+  {
+  {
      string texdrawtp="
 …
+  {
     if ((#[1]!="max") and (#[1]!=""))
+    {
+    {
       string texdrawtp=#[1];
+    }
 …
+  {
     // if the curve is a bunch of lines no vertex has to be drawn
     if (bunchoflines==0)
+    if (bunchoflines==0)
+    {
       texdrawtp=texdrawtp+"
 …
+    }
     // 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)+" "+decimal(graph[i][2]-centery)+") \\lvec ("+decimal(graph[graph[i][3][1,j]][1]-centerx)+" "+decimal(graph[graph[i][3][1,j]][2]-centery)+")";
         // if the multiplicity is more than one, denote it in the picture
         if (graph[i][3][2,j]>1)
+        if (graph[i][3][2,j]>1)
+        {
           texdrawtp=texdrawtp+"
 …
     // 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),decimal(3*graph[i][4][j][1][2]/scalefactor),"2.5"));
       texdrawtp=texdrawtp+"
        \\move ("+decimal(graph[i][1]-centerx)+" "+decimal(graph[i][2]-centery)+") \\rlvec ("+relxy[1]+" "+relxy[2]+")";
       // if the multiplicity is more than one, denote it in the picture
       if (graph[i][4][j][2]>1)
+      if (graph[i][4][j][2]>1)
+      {
         texdrawtp=texdrawtp+"
 …
   poly scalefactor=minOfPolys(list(12/leadcoef(maxx),12/leadcoef(maxy)));
   if (scalefactor<1)
+  {
+  {
     subdivision=subdivision+"
        \\relunitscale"+ decimal(scalefactor);
 …
+  {
     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])+")
 …
+  {
     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])+")";
+  }
 …
+    }
+  }
   // deal with the pathological cases
+  // deal with the pathological cases
   if (size(boundary)==1) // then the Newton polytope is a point
+  {
 …
+  {
     subdivision=subdivision+"
        \\move ("+string(markings[i][1])+" "+string(markings[i][2])+")
+       \\move ("+string(markings[i][1])+" "+string(markings[i][2])+")
        \\fcir f:0 r:"+decimal(2/(8*scalefactor),size(string(int(scalefactor)))+1);
+  }
   // enclose subdivision in the texdraw environment
   string texsubdivision="
+  string texsubdivision="
     \\begin{texdraw}
        \\drawdim cm  \\relunitscale 1
+       \\drawdim cm  \\relunitscale 1
        \\linewd 0.05"
     +subdivision+"
 …
    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);
+}
 …
 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"
 …
    ";
   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++)
 …
     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
 …
+  {
     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";
+  }
 …
+  {
     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])+")";
+  }
 …
+  {
     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";
+  }
 …
    "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);
 …
 ///////////////////////////////////////////////////////////////////////////////
 /// Auxilary Procedures
+/// Auxilary Procedures
 ///////////////////////////////////////////////////////////////////////////////
 …
 "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;
 …
+{
   // 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);
 …
   // 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)
 …
         initialf=initialf+koef*leadmonom(f);
+      }
+    }
+    }
     f=f-lead(f);
+  }
 …
+{
   // 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
 …
   // keep only the largest ones
   int vglgewicht;
   f=f-lead(f);
+  f=f-lead(f);
   while (f!=0)
+  {
 …
         initialf=initialf+koef*leadmonom(f);
+      }
+    }
+    }
     f=f-lead(f);
+  }
 …
 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"
 …
 /////////////////////////////////////////////////////////////////////////
 proc detropicalise (poly p)
+proc detropicalise (poly p)
 "USAGE:   detropicalise(f); f poly
 ASSUME:   f is a linear polynomial with an arbitrary constant term and
           positive integer coefficients as further coefficients;
 RETURN:   poly, the detropicalisation of (the non-constant part of) f
 NOTE:     the output will be a monomial and the constant coefficient
+NOTE:     the output will be a monomial and the constant coefficient
           has been ignored
 EXAMPLE:  example detropicalise;   shows an example"
 …
+  {
     if (leadmonom(p)!=1)
+    {
+    {
       dtp=dtp*leadmonom(p)^int(leadcoef(p));
+    }
 …
 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
 …
    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 ...
 …
 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"
 …
+  {
     if (size(#)!=0)
+    {
+    {
       k=random(0,1);
+    }
     if (k==0)
+    {
+    {
       j=random(ug,og);
       randomPolynomial=randomPolynomial+t^j*m[i];
 …
 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*");
+}
 …
 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;
 …
   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;
 …
+  {
     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;
 …
         //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];
 …
           setring BASERING;
           winprim=1; // and stop the checking
+        }
+        }
         j1=j1+1;  //else we look at the next associated prime
+      }
 …
+    {
       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);
 …
   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
 …
+      {
         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;
 …
+    {
       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
+        {
 …
       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
 …
+    {
       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;
 …
+    {
       // 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++)
 …
           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
 …
         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);
 …
   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
 …
+    {
       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.
 …
   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]);
 …
       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))
 …
+    }
   //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;
 …
     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;
 …
+  {
     // 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);
 …
     // 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++)
 …
       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);
 …
+      }
     //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;
 …
       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;
 …
     //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
 …
             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
 …
         export(ini);
         export(repl);
         return(list(BASERINGLESS2,wvecp));
+        return(list(BASERINGLESS2,wvecp));
+      }
+    }
 …
 static proc tropicalparametriseNoabs (ideal i,intvec ww,int ordnung,int gfanold,int nogfan,list #)
 "USAGE:  tropicalparametriseNoabs(i,tw,ord,gf,ng[,#]); i ideal, tw intvec, ord int, gf,ng int, # opt. list
 ASSUME:  - i is an ideal in Q[t,x_1,...,x_n,X_1,...,X_k],
            tw=(w_0,w_1,...,w_n,0,...,0) and (w_0,...,w_n,0,...,0) is in
            the tropical variety of i, and ord is the order up to which a point
            in V(i) over C((t)) lying over w shall be computed;
+ASSUME:  - i is an ideal in Q[t,x_1,...,x_n,X_1,...,X_k],
+           tw=(w_0,w_1,...,w_n,0,...,0) and (w_0,...,w_n,0,...,0) is in
+           the tropical variety of i, and ord is the order up to which a point
+           in V(i) over C((t)) lying over w shall be computed;
          - moreover, k should be zero if the procedure is not called recursively;
          - the point in the tropical variety is supposed to lie in the NEGATIVE
+         - the point in the tropical variety is supposed to lie in the NEGATIVE
            orthant;
          - the ideal is zero-dimensional when considered
+         - the ideal is zero-dimensional when considered
            in (Q(t)[X_1,...,X_k]/m)[x_1,...,x_n],
            where m=#[2] is a maximal ideal in Q(t)[X_1,...,X_k];
+           where m=#[2] is a maximal ideal in Q(t)[X_1,...,X_k];
          - gf is 0 if version 2.2 or larger is used and it is 1 else
          - ng is 1 if gfan should not be executed
+         - ng is 1 if gfan should not be executed
 RETURN:  list, l[1] = ring Q(0,X_1,...,X_r)[[t]]
                l[2] = int
                l[3] = string
 NOTE:    - the procedure is also called recursively by itself, and
            if it is called in the first recursion, the list # is empty,
            otherwise #[1] is an integer, one more than the number
+           if it is called in the first recursion, the list # is empty,
+           otherwise #[1] is an integer, one more than the number
            of true variables x_1,...,x_n,
            and #[2] will contain the maximal ideal m in the variables X_1,...X_k
 …
            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"
+{
 …
   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
 …
     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);
 …
   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);
 …
     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);
 …
     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 !!!
 …
     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++;
 …
+  }
   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++)
 …
     variablen=variablen+var(jj);
+  }
   // if some variables have been eliminated,
+  // if some variables have been eliminated,
   // then pass to a new ring which has less variables,
   // but if no variables are left, then we are done
   def BASERING=basering;
   if ((numberdeletedvariables>0) and (anzahlvariablen>1)) // if only t remains,
+  if ((numberdeletedvariables>0) and (anzahlvariablen>1)) // if only t remains,
   { // all true variables are gone
     execute("ring NEURING=("+charstr(basering)+"),("+string(variablen)+"),(dp("+string(size(variablen)-1)+"),lp(1));");
     ideal i=imap(BASERING,i);
     ideal gesamt_m=imap(BASERING,gesamt_m);
+  }
   // now we have to compute a point ww on the tropical variety
+    ideal gesamt_m=imap(BASERING,gesamt_m);
+  }
+  // now we have to compute a point ww on the tropical variety
   // of the transformed ideal i;
   // of course, we only have to do so, if we have not yet
+  // of course, we only have to do so, if we have not yet
   // reached the order up to which we
   // were supposed to do our computations
   if ((ordnung>1) and (anzahlvariablen>1)) // if only t remains,
+  if ((ordnung>1) and (anzahlvariablen>1)) // if only t remains,
   { // all true variables are gone
     def PREGFANRING=basering;
     if (nogfan!=1)
+    {
+    {
       // pass to a ring which has variables which are suitable for gfan
       execute("ring GFANRING=("+charstr(basering)+"),(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z),dp;");
       ideal phiideal=b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z;
+      ideal phiideal=b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z;
       phiideal[nvars(PREGFANRING)]=a; // map t to a
       map phi=PREGFANRING,phiideal;
+      map phi=PREGFANRING,phiideal;
       ideal i=phi(i);
       // homogenise the ideal i with the first not yet
       // used variable in our ring, since gfan
       // only handles homogenous ideals; in principle
+      // homogenise the ideal i with the first not yet
+      // used variable in our ring, since gfan
+      // only handles homogenous ideals; in principle
       // for this one has first to compute a
       // standard basis of i and homogenise that,
       // but for the tropical variety (says Anders)
+      // standard basis of i and homogenise that,
+      // but for the tropical variety (says Anders)
       // it suffices to homogenise an arbitrary system of generators
       // i=groebner(i);
+      // i=groebner(i);
       i=homog(i,maxideal(1)[nvars(PREGFANRING)+1]);
       // if gfan version >= 0.3.0 is used and the characteristic
 …
         write(":a /tmp/gfaninput","{"+string(i)+"}");
+      }
       else
+      else
+      {
         // write the ideal to a file which gfan takes as input and call gfan
 …
         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;
 …
         "IF YOU WANT wneu TO BE TESTED, THEN SET goon=0;";
+        ~
           // THIS IS NOT NECESSARY !!!! IF WE COMPUTE NOT ONLY THE
+          // THIS IS NOT NECESSARY !!!! IF WE COMPUTE NOT ONLY THE
           // TROPICAL PREVARIETY
           // test, if wneu really is in the tropical variety
+          // test, if wneu really is in the tropical variety
         while (goon==0)
+        {
 …
+      {
         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
 …
+    }
+  }
   // if we have not yet computed our parametrisation
+  // if we have not yet computed our parametrisation
   // up to the required order and
   // zero is not yet a solution, then we have
+  // zero is not yet a solution, then we have
   // to go on by calling the procedure recursively;
   // if all variables were deleted, then i=0 and thus anzahlvariablen==0
   if ((ordnung>1) and (anzahlvariablen>1))
+  {
     // we call the procedure with the transformed ideal i,
+  {
+    // we call the procedure with the transformed ideal i,
     // the new weight vector, with the
     // required order lowered by one, and with
+    // required order lowered by one, and with
     // additional parameters, namely the number of
     // true variables and the maximal ideal that
+    // true variables and the maximal ideal that
     // was computed so far to describe the field extension
     list PARALIST=tropicalparametriseNoabs(i,wneu,ordnung-1,gfanold,nogfan,anzahlvariablen,gesamt_m);
     // the output will be a ring, in which the
+    // the output will be a ring, in which the
     // parametrisation lives, and a string, which contains
     // the maximal ideal that describes the necessary field extension
 …
     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)
 …
       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)
 …
+    }
+  }
   // 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
 …
     // 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))
 …
+    }
     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++)
 …
+    }
+  }
   // 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
+  }
 …
     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));
 …
 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")
 …
     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);
 …
+  {
     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);
+  }
 …
   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;
 …
+    }
+  }
   m=eliminate(m,elimvars);
   export(a);
+  m=eliminate(m,elimvars);
+  export(a);
   export(m);
   list m_ring=INITIALRING,neuvar,neuevariablen;
 …
 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
 …
                       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'"
 …
     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
 …
   // 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;
 …
     // 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)
 …
       else
+      {
         phiideal[j-1]=0;
+        phiideal[j-1]=0;
+      }
+    }
 …
       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
 …
     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++;
 …
+    {
       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]));
+      }
 …
   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
 …
 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"
 …
     ideal tin=tInitialIdeal(i,w,1);
+  }
   int j;
   ideal variablen;
 …
   def BASERING=basering;
   if (anzahlvariablen<nvars(basering))
+  {
+  {
     execute("ring TINRING=("+charstr(basering)+","+string(Parameter)+"),("+string(variablen)+"),dp;");
+  }
 …
   poly monom=imap(BASERING,monom);
   return(radicalMemberShip(monom,tin));
+}
+}
 /////////////////////////////////////////////////////////////////////////
 …
 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
 …
 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"
 …
 "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;
 …
   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
 …
+    {
       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)
 …
         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;
+        }
 …
+        }
+      }
       // 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;
 …
         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;
 …
     // 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
 …
+    }
+  }
   // 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
 …
     l=j;
     for (k=j-1;k>=1;k--)
+    {
+    {
       if (minassisort[l][2]<minassisort[k][2])
+      {
 …
 "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"
+{
 …
+  {
     if (koeffizienten[j-ord(p)+1]!=0)
+    {
+    {
       if ((j-(N*wj)/w1)==0)
+      {
 …
 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"
 …
 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
 …
       ideal i=imap(BASERING,i);
+    }
+  }
+  }
   else
+  {
 …
+  }
   // 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)
 …
   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);
 …
 /// - eliminatecomponents
 /// - findzerosAndBasictransform
 /// - ordermaximalideals
+/// - ordermaximalideals
 ///////////////////////////////////////////////////////////////////////////////
 static proc tropicalparametrise (ideal i,intvec ww,int ordnung,int gfanold,int findall,int nogfan,list #)
 "USAGE:  tropicalparametrise(i,tw,ord,gf,fa,ng[,#]); i ideal, tw intvec, ord int, gf,fa,ng int, # opt. list
 ASSUME:  - i is an ideal in Q[t,x_1,...,x_n,@a], tw=(w_0,w_1,...,w_n,0)
            and (w_0,...,w_n,0) is in the tropical variety of i,
            and ord is the order up to which a point in V(i)
            over K{{t}} lying over w shall be computed;
          - moreover, @a should be not be there if the procedure is not
+ASSUME:  - i is an ideal in Q[t,x_1,...,x_n,@a], tw=(w_0,w_1,...,w_n,0)
+           and (w_0,...,w_n,0) is in the tropical variety of i,
+           and ord is the order up to which a point in V(i)
+           over K{{t}} lying over w shall be computed;
+         - moreover, @a should be not be there if the procedure is not
            called recursively;
          - the point in the tropical variety is supposed to lie in the
            NEGATIVE orthant;
          - the ideal is zero-dimensional when considered in
            (K(t)[@a]/m)[x_1,...,x_n], where m=#[2] is a maximal ideal in K[@a];
+         - the ideal is zero-dimensional when considered in
+           (K(t)[@a]/m)[x_1,...,x_n], where m=#[2] is a maximal ideal in K[@a];
          - gf is 0 if version 2.2 or larger is used and it is 1 else
          - fa is 1 if all solutions should be found
 …
                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"
+{
 …
   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
 …
   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
 …
+  }
   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
 …
   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++)
 …
     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
 …
             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 -";
 …
             "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)
+            {
 …
+          {
             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
 …
+        }
+      }
       // 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
+          // 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)
 …
               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)
 …
+        }
+      }
       // 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))
 …
+        }
         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++)
 …
         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
+        }
 …
           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)
 …
+  }
   // kill the gfan files in /tmp
   system("sh","cd /tmp; /usr/bin/touch gfaninput; /usr/bin/touch gfanoutput; /bin/rm gfaninput; /bin/rm gfanoutput");
   // we return a list which contains lists of the parametrisation
+  system("sh","cd /tmp; /usr/bin/touch gfaninput; /usr/bin/touch gfanoutput; /bin/rm gfaninput; /bin/rm gfanoutput");
+  // we return a list which contains lists of the parametrisation
   // rings (with the parametrisation ideal)
   // and an integer N such that t should be replaced by t^1/N
 …
 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
 …
                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"
+{
 …
   // 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));
 …
     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);
 …
     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)
 …
+      {
         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)
 …
       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
 …
+        }
         else
+        {
+        {
           execute("ring SATURATERING=("+charstr(basering)+"),("+varstr(basering)+"),("+ordstr(basering)+");");
           ideal i=imap(BASERING,i);
 …
     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
 …
       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
+      }
 …
+    }
     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++)
 …
       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)
+    {
 …
+    {
       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);
 …
 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"
+{
 …
     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);
 …
     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;
 …
     // check fort the jth maximal ideal a field extension is necessary;
     // the latter condition says that @a is not in BASERING;
     // if some of the maximal ideals needs a field extension,
+    // if some of the maximal ideals needs a field extension,
     // then everything will live in this ring
     if ((maximalideals[j][1]!=0) and (nvars(BASERING)==anzahlvariablen))
+    {
       // define the extension ring which contains
+      // define the extension ring which contains
       // the new variable @a, if it is not yet present
       execute("ring EXTENSIONRING=("+charstr(BASERING)+"),("+string(imap(BASERING,variablen))+",@a,"+tvar+"),(dp("+string(anzahlvariablen-1)+"),dp(1),lp(1));");
       // phi maps x_i to x_i, @a to @a (if present in the ring),
+      // phi maps x_i to x_i, @a to @a (if present in the ring),
       // and the additional variable
       // for the field extension is mapped to @a as well
+      // for the field extension is mapped to @a as well
       // -- note that we only apply phi
       // to the list a, and in this list no @a is present;
+      // to the list a, and in this list no @a is present;
       // therefore, it does not matter where this is mapped to
       map phi=ABSRING,imap(BASERING,variablen),@a;
+    }
     else // @a was already present in the BASERING or no
+    else // @a was already present in the BASERING or no
     { // field extension is necessary
       execute("ring EXTENSIONRING=("+charstr(BASERING)+"),("+varstr(BASERING)+"),("+ordstr(BASERING)+");");
       // phi maps x_i to x_i, @a to @a (if present in the ring),
+      // phi maps x_i to x_i, @a to @a (if present in the ring),
       // and the additional variable
       // for the field extension is mapped to @a as well respectively to 0,
+      // for the field extension is mapped to @a as well respectively to 0,
       // if no @a is present;
       // note that we only apply phi to the list a and to
+      // note that we only apply phi to the list a and to
       // the replacement rule for
       // the old variable @a, and in this list resp.
       // replacement rule no @a is present;
+      // the old variable @a, and in this list resp.
+      // replacement rule no @a is present;
       // therefore, it does not matter where this is mapped to;
       if (anzahlvariablen<nvars(EXTENSIONRING)) // @a is in EXTENSIONRING
+      {
+      {
         // additional variable is mapped to @a
         map phi=ABSRING,imap(BASERING,variablen),@a;
+        map phi=ABSRING,imap(BASERING,variablen),@a;
+      }
       else
+      {
         // additional variable is mapped to 0
         map phi=ABSRING,imap(BASERING,variablen),0;
+        map phi=ABSRING,imap(BASERING,variablen),0;
+      }
+    }
 …
     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)
 …
+    {
       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));
 …
     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]));
+        }
 …
     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]);
 …
+    }
     // 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;
 …
     export(i);
     export(m);
     export(zero);
+    export(zero);
     extensionringlist[j]=EXTENSIONRING;
     kill EXTENSIONRING;
 …
 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"
 …
   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--)
+  {
 …
       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]);
 …
+    {
       // 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)
 …
+      }
+    }
     // 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
 …
     // 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
 …
+    }
+  }
   // 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
 …
     l=j;
     for (k=j-1;k>=1;k--)
+    {
+    {
       if (deg(minassisort[l][1])<deg(minassisort[k][1]))
+      {
 …
 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")
 …
+  }
   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
 …
   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++)
 …
             e++;
+          }
+        }
+        }
+      }
+    }
 …
 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"
 …
   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++)
 …
+    }
+  }
   // 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
 …
+      {
         vergleich=substitute(tp[l],var(1),px);
         if (vergleich==wert)
+        if (vergleich==wert)
+        {
           newton=newton+detropicalise(oldtp[l]);
 …
         e++;
+      }
+    }
+    }
+  }
   // if a vertex appears several times, only its first occurence will be kept
 …
     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);
 …