Index: Singular/LIB/brnoeth.lib
===================================================================
--- Singular/LIB/brnoeth.lib	(revision 1288efb1bc6f003f059484c99a625cf47c1ed08b)
+++ Singular/LIB/brnoeth.lib	(revision f32177e9dea6c9833a7f2f8986a2cf6273f30fab)
@@ -1,3 +1,3 @@
-version="$Id: brnoeth.lib,v 1.20 2008-10-07 17:36:30 Singular Exp $";
+version="$Id: brnoeth.lib,v 1.21 2009-04-07 09:30:44 seelisch Exp $";
 category="Coding theory";
 info="
@@ -8,5 +8,5 @@
 OVERVIEW:
  Implementation of the Brill-Noether algorithm for solving the
- Riemann-Roch problem and applications in Algebraic Geometry codes.
+ Riemann-Roch problem and applications to Algebraic Geometry codes.
  The computation of Weierstrass semigroups is also implemented.@*
  The procedures are intended only for plane (singular) curves defined over
@@ -15,19 +15,19 @@
 
 MAIN PROCEDURES:
- Adj_div(f);            computes the conductor of a curve
- NSplaces(h,A);         computes non-singular places with given degrees
- BrillNoether(D,C);     computes a vector space basis of the linear system L(D)
- Weierstrass(P,m,C);    computes the Weierstrass semigroup of C at P up to m
- extcurve(d,C);         extends the curve C to an extension of degree d
- AGcode_L(G,D,E);       computes the evaluation AG code with divisors G and D
- AGcode_Omega(G,D,E);   computes the residual AG code with divisors G and D
- prepSV(G,D,F,E);       preprocessing for the basic decoding algorithm
- decodeSV(y,K);         decoding of a word with the basic decoding algorithm
+ Adj_div(f)            computes the conductor of a curve
+ NSplaces(h,A)         computes non-singular places with given degrees
+ BrillNoether(D,C)     computes a vector space basis of the linear system L(D)
+ Weierstrass(P,m,C)    computes the Weierstrass semigroup of C at P up to m
+ extcurve(d,C)         extends the curve C to an extension of degree d
+ AGcode_L(G,D,E)       computes the evaluation AG code with divisors G and D
+ AGcode_Omega(G,D,E)   computes the residual AG code with divisors G and D
+ prepSV(G,D,F,E)       preprocessing for the basic decoding algorithm
+ decodeSV(y,K)         decoding of a word with the basic decoding algorithm
 
 AUXILIARY PROCEDURES:
- closed_points(I);      computes the zero-set of a zero-dim. ideal in 2 vars
- dual_code(C);          computes the dual code
- sys_code(C);           computes an equivalent systematic code
- permute_L(L,P);        applies a permutation to a list
+ closed_points(I)      computes the zero-set of a zero-dim. ideal in 2 vars
+ dual_code(C)          computes the dual code
+ sys_code(C)           computes an equivalent systematic code
+ permute_L(L,P)        applies a permutation to a list
 
 KEYWORDS:  Weierstrass semigroup; Algebraic Geometry codes;
@@ -3345,5 +3345,5 @@
           which represent the numerator, resp. denominator, of a rational
           function).@*
-          The corresponding rational functions form a vector basis of the
+          The corresponding rational functions form a vector space basis of the
           linear system L(G), G a rational divisor over a non-singular curve.
 NOTE:     The procedure must be called from the ring CURVE[1][2], where
@@ -3943,5 +3943,5 @@
           The intvec G represents a rational divisor (see @ref{BrillNoether}
           for more details).@*
-          The code evaluates the vector basis of L(G) at the rational
+          The code evaluates the vector space basis of L(G) at the rational
           places given by D.
 WARNINGS: G should satisfy @math{ 2*genus-2 < deg(G) < size(D) }, which is
Index: Singular/LIB/control.lib
===================================================================
--- Singular/LIB/control.lib	(revision 1288efb1bc6f003f059484c99a625cf47c1ed08b)
+++ Singular/LIB/control.lib	(revision f32177e9dea6c9833a7f2f8986a2cf6273f30fab)
@@ -1,34 +1,34 @@
-version="$Id: control.lib,v 1.39 2008-10-07 17:55:52 levandov Exp $";
+version="$Id: control.lib,v 1.40 2009-04-07 09:30:44 seelisch Exp $";
 category="System and Control Theory";
 info="
 LIBRARY:  control.lib     Algebraic analysis tools for System and Control Theory
 
-AUTHORS:  Oleksandr Iena       yena@mathematik.uni-kl.de
-@*        Markus Becker        mbecker@mathematik.uni-kl.de
-@*        Viktor Levandovskyy  levandov@mathematik.uni-kl.de
+AUTHORS:  Oleksandr Iena,       yena@mathematik.uni-kl.de
+@*        Markus Becker,        mbecker@mathematik.uni-kl.de
+@*        Viktor Levandovskyy,  levandov@mathematik.uni-kl.de
 
 SUPPORT: Forschungsschwerpunkt 'Mathematik und Praxis' (Project of Dr. E. Zerz
-and V. Levandovskyy), Uni Kaiserslautern
+and V. Levandovskyy), University of Kaiserslautern
 
 MAIN PROCEDURES:
