Index: Singular/LIB/graphics.lib
===================================================================
--- Singular/LIB/graphics.lib	(revision bb9471e2e1af065ffce285ee2e4d142ab2d974b0)
+++ Singular/LIB/graphics.lib	(revision 0bc582ce3f42d033e854938a1175f56baba17b23)
@@ -1,8 +1,8 @@
 //last change: 13.02.2001 (Eric Westenberger)
 ///////////////////////////////////////////////////////////////////////////////
-version="$Id: graphics.lib,v 1.12 2008-12-12 17:22:35 Singular Exp $";
+version="$Id: graphics.lib,v 1.13 2009-04-06 09:17:01 seelisch Exp $";
 category="Visualization";
 info="
-LIBRARY: graphics.lib    Procedures to use Graphics with Mathematica
+LIBRARY: graphics.lib    Procedures for graphical output using Mathematica
 AUTHOR:   Christian Gorzel, gorzelc@math.uni-muenster.de
 
@@ -15,9 +15,9 @@
 ///////////////////////////////////////////////////////////////////////////////
 
-proc staircase(string fname,ideal I)
-"USAGE:   staircase(s,I); s a string, I ideal in two variables
+proc staircase(ideal I)
+"USAGE:   staircase(I); I an ideal in two variables
 RETURN:  string with Mathematica input for displaying staircase diagrams of an
          ideal I, i.e. exponent vectors of the initial ideal of I
-NOTE:    ideal I should be given by a standard basis. Let s=\"\" and copy and
+NOTE:    ideal I should be given by a standard basis. Copy and
          paste the result into a Mathematica notebook.
 EXAMPLE: example staircase; shows an example
@@ -64,13 +64,13 @@
   ring r0 = 0,(x,y),ls;
   ideal I = -1x2y6-1x4y2, 7x6y5+1/2x7y4+6x4y6;
-  staircase("",std(I));
+  staircase(std(I));
 
   ring r1 = 0,(x,y),dp;
   ideal I = fetch(r0,I);
-  staircase("",std(I));
+  staircase(std(I));
 
   ring r2 = 0,(x,y),wp(2,3);
   ideal I = fetch(r0,I);
-  staircase("",std(I));
+  staircase(std(I));
 
   // Paste the output into a Mathematica notebook
Index: Singular/LIB/ntsolve.lib
===================================================================
--- Singular/LIB/ntsolve.lib	(revision bb9471e2e1af065ffce285ee2e4d142ab2d974b0)
+++ Singular/LIB/ntsolve.lib	(revision 0bc582ce3f42d033e854938a1175f56baba17b23)
@@ -1,5 +1,5 @@
 //(GMG, last modified 16.12.00)
 ///////////////////////////////////////////////////////////////////////////////
-version="$Id: ntsolve.lib,v 1.15 2006-07-18 15:48:29 Singular Exp $";
+version="$Id: ntsolve.lib,v 1.16 2009-04-06 09:17:01 seelisch Exp $";
 category="Symbolic-numerical solving";
 info="
@@ -20,8 +20,8 @@
   gls: contains the equations, for which a solution will be computed@*
   ini: ideal of initial values (approximate solutions to start with),@*
-  ipar: control integers (default: ipar = 100,10)
+  ipar: control integers (default: ipar = [100, 10])
   @format
  ipar[1]: max. number of iterations
- ipar[2]: accuracy (we have the l_2-norm ||.||): accept solution @code{sol}
+ ipar[2]: accuracy (we have the l_2-norm ||.||): accepts solution @code{sol}
           if ||gls(sol)|| < eps0*(0.1^ipar[2])
           where eps0 = ||gls(ini)|| is the initial error
@@ -262,9 +262,9 @@
   a:   ideal of numbers, coordinates of an approximation of a common
        zero of G to start with (with a[i] to be substituted in var(i)),@*
-  ipar: control integer vector (default: ipar = 100,10)
+  ipar: control integer vector (default: ipar = [100, 10])
   @format
   ipar[1]: max. number of iterations
   ipar[2]: accuracy (we have as norm |.| absolute value ):
-           accept solution @code{sol} if |G(sol)| < |G(a)|*(0.1^ipar[2]).
+           accepts solution @code{sol} if |G(sol)| < |G(a)|*(0.1^ipar[2]).
   @end format
 RETURN:  an ideal, coordinates of a better approximation of a zero of G
Index: Singular/LIB/presolve.lib
===================================================================
--- Singular/LIB/presolve.lib	(revision bb9471e2e1af065ffce285ee2e4d142ab2d974b0)
+++ Singular/LIB/presolve.lib	(revision 0bc582ce3f42d033e854938a1175f56baba17b23)
@@ -1,4 +1,4 @@
 ///////////////////////////////////////////////////////////////////////////////
-version="$Id: presolve.lib,v 1.28 2009-02-20 09:26:50 Singular Exp $";
+version="$Id: presolve.lib,v 1.29 2009-04-06 09:17:01 seelisch Exp $";
 category="Symbolic-numerical solving";
 info="
@@ -164,5 +164,5 @@
   @format
   L[1]: ideal obtained from i by substituting from the first n variables those
-        which appear in a linear part of i, by putting this part into triangular 
+        which appear in a linear part of i, by putting this part into triangular
         form
   L[2]: ideal of variables which have been substituted
@@ -326,5 +326,5 @@
             k[x(1..m)]/i -> k[..variables from [4]..]/[1]
   @end format
-NOTE:    Applying elimpart to interred(i) may result in more sbstitutions.
+NOTE:    Applying elimpart to interred(i) may result in more substitutions.
          However, interred may be more expansive than elimpart for big ideals
 EXAMPLE: example elimpart; shows an example