-  control(R);     analysis of controllability-related properties of R (using Ext modules)
-  controlDim(R);  analysis of controllability-related properties of R (using dimension)
-  autonom(R);     analysis of autonomy-related properties of R (using Ext modules)
-  autonomDim(R);  analysis of autonomy-related properties of R (using dimension)
+  control(R)     analysis of controllability-related properties of R (using Ext modules)
+  controlDim(R)  analysis of controllability-related properties of R (using dimension)
+  autonom(R)     analysis of autonomy-related properties of R (using Ext modules)
+  autonomDim(R)  analysis of autonomy-related properties of R (using dimension)
 
 COMPONENT PROCEDURES:
-  leftKernel(R);       a left kernel of R
-  rightKernel(R);      a right kernel of R
-  leftInverse(R);      a left inverse of R
-  rightInverse(R);     a right inverse of R
-  colrank(M);          a column rank of M as of matrix
-  genericity(M);       analysis of the genericity of parameters
-  canonize(L);         Groebnerification for modules in the output of control or autonomy procs
-  iostruct(R);         computes an IO-structure of behavior given by a module R
-  findTorsion(R, I);   generators of the submodule of a module R, annihilated by the ideal I
+  leftKernel(R)       a left kernel of R
+  rightKernel(R)      a right kernel of R
+  leftInverse(R)      a left inverse of R
+  rightInverse(R)     a right inverse of R
+  colrank(M)          a column rank of M as of matrix
+  genericity(M)       analysis of the genericity of parameters
+  canonize(L)         Groebnerification for modules in the output of control or autonomy procs
+  iostruct(R)         computes an IO-structure of behavior given by a module R
+  findTorsion(R, I)   generators of the submodule of a module R, annihilated by the ideal I
 
 AUXILIARY PROCEDURES:
-  controlExample(s);   set up an example from the mini database inside of the library
-  view();              well-formatted output of lists, modules and matrices
+  controlExample(s)   set up an example from the mini database inside of the library
+  view()              well-formatted output of lists, modules and matrices
 ";
 
@@ -659,6 +659,7 @@
 RETURN:  list (of strings)
 PURPOSE: determine parametric expressions which have been assumed to be non-zero in the process of computing the Groebner basis
-NOTE: the output list consists of strings. The first string contains the variables only, whereas each further string contain a single polynomial in parameters.
-$* We strongly recommend to switch on the redSB and redTail options.
+NOTE: the output list consists of strings. The first string contains the variables only, whereas each further string contains
+      a single polynomial in parameters.
+@* We strongly recommend to switch on the redSB and redTail options.
 @* The procedure is effective with the lift procedure for modules with parameters
 EXAMPLE:  example genericity; shows an example
@@ -1415,5 +1416,5 @@
 PURPOSE: set up an example from the mini database by initalizing a ring and a module in a ring
 NOTE: in order to see the list of available examples, execute @code{controlExample(\"show\");}
-@* To use ab example, one has to do the following. Suppose one calls the ring, where the example will be activated, A. Then, by executing
+@* To use an example, one has to do the following. Suppose one calls the ring, where the example will be activated, A. Then, by executing
 @*  @code{def A = controlExample(\"Antenna\");} and @code{setring A;},
 @* A will become a basering from the example \"Antenna\" with
Index: Singular/LIB/general.lib
===================================================================
--- Singular/LIB/general.lib	(revision 1288efb1bc6f003f059484c99a625cf47c1ed08b)
+++ Singular/LIB/general.lib	(revision f32177e9dea6c9833a7f2f8986a2cf6273f30fab)
@@ -3,5 +3,5 @@
 //eric, added absValue 11.04.2002
 ///////////////////////////////////////////////////////////////////////////////
-version="$Id: general.lib,v 1.59 2009-01-14 16:07:04 Singular Exp $";
+version="$Id: general.lib,v 1.60 2009-04-07 09:30:44 seelisch Exp $";
 category="General purpose";
 info="
@@ -742,5 +742,5 @@
 NOTE:    If v is given id may be any simply indexed object (e.g. any list or
          string); if v[i]<0 and i<=size(id) v[i] is set internally to i;
-         entries of v must be pairwise distinct to get a permutation if id.
+         entries of v must be pairwise distinct to get a permutation id.
          Zero generators of ideal/module are deleted
 EXAMPLE: example sort; shows an example
@@ -1175,5 +1175,5 @@
                 type(l[3])=typeof(n)
 NOTE:    If n is a long integer (of type number) then the procedure
-         finds primefactors <= min(p,32003) but n may as larger as
+         finds primefactors <= min(p,32003) but n may be as larger as
          2147483647 (max. integer representation)
 WARNING: the procedure works for small integers only, just by testing all
Index: Singular/LIB/inout.lib
===================================================================
--- Singular/LIB/inout.lib	(revision 1288efb1bc6f003f059484c99a625cf47c1ed08b)
+++ Singular/LIB/inout.lib	(revision f32177e9dea6c9833a7f2f8986a2cf6273f30fab)
@@ -1,5 +1,5 @@
 // (GMG/BM, last modified 22.06.96)
 ///////////////////////////////////////////////////////////////////////////////
-version="$Id: inout.lib,v 1.32 2009-02-23 12:08:39 Singular Exp $";
+version="$Id: inout.lib,v 1.33 2009-04-07 09:30:44 seelisch Exp $";
 category="General purpose";
 info="
@@ -566,5 +566,5 @@
 
 proc showrecursive (@@id,poly p,list #)
-"USAGE:   showrecursive(id,p[,ord]); id= any object of basering, p= product of
+"USAGE:   showrecursive(id,p[,ord]); id any object of basering, p= product of
          variables and ord=string (any allowed ordstr)
 DISPLAY: display 'id' in a recursive format as a polynomial in the variables
Index: Singular/LIB/poly.lib
===================================================================
--- Singular/LIB/poly.lib	(revision 1288efb1bc6f003f059484c99a625cf47c1ed08b)
+++ Singular/LIB/poly.lib	(revision f32177e9dea6c9833a7f2f8986a2cf6273f30fab)
@@ -1,4 +1,4 @@
 ///////////////////////////////////////////////////////////////////////////////
-version="$Id: poly.lib,v 1.51 2009-02-20 18:50:55 Singular Exp $";
+version="$Id: poly.lib,v 1.52 2009-04-07 09:30:44 seelisch Exp $";
 category="General purpose";
 info="
@@ -259,6 +259,6 @@
 COMPUTE: rank of module presented by M in case it is free.
          By definition this is vdim(coker(M)/m*coker(M)) if coker(M)
-         is free, where m = maximal ideal of the variables of the
-         basering and M is considered as matrix.
+         is free, where m is the maximal ideal of the variables of the
+         basering and M is considered to be a matrix.
          (the 0-module is free of rank 0)
 RETURN:  rank of coker(M) if coker(M) is free and -1 else;
@@ -361,7 +361,5 @@
          corresponding component of id, independent of ring ordering
          (maxdeg of each var is 1).
-         Of type int if id is of type poly, of type intmat else
-NOTE:    proc maxdeg1 returns an integer, the absolute maximum; moreover, it has
-         an option for computing weighted degrees
+         Of type int, if id is of type poly; of type intmat otherwise
 SEE ALSO: maxdeg1
 EXAMPLE: example maxdeg; shows examples
@@ -498,6 +496,5 @@
          (mindeg of each variable is 1) of type int if id of type poly, else
          of type intmat.
-NOTE:    proc mindeg1 returns one integer, the absolute minimum; moreover it
-         has an option for computing weighted degrees.
+SEE ALSO: mindeg1
 EXAMPLE: example mindeg; shows examples
 "
@@ -630,6 +627,6 @@
 proc normalize (id)
 "USAGE:   normalize(id);  id=poly/vector/ideal/module
-RETURN:  object of same type,s
-         each element is normalized to make its leading coefficient equal to 1
+RETURN:  object of same type
+         each element is normalized with leading coefficient equal to 1
 EXAMPLE: example normalize; shows an example
 "
Index: Singular/LIB/redcgs.lib
===================================================================
--- Singular/LIB/redcgs.lib	(revision 1288efb1bc6f003f059484c99a625cf47c1ed08b)
+++ Singular/LIB/redcgs.lib	(revision f32177e9dea6c9833a7f2f8986a2cf6273f30fab)
@@ -1,4 +1,4 @@
 //////////////////////////////////////////////////////////////////////////////
-version="$Id: redcgs.lib,v 1.4 2009-02-26 14:07:04 Singular Exp $";
+version="$Id: redcgs.lib,v 1.5 2009-04-07 09:30:44 seelisch Exp $";
 category="General purpose";
 info="
@@ -3253,5 +3253,5 @@
           The elements of the list T computed by mrcgs are lists representing
           a rooted tree.
-          Each element has as the two first entries with the following content:
+          Each element has as the two first entries with the following content:@*
            [1]: The label (intvec) representing the position in the rooted
                 tree:  0 for the root (and this is a special element)
@@ -3596,5 +3596,5 @@
           The elements of the list T computed by rcgs are lists representing
           a rooted tree.
-          Each element has as the two first entries with the following content:
+          Each element has as the two first entries with the following content:@*
            [1]: The label (intvec) representing the position in the rooted
                 tree:  0 for the root (and this is a special element)
@@ -3778,5 +3778,5 @@
           The elements of the list T computed by crcgs are lists representing
           a rooted tree.
-          Each element has as the two first entries with the following content:
+          Each element has as the two first entries with the following content:@*
            [1]: The label (intvec) representing the position in the rooted
                 tree:  0 for the root (and this is a special element)