@@ -561,5 +561,5 @@
 
 proc fastelim (ideal i, poly p, list #)
-"USAGE:   fastelim(i,p[h,o,a,b,e,m]); i=ideal, p=polynomial; h,o,a,b,e=integers
+"USAGE:   fastelim(i,p[h,o,a,b,e,m]); i=ideal, p=polynomial; h,o,a,b,e=integers@*
           p: product of variables to be eliminated;@*
   Optional parameters:
@@ -871,7 +871,6 @@
 proc hilbvec (@id, list #)
 "USAGE:   hilbvec(id[,c,o]); id=poly/ideal/vector/module/matrix, c,o=strings,@*
-          c=char, o=ordering used by @code{hilb}@*
-          (default: c=\"32003\", o=\"dp\")
-RETURN:  intvec of 1-st Hilbert-series of id, computed in char c and ordering o
+          c=char, o=ordering used by @code{hilb} (default: c=\"32003\", o=\"dp\")
+RETURN:  intvec of 1st Hilbert-series of id, computed in char c and ordering o
 NOTE:    id must be homogeneous (i.e. all vars have weight 1)
 EXAMPLE: example hilbvec; shows an example
@@ -969,10 +968,9 @@
 
 proc solvelinearpart (id,list #)
-"USAGE:   solvelinearpart(id [,n] );  id=ideal/module, n=integer,@*
-          (default: n=0)
+"USAGE:   solvelinearpart(id [,n] );  id=ideal/module, n=integer (default: n=0)
 RETURN:  (interreduced) generators of id of degree <=1 in reduced triangular
          form if n=0 [non-reduced triangular form if n!=0]
 ASSUME:  monomial ordering is a global ordering (p-ordering)
-NOTE:    may be used to solve a system of linear equations
+NOTE:    may be used to solve a system of linear equations,
          see @code{gauss_row} from 'matrix.lib' for a different method
 WARNING: the result is very likely to be false for 'real' coefficients, use
@@ -1036,5 +1034,5 @@
   - ni controls the sorting in i-th block (= vars occuring in pi):
     ni=0 (resp. ni!=0) means that least complex (resp. most complex) vars come
-    first @*
+    first
   - oi and mi define the monomial ordering of the i-th block:
     if mi =0, oi=ordstr(i-th block)
@@ -1118,5 +1116,5 @@
          id=poly/ideal/vector/module,@*
          p1,p2,...= polynomials (product of vars),@*
-         n1,n2,...=integers@*
+         n1,n2,...= integers@*
          (default: p1=product of all vars, n1=0)
          the last pi (containing the remaining vars) may be omitted
@@ -1128,9 +1126,9 @@
        ni=0 (resp. ni!=0) means that less (resp. more) complex vars come first
   [2]: a list with 4 entries for each pi:
-       ideal ai : vars of pi in correct order,
-       intvec vi: permutation vector describing the ordering in ai,
-       intmat Mi: valuation matrix of ai, the columns of Mi being the
+       _[1]: ideal ai : vars of pi in correct order,
+       _[2]: intvec vi: permutation vector describing the ordering in ai,
+       _[3]: intmat Mi: valuation matrix of ai, the columns of Mi being the
                   valuation vectors of the vars in ai
-       intvec wi: size of 1-st, 2-nd,... block of identical columns of Mi
+       _[4]: intvec wi: size of 1-st, 2-nd,... block of identical columns of Mi
                   (vars with same valuation)
   @end format
@@ -1183,6 +1181,5 @@
 
          ni controls the ordering of vars occuring in pi: ni=0 (resp. ni!=0)
-         means that less (resp. more) complex vars come first@*
-         (default: p1=product of all vars, n1=0)
+         means that less (resp. more) complex vars come first (default: p1=product of all vars, n1=0),@*
          the last pi (containing the remaining vars) may be omitted
 COMPUTE: valuation (complexity) of variables with respect to id.@*
Index: Singular/LIB/ring.lib
===================================================================
--- Singular/LIB/ring.lib	(revision bb9471e2e1af065ffce285ee2e4d142ab2d974b0)
+++ Singular/LIB/ring.lib	(revision 0bc582ce3f42d033e854938a1175f56baba17b23)
@@ -1,4 +1,4 @@
 ///////////////////////////////////////////////////////////////////////////////
-version="$Id: ring.lib,v 1.32 2008-03-25 15:20:08 Singular Exp $";
+version="$Id: ring.lib,v 1.33 2009-04-06 09:17:01 seelisch Exp $";
 category="General purpose";
 info="
@@ -279,5 +279,5 @@
             If, however, a and b are local to a proc calling extendring, the
             intvec iv must be used to let extendring know the values of a and b
-@*        -  If an intvec iv !=0 is given, iv[1],iv[2],... is taken for the
+@*        -  If a non-zero intvec iv is given, iv[1],iv[2],... are taken for the
             1st, 2nd,... block of o, if o contains no substring \"w\" or \"W\"
             i.e. no weighted ordering (in the above case o=\"ds,dp,ls\"
@@ -286,5 +286,5 @@
             allowed) iv[1] is taken as size for the weight-vector, the next
             iv[1] values of iv are taken as weights and the remaining values of
-            iv as block-size for the remaining non-weighted blocks.
+            iv as block size for the remaining non-weighted blocks.
             e.g. o=\"dp,ws,Dp,ds\", iv=3,2,3,4,2,5 creates the ordering
             dp(2),ws(2,3,4),Dp(5),ds
@@ -416,9 +416,9 @@
 proc fetchall (R, list #)
 "USAGE:   fetchall(R[,s]);  R=ring/qring, s=string
-CREATE:  fetch all objects of ring R (of type poly/ideal/vector/module/number/
-         matrix) into the basering.
+CREATE:  fetch all objects of ring R (of type poly/ideal/vector/module/number/matrix)
+         into the basering.
          If no 2nd argument is present, the names are the same as in R. If,
          say, f is a poly in R and the 2nd argument is the string \"R\", then f
-         is maped to f_R etc.
+         is mapped to f_R etc.
 RETURN:  no return value
 NOTE:    As fetch, this procedure maps the 1st, 2nd, ... variable of R to the
@@ -462,12 +462,12 @@
 proc imapall (R, list #)
 "USAGE:   imapall(R[,s]);  R=ring/qring, s=string
-CREATE:  map all objects of ring R (of type poly/ideal/vector/module/number/
-         matrix) into the basering, by applying imap to all objects of R.
+CREATE:  map all objects of ring R (of type poly/ideal/vector/module/number/matrix)
+         into the basering by applying imap to all objects of R.
          If no 2nd argument is present, the names are the same as in R. If,
          say, f is a poly in R and the 3rd argument is the string \"R\", then f
-         is maped to f_R etc.
+         is mapped to f_R etc.
 RETURN:  no return value
 NOTE:    As imap, this procedure maps the variables of R to the variables with
-         the same name in the basering, the other variables are maped to 0.
+         the same name in the basering, the other variables are mapped to 0.
          The 2nd argument is useful in order to avoid conflicts of names, the
          empty string is allowed
@@ -509,8 +509,8 @@
 "USAGE:   mapall(R,i[,s]);  R=ring/qring, i=ideal of basering, s=string
 CREATE:  map all objects of ring R (of type poly/ideal/vector/module/number/
-         matrix, map) into the basering, by mapping the jth variable of R to
-         the jth generator of the ideal i. If no 3rd argument is present, the
+         matrix, map) into the basering by mapping the j-th variable of R to
+         the j-th generator of the ideal i. If no 3rd argument is present, the
          names are the same as in R. If, say, f is a poly in R and the 3rd
-         argument is the string \"R\", then f is maped to f_R etc.
+         argument is the string \"R\", then f is mapped to f_R etc.
 RETURN:  no return value.
 NOTE:    This procedure has the same effect as defining a map, say psi, by
@@ -549,9 +549,9 @@
 //   j; print(M); phi;    //phi maps R to S: x->c2, y->a2, z->b2
 //   ideal i1=a2,a+b,1;
-//   mapall(R,i1,\"\");   //map from R to S: x->a2, y->a+b, z->1
+//   mapall(R,i1,\"\");     //map from R to S: x->a2, y->a+b, z->1
 //   names(S);
 //   j_; print(M_); phi_;
 //   changevar(\"T\",\"x()\",R);  //change vars in R and call result T
-//   mapall(R,maxideal(1));       //identity map from R to T
+//   mapall(R,maxideal(1));   //identity map from R to T
 //   names(T);
 //   j; print(M); phi;
@@ -645,5 +645,5 @@
    def S=changevar("x,y,z");       //change vars of s
    setring S;
-   qring qS =std(fetch(s,i));      //create qring of S mod i (maped to S)
+   qring qS =std(fetch(s,i));      //create qring of S mod i (mapped to S)
    def T=changevar("d,e,f,g,h",t); //change vars of t
    setring T;
@@ -687,7 +687,7 @@
         all input parameters of type string
 RETURN:  ideal
-PURPOSE: computes the preimage of an ideal under a given map for non-global
+PURPOSE: compute the preimage of an ideal under a given map for non-global
          orderings.
-         The second argument has to be the name of a map from the basering to
+         The 2nd argument has to be the name of a map from the basering to
          the given ring (or the name of an ideal defining such a map), and
          the ideal has to be an ideal in the given ring.
Index: Singular/LIB/signcond.lib
===================================================================
--- Singular/LIB/signcond.lib	(revision bb9471e2e1af065ffce285ee2e4d142ab2d974b0)
+++ Singular/LIB/signcond.lib	(revision 0bc582ce3f42d033e854938a1175f56baba17b23)
@@ -1,3 +1,3 @@
-// $Id: signcond.lib,v 1.7 2006-07-18 15:48:30 Singular Exp $
+// $Id: signcond.lib,v 1.8 2009-04-06 09:17:01 seelisch Exp $
 // E. Tobis  12.Nov.2004
 // last change 5. May 2005 (G.-M. Greuel)
@@ -26,7 +26,7 @@
 
 proc firstoct(ideal I)
-"USAGE:    firstoct(i); i ideal
-RETURN:   number: the number of points of V(i) lying in the first octant
-ASSUME:   i is a Groebner basis
+"USAGE:    firstoct(I); I ideal
+RETURN:   number: the number of points of V(I) lying in the first octant
+ASSUME:   I is given by a Groebner basis.
 SEE ALSO: signcnd
 EXAMPLE:  example firstoct; shows an example"
@@ -80,7 +80,7 @@
            give rise to the sign condition expressed by the same position on
            the first list.
-           See the example for further explanation of the output.
-ASSUME:    I is a Groebner basis
-NOTE:      The procedure psigncnd performs some pretty printing of this output
+           See the example for further explanations of the output.
+ASSUME:    I is a Groebner basis.
+NOTE:      The procedure psigncnd performs some pretty printing of this output.
 SEE ALSO:  firstoct, psigncnd
 EXAMPLE:   example signcnd; shows an example"
Index: Singular/LIB/solve.lib
===================================================================
--- Singular/LIB/solve.lib	(revision bb9471e2e1af065ffce285ee2e4d142ab2d974b0)
+++ Singular/LIB/solve.lib	(revision 0bc582ce3f42d033e854938a1175f56baba17b23)
@@ -1,4 +1,4 @@
 ///////////////////////////////////////////////////////////////////////////////
-version="$Id: solve.lib,v 1.37 2009-01-06 14:15:21 Singular Exp $";
+version="$Id: solve.lib,v 1.38 2009-04-06 09:17:01 seelisch Exp $";
 category="Symbolic-numerical solving";
 info="
@@ -28,9 +28,9 @@
 proc laguerre_solve( poly f, list # )
 "USAGE:   laguerre_solve(f [, m, l, n, s] ); f = polynomial,@*
-         m, l, n, s = integers (control parameters of the method)
+         m, l, n, s = integers (control parameters of the method)@*
  m: precision of output in digits ( 4 <= m), if basering is not ring of
       complex numbers;
  l: precision of internal computation in decimal digits ( l >=8 )
-      only if the basering is not complex or complex with smaller precision;
+      only if the basering is not complex or complex with smaller precision;@*
  n: control of multiplicity of roots or of splitting of f into
       squarefree factors
@@ -202,5 +202,5 @@
       {
         if(charstr(rn)=="0"){dbprint(prot,"// polynomial is squarefree");}
-        else{dbprint(prot,"// split without result");}
+        else{dbprint(prot,"//split without result");}
       }
     }
@@ -517,5 +517,5 @@
 proc solve( ideal G, list # )
 "USAGE:   solve(G [, m, n [, l]] [,\"oldring\"] [,\"nodisplay\"] ); G = ideal,
-         m, n, l = integers (control parameters of the method), outR ring
+         m, n, l = integers (control parameters of the method), outR ring,@*
          m: precision of output in digits ( 4 <= m) and of the generated ring
             of complex numbers;
@@ -1476,5 +1476,5 @@
 proc mp_res_mat( ideal i, list # )
 "USAGE:   mp_res_mat(i [, k] ); i ideal, k integer,
-    k=0: sparse resultant matrix of Gelfand, Kapranov and Zelevinsky,
+    k=0: sparse resultant matrix of Gelfand, Kapranov and Zelevinsky,@*
     k=1: resultant matrix of Macaulay (k=0 is default)
 ASSUME:  The number of elements in the input system must be the number of
@@ -2043,5 +2043,5 @@
 proc triang_solve( list lfi, int prec, list # )
 "USAGE:   triang_solve(l,p [,d] ); l=list, p,d=integers@*
-         l a list of finitely many triangular systems, such that the union of
+         l is a list of finitely many triangular systems, such that the union of
          their varieties equals the variety of the initial ideal.@*
          p>0: gives precision of complex numbers in digits,@*
Index: Singular/LIB/triang.lib
===================================================================
--- Singular/LIB/triang.lib	(revision bb9471e2e1af065ffce285ee2e4d142ab2d974b0)
+++ Singular/LIB/triang.lib	(revision 0bc582ce3f42d033e854938a1175f56baba17b23)
@@ -1,5 +1,5 @@
 //last change: 13.02.2001 (Eric Westenberger)
 //////////////////////////////////////////////////////////////////////////////
-version="$Id: triang.lib,v 1.12 2008-10-01 14:20:22 Singular Exp $";
+version="$Id: triang.lib,v 1.13 2009-04-06 09:17:01 seelisch Exp $";
 category="Symbolic-numerical solving";
 info="
@@ -629,8 +629,7 @@
          If i = 2, then each polynomial of the triangular systems
          is factorized.
-NOTE:    Algorithm of Moeller (see: Moeller, H.M.:
-         On decomposing systems of polynomial equations with
-         finitely many solutions, Appl. Algebra Eng. Commun. Comput. 4,
-         217 - 230, 1993).
+NOTE:    Algorithm of Moeller (see: Moeller, H.M.: On decomposing systems of 
+         polynomial equations with finitely many solutions, Appl. Algebra Eng. 
+         Commun. Comput. 4, 217 - 230, 1993).
 EXAMPLE: example triangM; shows an example
 "
Index: Singular/LIB/zeroset.lib
===================================================================
--- Singular/LIB/zeroset.lib	(revision bb9471e2e1af065ffce285ee2e4d142ab2d974b0)
+++ Singular/LIB/zeroset.lib	(revision 0bc582ce3f42d033e854938a1175f56baba17b23)
@@ -1,11 +1,11 @@
 // Last change 12.02.2001 (Eric Westenberger)
 ///////////////////////////////////////////////////////////////////////////////
-version="$Id: zeroset.lib,v 1.18 2008-10-09 09:31:58 Singular Exp $";
+version="$Id: zeroset.lib,v 1.19 2009-04-06 09:17:01 seelisch Exp $";
 category="Symbolic-numerical solving";
 info="
-LIBRARY:  zeroset.lib      Procedures For Roots and Factorization
-AUTHOR:   Thomas Bayer,    email: tbayer@mathematik.uni-kl.de
-          http://wwwmayr.informatik.tu-muenchen.de/personen/bayert/
-          Current Address: Institut fuer Informatik, TU Muenchen
+LIBRARY:  zeroset.lib      Procedures for roots and factorization
+AUTHOR:   Thomas Bayer,    email: tbayer@mathematik.uni-kl.de,@*
+          http://wwwmayr.informatik.tu-muenchen.de/personen/bayert/@*
+          Current address: Hochschule Ravensburg-Weingarten
 
 OVERVIEW:
@@ -18,4 +18,6 @@
  of Singular for univariate factorization of polynomials over simple algebraic
  extensions in characteristic 0.
+ 
+ NOTE:
  Subprocedures with postfix 'Main' require that the ring contains a variable
  'a' and no parameters, and the ideal 'mpoly', where 'minpoly' from the
@@ -23,20 +25,20 @@
 
 PROCEDURES:
- Quotient(f, g)    quotient q  of f w.r.t. g (in f = q*g + remainder)
- Remainder(f,g)    remainder of the division of f by g
- Roots(f)    computes all roots of f in an extension field of Q
- SQFRNorm(f)    norm of f (f must be squarefree)
- ZeroSet(I)    zero-set of the 0-dim. ideal I
+ quotient(f, g)    quotient q  of f w.r.t. g (in f = q*g + remainder)
+ remainder(f,g)    remainder of the division of f by g
+ roots(f)    computes all roots of f in an extension field of Q
+ sqfrNorm(f)    norm of f (f must be squarefree)
+ zeroSet(I)    zero-set of the 0-dim. ideal I
 
 AUXILIARY PROCEDURES:
- EGCDMain(f, g)    gcd over an algebraic extension field of Q
- FactorMain(f)    factorization of f over an algebraic extension field
- InvertNumberMain(c)  inverts an element of an algebraic extension field
- QuotientMain(f, g)  quotient of f w.r.t. g
- RemainderMain(f,g)  remainder of the division of f by g
- RootsMain(f)    computes all roots of f, might extend the ground field
- SQFRNormMain(f)  norm of f (f must be squarefree)
- ContainedQ(data, f)  f in data ?
- SameQ(a, b)    a == b (list a,b)
+ egcdMain(f, g)    gcd over an algebraic extension field of Q
+ factorMain(f)    factorization of f over an algebraic extension field
+ invertNumberMain(c)  inverts an element of an algebraic extension field
+ quotientMain(f, g)  quotient of f w.r.t. g
+ remainderMain(f,g)  remainder of the division of f by g
+ rootsMain(f)    computes all roots of f, might extend the ground field
+ sqfrNormMain(f)  norm of f (f must be squarefree)
+ containedQ(data, f)  f in data ?
+ sameQ(a, b)    a == b (list a,b)
 ";
 
@@ -57,5 +59,5 @@
 
 // Improvement :
-// a main problem is the growth of the coefficients. Try Roots(x7 - 1)
+// a main problem is the growth of the coefficients. Try roots(x7 - 1)
 // return ideal mpoly !
 // mpoly is not monic, comes from primitive_extra
@@ -75,6 +77,6 @@
 ///////////////////////////////////////////////////////////////////////////////
 
-proc Roots(poly f)
-"USAGE:   Roots(f); where f is a polynomial
+proc roots(poly f)
+"USAGE:   roots(f); where f is a polynomial
 PURPOSE: compute all roots of f in a finite extension of the ground field
          without multiplicities.
@@ -91,5 +93,5 @@
   @end format
 ASSUME:  ground field to be Q or a simple extension of Q given by a minpoly
-EXAMPLE: example  Roots; shows an example
+EXAMPLE: example  roots; shows an example
 "
 {
@@ -108,5 +110,5 @@
 
   poly f = imap(ROB, f);
-  list result = RootsMain(f);  // find roots of f
+  list result = rootsMain(f);  // find roots of f
 
   // store the roots and the new representation of 'a' and transform
@@ -130,8 +132,8 @@
   export(newA);
   export(f); dbprint(dbPrt,"
-// 'Roots' created a new ring which contains the list 'roots' and
+// 'roots' created a new ring which contains the list 'roots' and
 // the polynomials 'f' and 'newA'
 // To access the roots, newA and the new representation of f, type
-   def R = Roots(f); setring R; roots; newA; f;
+   def R = roots(f); setring R; roots; newA; f;
 ");
   return(RON);
@@ -142,5 +144,5 @@
   minpoly = a2+1;
   poly f = x3 - a;
-  def R1 = Roots(f);
+  def R1 = roots(f);
   setring R1;
   minpoly;
@@ -155,6 +157,6 @@
 ///////////////////////////////////////////////////////////////////////////////
 
-proc RootsMain(poly f)
-"USAGE:   RootsMain(f); where f is a polynomial
+proc rootsMain(poly f)
+"USAGE:   rootsMain(f); where f is a polynomial
 PURPOSE: compute all roots of f in a finite extension of the ground field
          without multiplicities.
@@ -162,11 +164,11 @@
   @format
   _[1] = roots of f, each entry is a polynomial
-  _[2] = 'newA' - if the ground field is Q(a') and the extension field
-         is Q(a), then 'newA' is the representation of a' in Q(a)
+  _[2] = 'newA' - if the ground field is Q(b) and the extension field
+         is Q(a), then 'newA' is the representation of b in Q(a)
   _[3] = minpoly of the algebraic extension of the ground field
   @end format
 ASSUME:  basering = Q[x,a] ideal mpoly must be defined, it might be 0!
 NOTE:    might change the ideal mpoly!!
-EXAMPLE: example  Roots; shows an example
+EXAMPLE: example  roots; shows an example
 "
 {
@@ -182,6 +184,6 @@
   // nonlinear factors are processed later
 
-  dbprint(dbPrt, "Roots of " + string(f) +  ", minimal polynomial = " + string(mpoly[1]));
-  factorList = FactorMain(f);          // Factorize f
+  dbprint(dbPrt, "roots of " + string(f) +  ", minimal polynomial = " + string(mpoly[1]));
+  factorList = factorMain(f);          // Factorize f
   dbprint(dbPrt, (" prime factors of f are : " + string(factorList[1])));
 
@@ -193,5 +195,5 @@
       linFactors++;        // get the root from the linear factor
       lc = LeadTerm(fa, 1)[3];
-      fa = MultPolys(InvertNumberMain(lc), fa); // make factor monic
+      fa = MultPolys(invertNumberMain(lc), fa); // make factor monic
       roots[linFactors] = var(1) - fa;  // fa is monic !!
     }
@@ -227,5 +229,5 @@
     // compute the roots of the nonlinear (irreducible, monic) factor f1 of f
     // by extending the basefield by a' with minimal polynomial f1
-    // Then call Roots(f1) to find the roots of f1 over the new base field
+    // Then call roots(f1) to find the roots of f1 over the new base field
 
     f1 = nlFactors[1];
@@ -247,5 +249,5 @@
     result[3] = mpoly[1];
     oldMinPoly = mpoly[1];
-    partSol = RootsMain(f1);    // find roots of f1 over extended field
+    partSol = rootsMain(f1);    // find roots of f1 over extended field
 
     if(oldMinPoly != partSol[3]) {    // minpoly has changed ?
@@ -262,5 +264,5 @@
   }
   else {  // more than one nonlinear (irreducible) factor (f_1,...,f_r)
-    // solve each of them by RootsMain(f_i), append their roots
+    // solve each of them by rootsMain(f_i), append their roots
     // change the minpoly and transform all previously computed
     // roots if necessary.
@@ -271,5 +273,5 @@
     for(i = 1; i <= size(nlFactors); i = i + 1) {
       oldMinPoly = mpoly[1];
-      partSol = RootsMain(nlFactors[i]);    // main work
+      partSol = rootsMain(nlFactors[i]);    // main work
       nlFactors[i] = 0;        // delete factor
       result[3] = partSol[3];        // store minpoly
@@ -297,6 +299,6 @@
 ///////////////////////////////////////////////////////////////////////////////
 
-proc ZeroSet(ideal I, list #)
-"USAGE:   ZeroSet(I [,opt] ); I=ideal, opt=integer
+proc zeroSet(ideal I, list #)
+"USAGE:   zeroSet(I [,opt] ); I=ideal, opt=integer
 PURPOSE: compute the zero-set of the zero-dim. ideal I, in a finite extension
          of the ground field.
@@ -306,6 +308,6 @@
   @format
   - 'zeroset' is the list of the zeros of the ideal I, each zero is an ideal.
-  - if the ground field is Q(a') and the extension field is Q(a), then
-    'newA' is the representation of a' in Q(a).
+  - if the ground field is Q(b) and the extension field is Q(a), then
+    'newA' is the representation of b in Q(a).
     If the basering contains a parameter 'a' and the minpoly remains unchanged
     then 'newA' = 'a'.
@@ -315,9 +317,9 @@
 ASSUME:  dim(I) = 0, and ground field to be Q or a simple extension of Q given
          by a minpoly.
-OPTIONS: opt = 0 no primary decomposition (default)
-         opt > 0 primary decomposition
-NOTE:    If I contains an algebraic number (parameter) then 'I' must be
+OPTIONS: opt = 0: no primary decomposition (default)
+         opt > 0: primary decomposition
+NOTE:    If I contains an algebraic number (parameter) then I must be
          transformed w.r.t. 'newA' in the new ring.
-EXAMPLE: example ZeroSet; shows an example
+EXAMPLE: example zeroSet; shows an example
 "
 {
@@ -347,5 +349,5 @@
   }
 
-  list result = ZeroSetMain(id, primaryDecQ);
+  list result = zeroSetMain(id, primaryDecQ);
 
   // store the zero-set, minimal polynomial and the new representative of 'a'
@@ -376,9 +378,9 @@
   export(newA);
     dbprint(dbPrt,"
-// 'ZeroSet' created a new ring which contains the list 'zeroset', the ideal
+// 'zeroSet' created a new ring which contains the list 'zeroset', the ideal
 // 'id' and the polynomial 'newA'. 'id' is the ideal of the input transformed
 // w.r.t. 'newA'.
 // To access the zero-set, 'newA' and the new representation of the ideal, type
-   def R = ZeroSet(I); setring R; zeroset; newA; id;
+   def R = zeroSet(I); setring R; zeroset; newA; id;
 ");
   setring RZSB;
@@ -390,5 +392,5 @@
   minpoly = a2 + 1;
   ideal I = x2 - 1/2, a*z - 1, y - 2;
-  def T = ZeroSet(I);
+  def T = zeroSet(I);
   setring T;
   minpoly;
@@ -404,6 +406,6 @@
 ///////////////////////////////////////////////////////////////////////////////
 
-proc InvertNumberMain(poly f)
-"USAGE:   InvertNumberMain(f); where f is a polynomial
+proc invertNumberMain(poly f)
+"USAGE:   invertNumberMain(f); where f is a polynomial
 PURPOSE: compute 1/f if f is a number in Q(a), i.e., f is represented by a
          polynomial in Q[a].
@@ -468,6 +470,6 @@
 ///////////////////////////////////////////////////////////////////////////////
 
-proc Quotient(poly f, poly g)
-"USAGE:   Quotient(f, g); where f,g are polynomials;
+proc quotient(poly f, poly g)
+"USAGE:   quotient(f, g); where f,g are polynomials;
 PURPOSE: compute the quotient q and remainder r s.t. f = g*q + r, deg(r) < deg(g)
 RETURN:  list of polynomials
@@ -478,5 +480,5 @@
 ASSUME:  basering = Q[x] or Q(a)[x]
 NOTE: outdated, use div/mod instead
-EXAMPLE: example  Quotient; shows an example
+EXAMPLE: example  quotient; shows an example
 "
 {
@@ -487,5 +489,5 @@
   poly f = imap(QUOB, f);
   poly g = imap(QUOB, g);
-  list result = QuotientMain(f, g);
+  list result = quotientMain(f, g);
 
   setring(QUOB);
@@ -500,11 +502,11 @@
  poly f =  x4 - 2;
  poly g = x - a;
- list qr = Quotient(f, g);
+ list qr = quotient(f, g);
  qr;
  qr[1]*g + qr[2] - f;
 }
 
-proc QuotientMain(poly f, poly g)
-"USAGE:   QuotientMain(f, g); where f,g are polynomials
+proc quotientMain(poly f, poly g)
+"USAGE:   quotientMain(f, g); where f,g are polynomials
 PURPOSE: compute the quotient q and remainder r s.th. f = g*q + r, deg(r) < deg(g)
 RETURN:  list of polynomials
@@ -516,5 +518,5 @@
          this represents the ring Q(a)[x] together with its minimal polynomial.
 NOTE: outdated, use div/mod instead
-EXAMPLE: example  Quotient; shows an example
+EXAMPLE: example  quotient; shows an example
 "
 {
@@ -532,6 +534,6 @@
 ///////////////////////////////////////////////////////////////////////////////
 
-proc Remainder(poly f, poly g)
-"USAGE:   Remainder(f, g); where f,g are polynomials
+proc remainder(poly f, poly g)
+"USAGE:   remainder(f, g); where f,g are polynomials
 PURPOSE: compute the remainder of the division of f by g, i.e. a polynomial r
          s.t. f = g*q + r, deg(r) < deg(g).
@@ -547,5 +549,5 @@
   poly f = imap(REMB, f);
   poly g = imap(REMB, g);
-  poly h = RemainderMain(f, g);
+  poly h = remainderMain(f, g);
 
   setring(REMB);
@@ -560,9 +562,9 @@
  poly f =  x4 - 1;
  poly g = x3 - 1;
- Remainder(f, g);
-}
-
-proc RemainderMain(poly f, poly g)
-"USAGE:   RemainderMain(f, g); where f,g are polynomials
+ remainder(f, g);
+}
+
+proc remainderMain(poly f, poly g)
+"USAGE:   remainderMain(f, g); where f,g are polynomials
 PURPOSE: compute the remainder r s.t. f = g*q + r, deg(r) < deg(g)
 RETURN:  poly
@@ -579,5 +581,5 @@
 
   lc = LeadTerm(g, 1)[3];
-  g1 = MultPolys(InvertNumberMain(lc), g);  // make g monic
+  g1 = MultPolys(invertNumberMain(lc), g);  // make g monic
 
   return(SimplifyPoly(reduce(f, std(g1))));
@@ -586,6 +588,6 @@
 ///////////////////////////////////////////////////////////////////////////////
 
-proc EGCDMain(poly f, poly g)
-"USAGE:   EGCDMain(f, g); where f,g are polynomials
+proc egcdMain(poly f, poly g)
+"USAGE:   egcdMain(f, g); where f,g are polynomials
 PURPOSE: compute the polynomial gcd of f and g over Q(a)[x]
 RETURN:  poly
@@ -604,5 +606,5 @@
 
   while(r2 != 0) {
-    r  = RemainderMain(r1, r2);
+    r  = remainderMain(r1, r2);
     r1 = r2;
     r2 = r;
@@ -648,6 +650,6 @@
 ///////////////////////////////////////////////////////////////////////////////
 
-proc SQFRNorm(poly f)
-"USAGE:   SQFRNorm(f); where f is a polynomial
+proc sqfrNorm(poly f)
+"USAGE:   sqfrNorm(f); where f is a polynomial
 PURPOSE: compute the norm of the squarefree polynomial f in Q(a)[x].
 RETURN:  list with 3 entries
@@ -659,5 +661,5 @@
 ASSUME:  f must be squarefree, basering = Q(a)[x] and minpoly != 0.
 NOTE:    the norm is an element of Q[x]
-EXAMPLE: example  SQFRNorm; shows an example
+EXAMPLE: example  sqfrNorm; shows an example
 "
 {
@@ -667,5 +669,5 @@
   setring SNR;
   poly f = imap(SNB, f);
-  list result = SQFRNormMain(f);  // squarefree norm of f
+  list result = sqfrNormMain(f);  // squarefree norm of f
 
   setring SNB;
@@ -679,9 +681,9 @@
    minpoly = a2+1;
   poly f =  x4 - 2*x + 1;
-  SQFRNorm(f);
-}
-
-proc SQFRNormMain(poly f)
-"USAGE:   SQFRNorm(f); where f is a polynomial
+  sqfrNorm(f);
+}
+
+proc sqfrNormMain(poly f)
+"USAGE:   sqfrNorm(f); where f is a polynomial
 PURPOSE: compute the norm of the squarefree polynomial f in Q(a)[x].
 RETURN:  list with 3 entries
@@ -734,6 +736,6 @@
 ///////////////////////////////////////////////////////////////////////////////
 
-proc FactorMain(poly f)
-"USAGE:   FactorMain(f); where f is a polynomial
+proc factorMain(poly f)
+"USAGE:   factorMain(f); where f is a polynomial
 PURPOSE: compute the factorization of the squarefree poly f over Q(a)[t],
          minpoly  = p(a).
@@ -771,5 +773,5 @@
   fac1[1] = 1;
   fac2[1] = 1;
-  normList = SQFRNormMain(f);
+  normList = sqfrNormMain(f);
   // print(" factorize : deg = " + string(deg(normList[1], intvec(1,0))));
   factorList = factorize(normList[1]);     // factor squarefree norm of f over Q[x]
@@ -782,6 +784,6 @@
   for(i = 2; i <= size(factorList[1]); i = i + 1) {
     H = factorList[1][i];
-    h = EGCDMain(H, g);
-    quo_rem = QuotientMain(g, h);
+    h = egcdMain(H, g);
+    quo_rem = quotientMain(g, h);
     g = quo_rem[1];
     fac1[i] = SimplifyPoly(F(h));
@@ -793,6 +795,6 @@
 ///////////////////////////////////////////////////////////////////////////////
 
-proc ZeroSetMain(ideal I, int primDecQ)
-"USAGE:   ZeroSetMain(ideal I, int opt); ideal I, int opt
+proc zeroSetMain(ideal I, int primDecQ)
+"USAGE:   zeroSetMain(ideal I, int opt); ideal I, int opt
 PURPOSE: compute the zero-set of the zero-dim. ideal I, in a simple extension
          of the ground field.
@@ -812,9 +814,9 @@
 NOTE:    opt = 0  no primary decomposition
          opt > 0  use a primary decomposition
-EXAMPLE: example ZeroSet; shows an example
-"
-{
-  // main work is done in ZeroSetMainWork, here the zero-set of each ideal from the
-  // primary decompostion is coputed by menas of ZeroSetMainWork, and then the
+EXAMPLE: example zeroSet; shows an example
+"
+{
+  // main work is done in zeroSetMainWork, here the zero-set of each ideal from the
+  // primary decompostion is coputed by menas of zeroSetMainWork, and then the
   // minpoly and the parameter representing the algebraic extension are
   // transformed according to 'newA', i.e., only bookeeping is done.
@@ -829,5 +831,5 @@
 
   dbPrt = printlevel-voice+2;
-  dbprint(dbPrt, "ZeroSet of " + string(I) + ", minpoly = " + string(minpoly));
+  dbprint(dbPrt, "zeroSet of " + string(I) + ", minpoly = " + string(minpoly));
 
   n = nvars(basering) - 1;
@@ -835,5 +837,5 @@
   w[n + 1] = 0;
 
-  if(primDecQ == 0) { return(ZeroSetMainWork(I, w, 0)); }
+  if(primDecQ == 0) { return(zeroSetMainWork(I, w, 0)); }
 
   newA = var(n + 1);
@@ -862,5 +864,5 @@
     oldMinPoly = mpoly[1];
     dbprint(dbPrt, " ideal#" + string(i) + " of " + string(size(idealList)) + " = " + string(J));
-    currentSol = ZeroSetMainWork(J, w, 0);
+    currentSol = zeroSetMainWork(J, w, 0);
 
     if(oldMinPoly != currentSol[3]) {   // change minpoly and transform solutions
@@ -883,6 +885,6 @@
 ///////////////////////////////////////////////////////////////////////////////
 
-proc ZeroSetMainWork(ideal id, intvec wt, int sVars)
-"USAGE:   ZeroSetMainWork(I, wt, sVars);
+proc zeroSetMainWork(ideal id, intvec wt, int sVars)
+"USAGE:   zeroSetMainWork(I, wt, sVars);
 PURPOSE: compute the zero-set of the zero-dim. ideal I, in a finite extension
          of the ground field (without multiplicities).
@@ -958,5 +960,5 @@
   // substitute each partial solution in generators and find the
   // zero set of the resulting ideal by recursive application
-  // of ZeroSetMainWork !
+  // of zeroSetMainWork !
 
   index = linIndex + nlinIndex;
@@ -968,5 +970,5 @@
     gens = std(SimplifyData(Fsubs(generators)));    // substitute partial solution
     oldMinPoly = mpoly[1];
-    partSol = ZeroSetMainWork(gens, wt, size(index) + sVars);
+    partSol = zeroSetMainWork(gens, wt, size(index) + sVars);
 
     if(oldMinPoly != partSol[3]) {    // minpoly has changed
@@ -1028,5 +1030,5 @@
         nrSols++; found++;
         index[nrSols] = vars[1];
-        sol[nrSols] = var(vars[1]) - MultPolys(InvertNumberMain(LeadTerm(f, vars[1])[3]), f);
+        sol[nrSols] = var(vars[1]) - MultPolys(invertNumberMain(LeadTerm(f, vars[1])[3]), f);
       }
     }
@@ -1050,5 +1052,5 @@
 
 proc NonLinearZeroSetMain(ideal I, intvec wt)
-"USAGE:   ZeroSetMainWork(I, wt, sVars);
+"USAGE:   NonLinearZeroSetMain(I, wt);
 PURPOSE: solves the (nonlinear) univariate polynomials in I
          of the ground field (without multiplicities).
@@ -1103,5 +1105,5 @@
       export(RIS1);
       export(mpoly);
-      roots = RootsMain(f);
+      roots = rootsMain(f);
 
       // get "old" basering with new minpoly
@@ -1180,5 +1182,5 @@
          'sol2' is a list of partial solutions (from 'NonLinearZeroSetMain')
 ASSUME:  'sol2' is not empty
-NOTE:    used by 'ZeroSetMainWork'
+NOTE:    used by 'zeroSetMainWork'
 {
   int i, j, k, m;
@@ -1211,5 +1213,5 @@
   ideal I;
   for(int i = 1; i <= nvars(basering) - 1; i = i + 1) {    // built subs. map
-    if(ContainedQ(index, i)) {
+    if(containedQ(index, i)) {
       k++;
       I[index[k]] = sol[k];
@@ -1266,6 +1268,6 @@
 ///////////////////////////////////////////////////////////////////////////////
 
-proc ContainedQ(data, f, list #)
-"USAGE:    ContainedQ(data, f [, opt]); data=list; f=any type, opt=integer
+proc containedQ(data, f, list #)
+"USAGE:    containedQ(data, f [, opt]); data=list; f=any type; opt=integer
 PURPOSE:  test if f is an element of data.
 RETURN:   int
@@ -1273,5 +1275,5 @@
           1 if f contained in data
 OPTIONS:  opt = 0 : use '==' for comparing f with elements from data@*
-          opt = 1 : use @code{SameQ} for comparing f with elements from data
+          opt = 1 : use @code{sameQ} for comparing f with elements from data
 "
 {
@@ -1288,5 +1290,5 @@
     }
     else {
-      if(SameQ(f, data[i])) { found = 1;}
+      if(sameQ(f, data[i])) { found = 1;}
       else {i = i + 1;}
     }
@@ -1297,6 +1299,6 @@
 //////////////////////////////////////////////////////////////////////////////
 
-proc SameQ(a, b)
-"USAGE:    SameQ(a, b); a,b=list/intvec
+proc sameQ(a, b)
+"USAGE:    sameQ(a, b); a,b=list/intvec
 PURPOSE:  test a == b elementwise, i.e., a[i] = b[i].
 RETURN:   int
