Changeset 3c4dcc in git

Timestamp:

May 6, 2005, 4:39:20 PM (18 years ago)

Author:

Hans Schönemann <hannes@…>

Branches:

(u'spielwiese', '828514cf6e480e4bafc26df99217bf2a1ed1ef45')

Children:

0d217d3f1cc4c0449bdb078c65fd1f43cd1a2b84

Parents:

e6fb5315eb32da00236163ce10f9bdafaaa0bd47

Message:

*hannes: DOS->UNIX and white space cleanup


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

Location:

Singular/LIB

Files:

• KVequiv.lib (modified) (24 diffs)
• algebra.lib (modified) (7 diffs)
• brnoeth.lib (modified) (7 diffs)
• center.lib (modified) (117 diffs)
• classify.lib (modified) (5 diffs)
• control.lib (modified) (75 diffs)
• deform.lib (modified) (9 diffs)
• digimult.lib (modified) (6 diffs)
• equising.lib (modified) (116 diffs)
• finvar.lib (modified) (2 diffs)
• gaussman.lib (modified) (5 diffs)
• general.lib (modified) (3 diffs)
• gkdim.lib (modified) (7 diffs)
• gmspoly.lib (modified) (3 diffs)
• gmssing.lib (modified) (2 diffs)
• groebnerwalk.lib (modified) (39 diffs)
• groups.lib (modified) (37 diffs)
• hnoether.lib (modified) (106 diffs)
• inout.lib (modified) (4 diffs)
• involut.lib (modified) (37 diffs)
• latex.lib (modified) (64 diffs)
• linalg.lib (modified) (7 diffs)
• matrix.lib (modified) (3 diffs)
• mregular.lib (modified) (46 diffs)
• ncalg.lib (modified) (22 diffs)
• ncdecomp.lib (modified) (6 diffs)
• nchomolog.lib (modified) (17 diffs)
• nctools.lib (modified) (17 diffs)
• normal.lib (modified) (61 diffs)
• poly.lib (modified) (5 diffs)
• presolve.lib (modified) (20 diffs)
• primdec.lib (modified) (3 diffs)
• primitiv.lib (modified) (3 diffs)
• qhmoduli.lib (modified) (1 diff)
• qmatrix.lib (modified) (12 diffs)
• resolve.lib (modified) (2 diffs)
• ring.lib (modified) (15 diffs)
• rinvar.lib (modified) (18 diffs)
• signcond.lib (modified) (3 diffs)
• sing.lib (modified) (8 diffs)
• solve.lib (modified) (50 diffs)
• spcurve.lib (modified) (4 diffs)
• surf.lib (modified) (2 diffs)
• triang.lib (modified) (1 diff)
• zeroset.lib (modified) (6 diffs)

Singular/LIB/KVequiv.lib

@@ -1 @@
-// $Id: KVequiv.lib,v 1.1 2001-11-27 15:56:15 anne Exp $
+// $Id: KVequiv.lib,v 1.2 2005-05-06 14:38:03 hannes Exp $
 // (anne, last modified 27.11.2001)
 /////////////////////////////////////////////////////////////////////////////
@@ -5 +5 @@
 /////////////////////////////////////////////////////////////////////////////
 
-version="$Id: KVequiv.lib,v 1.1 2001-11-27 15:56:15 anne Exp $";
+version="$Id: KVequiv.lib,v 1.2 2005-05-06 14:38:03 hannes Exp $";
 info="
 LIBRARY:  KVequiv.lib    PROCEDURES RELATED TO K_V-EQUIVALENCE
@@ -15 +15 @@
  derlogV(iV);                   derlog(V(iV))
  KVtangent(I,rname,dername,k)   K_V tangent space to given singularity
- KVversal(KVtan,I,rname,idname) K_V versal family 
+ KVversal(KVtan,I,rname,idname) K_V versal family
  KVvermap(KVtan,I)              section inducing K_V versal family
  lft_vf(I,rname,idname)         liftable vector fields
@@ -21 +21 @@
 REMARKS:
  * monomial ordering should be of type (c,...)
- * monomial ordering should be local on the original (2) rings 
+ * monomial ordering should be local on the original (2) rings
 ";
 ////////////////////////////////////////////////////////////////////////////
@@ -31 +31 @@
 
 // then the ones written in C/C++
-LIB("loctriv.so"); 
+LIB("loctriv.so");
 
 ////////////////////////////////////////////////////////////////////////////
@@ -39 +39 @@
 proc derlogV(ideal iV)
 "USAGE:  @code{derlogV(iV)};   @code{iV} ideal
-RETURN:  matrix whose columns generate derlog(V(iV)) 
+RETURN:  matrix whose columns generate derlog(V(iV))
 EXAMPLE: @code{example derlogV}; shows an example
 "
@@ -79 +79 @@
                                                  @code{rname,dername} strings
                                                  @code{[k]} int
-RETURN:   K_V tangent space to a singularity given as a section of a 
-          model singularity 
-NOTE:     The model singularity lives in the ring given by rname and 
+RETURN:   K_V tangent space to a singularity given as a section of a
+          model singularity
+NOTE:     The model singularity lives in the ring given by rname and
           its derlog(V) is given by dername in that ring. The section is
-          specified by the generators of mapi. If k is given, the first k 
+          specified by the generators of mapi. If k is given, the first k
           variables are used as variables, the remaining ones as parameters
 EXAMPLE:  @code{example KVtangent}; shows an example
@@ -178 +178 @@
                                                   @code{rname,idname} strings
 RETURN:   list; The first entry of the list is the new ring in which the
-          K_V versal family lives, the second is the name of the ideal 
-          describing a K_V versal family of a singularity given as section 
+          K_V versal family lives, the second is the name of the ideal
+          describing a K_V versal family of a singularity given as section
           of a model singularity (which was specified as idname in rname)
 NOTE:     The section is given by the generators of I, KVtan is the matrix
           describing the K_V tangent space to the singularity (as returned
-          by KVtangent). rname denotes the ring in which the model 
+          by KVtangent). rname denotes the ring in which the model
           singularity lives, and idname is the name of the ideal in this ring
           defining the singularity.
@@ -231 +231 @@
 // Extend our current ring by adjoining the correct number of variables
 // A(i) for the parameters and copy our objects to this ring
-//---------------------------------------------------------------------------  
+//---------------------------------------------------------------------------
   def rbas=basering;
   ring rtemp=0,(A(1..size(kbKVt))),(c,dp);
@@ -270 +270 @@
   ideal idy=ab,cd;
   def dV=derlogV(idy);
-  echo=1; 
+  echo=1;
   export ry; export dV; export idy; echo=2;
   ring rx=0,(x,y,z),ds;
@@ -279 +279 @@
   setring rnew;
   `li[2]`;
-  echo=1; 
+  echo=1;
   setring ry; kill idy; kill dV; setring rx; kill ry;
 }
@@ -286 +286 @@
 proc KVvermap(matrix KVtan, ideal mapi)
 "USAGE:   @code{KVvermap(KVtan,I)};  @code{KVtan} matrix, @code{I} ideal
-RETURN:   list; The first entry of the list is the new ring in which the 
-          versal object lives, the second specifies a map describing the 
-          section which yields a K_V versal family of the original 
+RETURN:   list; The first entry of the list is the new ring in which the
+          versal object lives, the second specifies a map describing the
+          section which yields a K_V versal family of the original
           singularity which was given as section of a model singularity
 NOTE:     The section is given by the generators of I, KVtan is the matrix
@@ -321 +321 @@
 // Extend our current ring by adjoining the correct number of variables
 // A(i) for the parameters and copy our objects to this ring
-//---------------------------------------------------------------------------  
+//---------------------------------------------------------------------------
   def rbas=basering;
   ring rtemp=0,(A(1..size(kbKVt))),(c,dp);
@@ -350 +350 @@
   ideal idy=ab,cd;
   def dV=derlogV(idy);
-  echo=1; 
+  echo=1;
   export ry; export dV; export idy; echo=2;
   ring rx=0,(x,y,z),ds;
@@ -359 +359 @@
   setring rnew;
   `li[2]`;
-  echo=1; 
+  echo=1;
   setring ry; kill idy; kill dV; setring rx; kill ry;
 }
@@ -373 +373 @@
 RETURN: list
         [1]: ring in which objects specified by the strings [2] and [3] live
-        [2]: name of ideal describing the liftable vector fields - 
+        [2]: name of ideal describing the liftable vector fields -
              computed up to order b in the parameters
         [3]: name of basis of the K_V-normal space of the original singularity
         [4]: (if 6th argument is given)
-             ring in which the reduction of the liftable vector fields has 
+             ring in which the reduction of the liftable vector fields has
              taken place.
         [5]: name of liftable vector fields in ring [4]
@@ -386 +386 @@
         ring rname in the ideal idname, the resulting expression is
         quasihomogeneous; wv specifies the weight vector of the ring rname.
-        b is the degree bound up in the perturbation parameters up to which
-        computations are performed.
+        b is the degree bound up in the perturbation parameters up to which
+        computations are performed.
 NOTE:   the original ring should not contain any variables of name
         A(i) or e(j)
-EXAMPLE:@code{example lft_vf;} gives an example 
+EXAMPLE:@code{example lft_vf;} gives an example
 "
 {
@@ -431 +431 @@
 // first prepare derlog(V) for the model singularity
 // and set the correct weights
-//---------------------------------------------------------------------------  
+//---------------------------------------------------------------------------
   def @dV=derlogV(`idname`);
   export(@dV);
@@ -453 +453 @@
   }
 //---------------------------------------------------------------------------
-// Construction of the versal family 
+// Construction of the versal family
 //---------------------------------------------------------------------------
   list lilit=KVvermap(KVt,mapi);
@@ -464 +464 @@
 //---------------------------------------------------------------------------
 // put the unperturbed and the perturbed tangent space into a module
-// (1st component unperturbed) and run a groebner basis computation 
+// (1st component unperturbed) and run a groebner basis computation
 // which only considers spolys with non-vanishing first component
 //---------------------------------------------------------------------------
   def rxa=basering;
-  string rchange="ring rexa=" + charstr(basering) + ",(e(1.." + 
-                 string(ncols(mapi)) + ")," + varstr(basering) + 
+  string rchange="ring rexa=" + charstr(basering) + ",(e(1.." +
+                 string(ncols(mapi)) + ")," + varstr(basering) +
                  "),(c,ws(" + string((-1)*wv) + "," + string(ivm) + "),dp);";
   execute(rchange);
@@ -557 +557 @@
       mt=mt,Aus2[2,i];
     }
-  }  
+  }
 //---------------------------------------------------------------------------
 // * change weights of the A(i) such that Aus2[1,i] and Aus2[2,i] have the
 //   same leading term, if the first one is non-zero
-// * reduce mt by mx 
+// * reduce mt by mx
 // * find l such that (x_1,...,x_n)^l * eid can be used instead of noether
 //   which we have to avoid because we are playing with the weights
@@ -571 +571 @@
   }
   mx=jet(mx,counter*(b+1),qiv);
-  rchange="ring rexaw=" + charstr(basering) + ",(" + varstr(basering) + 
+  rchange="ring rexaw=" + charstr(basering) + ",(" + varstr(basering) +
                       "),(c,ws(" + string((-1)*wv) + "," + string(ivm) +
                       "," + string(oiv) + "));";
@@ -654 +654 @@
   ideal idy=ab,cd;
   def dV=derlogV(idy);
-  echo=1; 
+  echo=1;
   export ry; export dV; export idy; echo=2;
   ring rx=0,(x,y,z),ds;
@@ -665 +665 @@
   `li[2]`;
   `li[3]`;
-  echo=1; 
+  echo=1;
   setring ry; kill idy; kill dV; setring rx; kill ry;
 }

Singular/LIB/algebra.lib

@@ -1 +1 @@
 ///////////////////////////////////////////////////////////////////////////////
-version="$Id: algebra.lib,v 1.10 2005-04-28 09:22:14 Singular Exp $";
+version="$Id: algebra.lib,v 1.11 2005-05-06 14:38:03 hannes Exp $";
 category="Commutative Algebra";
 info="
@@ -99 +99 @@
 // e.g.:
                def S = l[2]; setring S; check;
-        ");
+        ");
      return(l);
     }
@@ -287 +287 @@
 "USAGE:   algDependent(f[,c]); f ideal (say, f = f1,...,fm), c integer
 RETURN:
-@format 
+@format
          a list l  of size 2, l[1] integer, l[2] ring:
          - l[1] = 1 if f1,...,fm are algebraic dependent, 0 if not
@@ -398 +398 @@
 // e.g.:
              def S = l[2]; setring S; ker;
-        ");
+        ");
     return (L);
 }
@@ -492 +492 @@
 "USAGE:   is_injective(phi[,c,s]); phi map, pr reimage ring, c int, s string
 RETURN:
-@format 
+@format
          - 1 (type int) if phi is injective, 0 if not (if s is not given).
          - If s is given, return a list l of size 2, l[1] int, l[2] ring:
@@ -564 +564 @@
 // e.g.:
      def S = l[2]; setring S; ker;
-        ");
+        ");
       return(L);
     }
@@ -754 +754 @@
 "USAGE:   noetherNormal(id[,p]);  id ideal, p integer
 RETURN:
-@format 
+@format
          a list l two ideals, say I,J:
          - I is generated by a subset of the variables with size(I) = dim(id)

Singular/LIB/brnoeth.lib

@@ -1 @@
-version="$Id: brnoeth.lib,v 1.14 2005-04-19 15:23:38 Singular Exp $";
+version="$Id: brnoeth.lib,v 1.15 2005-05-06 14:38:04 hannes Exp $";
 category="Coding theory";
 info="
@@ -1148 +1148 @@
   int i,j,k;
   int m,n;
-//  list L@HNE=essdevelop(CHI);  
+//  list L@HNE=essdevelop(CHI);
   list LLL=ratdevelop(CHI);
   if (typeof(LLL[1])=="ring") {
@@ -2043 +2043 @@
              + "executing Adj_div, as 'a' is used for "
              + "the name of the parameter of the field extensions needed.");
-      ERROR("Please rename or kill the object named 'a'"); 
+      ERROR("Please rename or kill the object named 'a'");
     }
   }
@@ -2197 +2197 @@
           See @ref{Adj_div} for a description of the entries in L.
 NOTE:     The list_expression should be the output of the procedure Adj_div.@*
-          Raising @code{printlevel}, additional comments are displayed 
+          Raising @code{printlevel}, additional comments are displayed
           (default: @code{printlevel=0}).
 WARNING:  The parameter of the needed field extensions is called 'a'. Thus,
@@ -2220 +2220 @@
              + "executing Adj_div, as 'a' is used for "
              + "the name of the parameter of the field extensions needed.");
-      ERROR("Please rename or kill the object named 'a'"); 
+      ERROR("Please rename or kill the object named 'a'");
     }
   }
@@ -2918 +2918 @@
   if (typeof(LLL[1])=="ring") {
     def altring=basering;
-    def HNEring = LLL[1]; 
+    def HNEring = LLL[1];
     setring HNEring;
     def L@HNE = hne[1];
@@ -2951 +2951 @@
   }
   kill LLL;
-  
+
   list BRANCH=list();
   BRANCH[1]=Maux;

Singular/LIB/center.lib

@@ -1 +1 @@
 ///////////////////////////////////////////////////////////////////////////////
-version="$Id: center.lib,v 1.13 2005-02-23 18:10:44 levandov Exp $";
+version="$Id: center.lib,v 1.14 2005-05-06 14:38:08 hannes Exp $";
 category="Noncommutative";
 info="
@@ -6 +6 @@
 AUTHOR:  Oleksandr Motsak,        motsak@mathematik.uni-kl.de.
 OVERVIEW:
- This is a library for computing the central elements and centralizers of elements in various noncommutative algebras. 
+ This is a library for computing the central elements and centralizers of elements in various noncommutative algebras.
  Implementation is based on algorithms, written in the frame of the diploma thesis by O. Motsak (advisor: Prof. S.A. Ovsienko, support: V. Levandovskyy), at Kyiv Taras Shevchenko University (Ukraine) with the title 'An algorithm for the computation of the center of noncommutative polynomial algebra'.
 
@@ -12 +12 @@
 
 PROCEDURES:
-        center(MaxDeg[,N]);             computes the generators of the center of a basering,
-        centralizer(f, MaxDeg[,N]);     computes the generators of the centralizer of f in a basering,
-        inCenter(l);                    checks the centrality of elements of list/ideal/poly l
-        inCentralizer(l, f);            checks the commutativity wrt polynomial f of polynomials of list/ideal/poly l
+        center(MaxDeg[,N]);             computes the generators of the center of a basering,
+        centralizer(f, MaxDeg[,N]);     computes the generators of the centralizer of f in a basering,
+        inCenter(l);                    checks the centrality of elements of list/ideal/poly l
+        inCentralizer(l, f);            checks the commutativity wrt polynomial f of polynomials of list/ideal/poly l
 
 KEYWORDS:  inCenter; inCentralizer; center; centralizer
 ";
 
-
 /******************************************************/
 // stuff
@@ -26 +25 @@
 /******************************************************/
 static proc myValue ( def s, list # )
-  " 
-        return s or (typeof(s))(#)
+"
+        return s or (typeof(s))(#)
 "
 {
@@ -34 +33 @@
     {
       if ( typeof( #[1] ) == typeof(s) )
-        {
-          @p = #[1];
-        };
+        {
+          @p = #[1];
+        };
     };
   return (@p);
@@ -44 +43 @@
 static proc myInt ( list # )
   "
-        return 0 or int(#)
+        return 0 or int(#)
 "
 {
@@ -54 +53 @@
 static proc myPoly ( list # )
   "
-        return 0 or poly(#)
+        return 0 or poly(#)
 "
 {
@@ -64 +63 @@
 static proc myRing ( list # )
   "
-        return basring or ring(#)
+        return basring or ring(#)
 "
 {
@@ -74 +73 @@
 static proc myString ( list # )
   "
-        return basring or ring(#)
+        return basring or ring(#)
 "
 {
@@ -84 +83 @@
 static proc myIdeal ( list # )
   "
-        return 0 or ideal(#)
+        return 0 or ideal(#)
 "
 {
@@ -107 +106 @@
       print (#);
     };
-};   
+};
 
 /******************************************************/
@@ -134 +133 @@
 static proc maxDeg( def z )
   "
-        returns: int : max of givendeg( z_i ), among all z_i \in z
-                returns -1 if z is empty or contain only 0 polynomial
-"
-{
-  int max = -1; 
+        returns: int : max of givendeg( z_i ), among all z_i \in z
+                returns -1 if z is empty or contain only 0 polynomial
+"
+{
+  int max = -1;
   int d;
 
@@ -144 +143 @@
     {
       d = deg(z[i]);
-      if( d > max ) 
-        {
-          max = d;
-        };
+      if( d > max )
+        {
+          max = d;
+        };
     };
 
@@ -159 +158 @@
 static proc myCoeff ( poly f, poly m )
   "
-        input: poly f,
-        return: coeff at m
+        input: poly f,
+        return: coeff at m
 "
 {
@@ -166 +165 @@
 
   int i = size(f);
-        
+
   while ( (i>0) and (leadmonom(f[i])<m) )
     {
@@ -173 +172 @@
   if( i == 0 )
     {
-      return ( 0 );         
+      return ( 0 );
     };
 
@@ -180 +179 @@
       return ( leadcoef(f[i]) );
     };
-        
+
   return ( 0 );
 };
@@ -194 +193 @@
       V[k] = var(k);
     };
-        
+
   return (V);
 };
@@ -207 +206 @@
 
   poly v, d; int i;
-        
+
   for ( int k = 2; k <= N; k++ )
     {
       v = V[k];
       for ( i = 1; i < k; i++ )
-        {
-          d = V[i];
-          M[k,i] =  v*d - d*v;  // [var(k),var(i)]
-          M[i,k] = -M[k,i];     // [var(i),var(k)] ==  -[var(k),var(i)]
-        };
+        {
+          d = V[i];
+          M[k,i] =  v*d - d*v;        // [var(k),var(i)]
+          M[i,k] = -M[k,i];        // [var(i),var(k)] ==  -[var(k),var(i)]
+        };
     };
 
@@ -233 +232 @@
   int i, j; poly a; poly d;
 
-  int N          = nvars( basering );
-  list V         = my_vars();
+  int N          = nvars( basering );
+  list V         = my_vars();
   matrix M = my_commutators();
 
@@ -240 +239 @@
 
   int cartan;
-        
+
   list RESULT = list();
   int  r_begin = 1;
   int  r_end   = N;
-        
+
 
   for ( int k = 1; k <= N; k++ )
@@ -251 +250 @@
       cartan = 1;
       for ( i = 1; i <= N; i++ )
-        {
-          d = M[k,i];
-          for ( j = 1; j <= N; j++ )
-            {
-              a = myCoeff( d, V[j] );   
-              A[i,j] =  a;
-
-              if( (i!=j) and (a!=0) )
-                {
-                  cartan = 0;
-                };                                      
-            };
-        };
+        {
+          d = M[k,i];
+          for ( j = 1; j <= N; j++ )
+            {
+              a = myCoeff( d, V[j] );
+              A[i,j] =  a;
+
+              if( (i!=j) and (a!=0) )
+                {
+                  cartan = 0;
+                };
+            };
+        };
 
       if ( cartan )
-        {       
-          RESULT[r_begin] = list( V[k], cartan, A );
-          r_begin++;
-        } else
-          {
-            RESULT[r_end] = list( V[k], cartan, A );
-            r_end--;            
-          };
-                                
-    };
-        
+        {
+          RESULT[r_begin] = list( V[k], cartan, A );
+          r_begin++;
+        } else
+          {
+            RESULT[r_end] = list( V[k], cartan, A );
+            r_end--;
+          };
+
+    };
+
   return (RESULT);
 
@@ -291 +290 @@
       kill ( @@@SORTEDVARARRAY );
     };
-  
+
   list @@@SORTEDVARARRAY;
   list V = my_associated();
-  
+
   // cartans - first then others...
-  
+
   for ( int i = 1; i<= size(V); i++ )
     {
       @@@SORTEDVARARRAY[i] = V[i][1];
     };
-  
+
   Print( "@@@SORTEDVARARRAY: " + string(@@@SORTEDVARARRAY) );
-    
-  export(@@@SORTEDVARARRAY);   
+
+  export(@@@SORTEDVARARRAY);
 };
 
@@ -321 +320 @@
   Print( "Error: my_var_init() was not called before this..." );
   return( var(@number) );
-    
+
 };
 
@@ -346 +345 @@
 "
 {
-  string s = "";        
-        
+  string s = "";
+
   while ( param != 0 )
     {
       s = string ( param % 2 ) + s;
       param = param / 2;
-      n --;     
+      n --;
     };
   while ( n > 0 )
@@ -375 +374 @@
       // setup redSB, redTail options
       export(@@@MY_QIDEAL);
-      
+
       option(redSB);
       option(redTail);
-      
+
     };
 };
@@ -397 +396 @@
     {
       /*
-        int param = 1 ; // by def: reduce both 1st and 2nd entries
-        param = myValue(param, #); 
-        string bits = myBitParam( param, 8 );
+        int param = 1 ; // by def: reduce both 1st and 2nd entries
+        param = myValue(param, #);
+        string bits = myBitParam( param, 8 );
       */
       BCall( "QNF_poly", p );
-      
+
       p = NF( p, @@@MY_QIDEAL );
-      
+
       ECall( "QNF_poly", p );
     }; // QRing
@@ -423 +422 @@
 +2    7 => reduce every 2nd entry
 
-        --- (for PBW in qrings) ---
+        --- (for PBW in qrings) ---
 
 +4    6 => kill out pbw entries where pbw monom (1) was affected
@@ -429 +428 @@
 //?? wofuer?
 +8    5 => reduce every 3rd entry
-    
+
 "
 {
@@ -437 +436 @@
 
       int param = 1 + 2; // by def: reduce both 1st and 2nd entries
-      param = myValue(param, #); 
-        
+      param = myValue(param, #);
+
       string bits = myBitParam( param, 8 );
 
@@ -444 +443 @@
 
       poly temp;
-        
+
       for ( int i = size(l); i>0 ; i -- )
-        {
-
-          if ( typeof( l[i] ) == "poly" )
-            {
-
-              if ( (bits[8] == "1") or (bits[6] == "1") )
-                {
-                  temp = NF( l[i], @@@MY_QIDEAL );
-                            
-                  if ( bits[6] == "1" ) 
-                    {// for PBW in qrings: kill out pbw entries where pbw monom was reduced
-                            
-                      if( temp != l[i] ) 
-                        {
-                          l = delete( l, i );
-                          i --;
-                          continue;
-                        };
-                    };
-                            
-                  if ( bits[8] == "1" ) 
-                    {
-                      l[i] = temp;
-                    };
-                };
-            };
-
-          if ( typeof( l[i] ) == "list" )
-            {   
-              // 1st 
-              
-              if ( size(l[i])>0 )
-                {               
-                  if ( (bits[8] == "1") or (bits[6] == "1") )
-                    {
-                      if( typeof( l[i][1] ) == "poly" )
-                        {
-                            
-                          temp = NF( l[i][1], @@@MY_QIDEAL );
-                            
-                          if ( bits[6] == "1" ) 
-                            {// for PBW in qrings: kill out pbw entries where pbw monom was reduced
-                                
-                              if( temp != l[i][1] ) 
-                                {
-                                  l = delete( l, i );
-                                  i --;
-                                  continue;
-                                };
-                            };
-                            
-                          if ( bits[8] == "1" ) 
-                            {
-                              l[i][1] = temp;
-                            };
-                            
-                        };
-                    };
-                };
-              
-              // 2nd
-                
-              if ( size(l[i])>1 )
-                {               
-                  if ( bits[7] == "1" )
-                    {
-                      if( typeof( l[i][2] ) == "poly" )
-                        {
-                          temp = NF( l[i][2], @@@MY_QIDEAL );
-                          
-                          l[i][2] = temp; 
-                        };
-                    };
-                };
-            };
-        };
-        
+        {
+
+          if ( typeof( l[i] ) == "poly" )
+            {
+
+              if ( (bits[8] == "1") or (bits[6] == "1") )
+                {
+                  temp = NF( l[i], @@@MY_QIDEAL );
+
+                  if ( bits[6] == "1" )
+                    {// for PBW in qrings: kill out pbw entries where pbw monom was reduced
+
+                      if( temp != l[i] )
+                        {
+                          l = delete( l, i );
+                          i --;
+                          continue;
+                        };
+                    };
+
+                  if ( bits[8] == "1" )
+                    {
+                      l[i] = temp;
+                    };
+                };
+            };
+
+          if ( typeof( l[i] ) == "list" )
+            {
+              // 1st
+
+              if ( size(l[i])>0 )
+                {
+                  if ( (bits[8] == "1") or (bits[6] == "1") )
+                    {
+                      if( typeof( l[i][1] ) == "poly" )
+                        {
+
+                          temp = NF( l[i][1], @@@MY_QIDEAL );
+
+                          if ( bits[6] == "1" )
+                            {// for PBW in qrings: kill out pbw entries where pbw monom was reduced
+
+                              if( temp != l[i][1] )
+                                {
+                                  l = delete( l, i );
+                                  i --;
+                                  continue;
+                                };
+                            };
+
+                          if ( bits[8] == "1" )
+                            {
+                              l[i][1] = temp;
+                            };
+
+                        };
+                    };
+                };
+
+              // 2nd
+
+              if ( size(l[i])>1 )
+                {
+                  if ( bits[7] == "1" )
+                    {
+                      if( typeof( l[i][2] ) == "poly" )
+                        {
+                          temp = NF( l[i][2], @@@MY_QIDEAL );
+
+                          l[i][2] = temp;
+                        };
+                    };
+                };
+            };
+        };
+
       ECall( "QNF_list", "list" );
-        
+
     }; // Qring
-    
+
   return ( l );
 };
@@ -545 +544 @@
 static proc uni_poly( poly p )
   "
-        returns polynomial with the same monomials but without coefficients.
-"
-{
-  poly @tt = poly(0);    
+        returns polynomial with the same monomials but without coefficients.
+"
+{
+  poly @tt = poly(0);
   for ( int @k = size(p); @k > 0; @k -- )
     {
       @tt = @tt + leadmonom(p[@k]);
-    };    
-  return (@tt); 
+    };
+  return (@tt);
 };
 
@@ -560 +559 @@
 {
   int @n = size( @t );
-  
+
   if ( @n == 0 )
     {
       return (@def);
     };
-    
+
   number @max = leadcoef(@t[1]);
   number @mm;
-  
-  if ( @n > 1) 
+
+  if ( @n > 1)
     {
       for ( int @i = 2; @i <= @n ;@i ++ )
-        {
-          @mm = leadcoef ( @t[@i] );
-          if ( @mm < 0 ) 
-            {
-              @mm = -@mm;
-            };
-          
-          if( @mm > @max ) 
-            {
-              @max = @mm;
-            };
-        };
-    };
-  
+        {
+          @mm = leadcoef ( @t[@i] );
+          if ( @mm < 0 )
+            {
+              @mm = -@mm;
+            };
+
+          if( @mm > @max )
+            {
+              @max = @mm;
+            };
+        };
+    };
+
   @max = @max + 1;
-  if ( @max == 0 ) 
+  if ( @max == 0 )
     {
       @max = @max + 1;
@@ -599 +598 @@
 {
   int @l, @k;
-  
+
   poly @t, @tt;
 
   @l = size (@given);
-  
+
   @t = poly(0);
   for ( @k = @l; @k > 0; @k -- )
     {
       if (@num == 1)
-        {
-          @tt = @given[@k];
-        } else
-          {
-            @tt = @given[@k][2];        
-          };
-      
+        {
+          @tt = @given[@k];
+        } else
+          {
+            @tt = @given[@k][2];
+          };
+
       @t = @t + uni_poly( @tt );
     };
-  
+
   return ( uni_poly(@t) );
 };
@@ -626 +625 @@
 static proc LM ( intvec exp )
   "
-        input : given exponent
-        return: monom with this exponent...
+        input : given exponent
+        return: monom with this exponent...
 "
 {
@@ -635 +634 @@
       @deg = exp[@i];
       if ( @deg > 0 )
-        {
-          @f = @f * (var(@i)^(@deg));
-        };
+        {
+          @f = @f * (var(@i)^(@deg));
+        };
     };
 
@@ -651 +650 @@
 static proc zSort ( list @z )
   "
-        Sort elements of a list of polynoms, 
-        and normalize
+        Sort elements of a list of polynoms,
+        and normalize
 "
 {
@@ -664 +663 @@
     {
       if ( @z[1] == 0 ) // if zero => empty list
-        {
-          return(list());
-        };          
+        {
+          return(list());
+        };
 
       @z[1] =  @z[1] * ( 1/leadcoef(@z[1]) ) ;
@@ -674 +673 @@
 
   int i = 1;
-        
+
   while ( i<=n )
     {
-      if (size( @z[i] ) != 0) 
-        {
-          break;
-        };
+      if (size( @z[i] ) != 0)
+        {
+          break;
+        };
       i++;
     };
-        
+
   if ( i > n )
     { // all zeroes
       return(list());
     };
-        
+
   ideal id = @z[i];
   i++;
-        
+
   while ( i<= n )
     {
       if( @z[i] != 0 )
-        {
-          id=@z[i],id;
-        };
+        {
+          id=@z[i],id;
+        };
       i++;
     };
@@ -711 +710 @@
       p = srt[1][i];
       if ( p == 0 )
-        {
-          i --;
-          continue;
-        };
-      p = p* (1/leadcoef(p));           // normalize
+        {
+          i --;
+          continue;
+        };
+      p = p* (1/leadcoef(p));                // normalize
       result = list(p) + result;
     };
 
-  //    "OUT SORT::";
-  //    result;
-        
+  //        "OUT SORT::";
+  //        result;
+
   return ( result );
 };
@@ -730 +729 @@
 static proc zRefine ( list @z )
   "
-        kill terms by leading monomials...
-        Note: based on myCoeff  
+        kill terms by leading monomials...
+        Note: based on myCoeff
 "
 {
@@ -746 +745 @@
   int flag = 1;
 
-  while ( flag == 1 ) 
+  while ( flag == 1 )
     {
       flag = 0;
@@ -752 +751 @@
       @z = zSort(@z); // sort out, < ...
 
-      if( size(@z) < 2 ) 
-        {
-          return (@z);
-        };
+      if( size(@z) < 2 )
+        {
+          return (@z);
+        };
 
       for ( @i = size(@z); @i > 0; @i -- ) // at 1st the biggest ... then smallest...
-        {
-
-          @ff    = @z[@i];
-
-          if( size(@ff) == 0 )
-            {
-              @z = delete ( @z , @i );
-              @i --;
-              continue;
-            };
-
-          @ff    = @ff*(1/leadcoef(@ff));
-          @z[@i] = @ff;
-          @f    = leadmonom(@ff);
-
-          for ( @j = (@i-1); (@j>0); @j --  )
-            {
-              @gg = @z[@j];
-              @ng = myCoeff(@gg, @f); // leads?
-              if( @ng!=0 )
-                {
-                  @z[@j] = @gg - @ng * @ff; 
-                  flag = 1;
-                };              
-            };
-          for ( @j = (@i+1); (@j<=size(@z)); @j ++ )
-            {
-              @gg = @z[@j];
-              @ng = myCoeff(@gg, @f); 
-              if( @ng!=0 )
-                {
-                  @z[@j] = @gg - @ng * @ff; 
-                  flag = 1;
-                };              
-            };
-
-        };
+        {
+
+          @ff    = @z[@i];
+
+          if( size(@ff) == 0 )
+            {
+              @z = delete ( @z , @i );
+              @i --;
+              continue;
+            };
+
+          @ff    = @ff*(1/leadcoef(@ff));
+          @z[@i] = @ff;
+          @f         = leadmonom(@ff);
+
+          for ( @j = (@i-1); (@j>0); @j --  )
+            {
+              @gg = @z[@j];
+              @ng = myCoeff(@gg, @f); // leads?
+              if( @ng!=0 )
+                {
+                  @z[@j] = @gg - @ng * @ff;
+                  flag = 1;
+                };
+            };
+          for ( @j = (@i+1); (@j<=size(@z)); @j ++ )
+            {
+              @gg = @z[@j];
+              @ng = myCoeff(@gg, @f);
+              if( @ng!=0 )
+                {
+                  @z[@j] = @gg - @ng * @ff;
+                  flag = 1;
+                };
+            };
+
+        };
     };
 
   ECall("zRefine", "list");
 
-  return        ( @z );
-
-};
-
-
-/******************************************************/
-// procedures for building "bad leadmonomials" set 
+  return         ( @z );
+
+};
+
+
+/******************************************************/
+// procedures for building "bad leadmonomials" set
 
 
@@ -811 +810 @@
 static proc checkPolyUniq( list l, poly p )
   "
-        check whether p sits already in l, assume l to be size-sorted <
-        return: -1 if present
-                 1 if we need to add
+        check whether p sits already in l, assume l to be size-sorted <
+        return: -1 if present
+                 1 if we need to add
 "
 {
@@ -821 +820 @@
 
   int s = size(p);
-        
+
   while( i<= n )
-    { 
+    {
       if ( size(l[i]) >= s )
-        {
-          break;
-        };
-            
-      i ++; 
+        {
+          break;
+        };
+
+      i ++;
     };
 
   // now: size(l[i]) >= s
   while( i<= n )
-    { 
+    {
       if ( size(l[i]) == s )
-        {
-          break;
-                
-        };
-      if ( l[i] == p ) 
-        {
-          ECall( "checkPolyUniq", -1 );
-          return (-1);
-        };
-      i ++; 
+        {
+          break;
+
+        };
+      if ( l[i] == p )
+        {
+          ECall( "checkPolyUniq", -1 );
+          return (-1);
+        };
+      i ++;
     };
 
@@ -856 +855 @@
 static proc addPolyUniq( list l, poly p )
   "
-        add p into l uniquely, and keep l size-sorted <
+        add p into l uniquely, and keep l size-sorted <
 "
 {
   BCall( "addPolyUniq", " { " + string(l) + " }, " + string(p) );
-        
+
   int n = size(l);
 
@@ -866 +865 @@
     {
       l = list(p);
-                
+
       ECall( "addPolyUniq", l );
-                
+
       return (l);
     };
 
   int s = size(p);
-        
+
   int i = 1;
   while( i<= n )
     {
       if( size(l[i]) > s )
-        {
-          l = insert( l, p, i-1 ) ;
-          break;
-        };
-                
+        {
+          l = insert( l, p, i-1 ) ;
+          break;
+        };
+
       if( size(l[i]) == s )
-        {
-          if ( l[i] == p )
-            {
-              break;
-            };
-        };
-                
+        {
+          if ( l[i] == p )
+            {
+              break;
+            };
+        };
+
       i++;
     };
-        
+
   if( i > n )
     {
       l = l + list(p);
     };
-        
+
   ECall( "addPolyUniq", l );
   return(l);
@@ -907 +906 @@
 static proc mergePolysUniq( list a, list b )
   "
-        merge lists uniq
+        merge lists uniq
 "
 {
   BCall( "mergePolysUniq", "{ " + string(a) + " }, { " + string(b) + "} " );
-        
+
   for( int i = 1; i <= size(b); i ++ )
     {
       a = addPolyUniq(a, b[i]);
     };
-        
+
   ECall( "mergePolysUniq", a );
-        
+
   return (a);
 };
@@ -926 +925 @@
 static proc sortPolysUniq( list a )
   "
-        sort list uniq
+        sort list uniq
 "
 {
   BCall( "sortPolysUniq", a );
-        
+
   if( size(a) < 2 )
     {
@@ -936 +935 @@
       return(a);
     };
-        
+
   list b = list(a[1]);
-        
+
   for( int i = 2; i <= size(a); i ++ )
     {
       b = addPolyUniq(b, a[i]);
     };
-        
+
   ECall( "sortPolysUniq", b );
-        
+
   return (b);
 };
 
 /******************************************************/
-static proc addRecordUniq ( list leadD, list newD, intvec texp, poly tm, int kind, list prs ) 
-  "
-        if kind = 0 => for PBW - no products
-        if kind = 1 => with products
+static proc addRecordUniq ( list leadD, list newD, intvec texp, poly tm, int kind, list prs )
+  "
+        if kind = 0 => for PBW - no products
+        if kind = 1 => with products
 "
 {
@@ -962 +961 @@
 
   prs = sortPolysUniq(prs);
-        
+
   // trick:
   //  check for presens of a monomial @tm in current index poly of @leads (=> in list @leads)
   //  if char = 0 then new_size > (if not present) or =  (if already present)
-  //  if char > 0 then new_size > (if not present) or =< (if already present) 
+  //  if char > 0 then new_size > (if not present) or =< (if already present)
   // !!!!!
-  if( size(tm + leadD[2]) > size(leadD[2]) ) 
+  if( size(tm + leadD[2]) > size(leadD[2]) )
     {
       f_add = 1;
     } else
       {
-        if ( kind != 0 )
-          {
-            for ( i = 1; i<= size(leadD[1]); i++ )
-              {
-                if ( leadD[1][i][2] == tm )
-                  {
-                    for ( i = size(prs); i>0; i-- )
-                      {
-                        f_add = checkPolyUniq( leadD[1][i][3], prs[i] );
-                        if( f_add == -1 )
-                          {
-                            prs = delete(prs, i);
-                          };
-                      };
-
-                    break;
-                  };
-              };                        
-          };
+        if ( kind != 0 )
+          {
+            for ( i = 1; i<= size(leadD[1]); i++ )
+              {
+                if ( leadD[1][i][2] == tm )
+                  {
+                    for ( i = size(prs); i>0; i-- )
+                      {
+                        f_add = checkPolyUniq( leadD[1][i][3], prs[i] );
+                        if( f_add == -1 )
+                          {
+                            prs = delete(prs, i);
+                          };
+                      };
+
+                    break;
+                  };
+              };
+          };
       };
 
@@ -999 +998 @@
       list newlist ;
       if ( kind != 0 )
-        {
-          newlist =  list ( list ( texp, tm, prs ) );
-        } else
-          {
-            newlist =  list ( list ( texp, tm ) );
-          };
+        {
+          newlist =  list ( list ( texp, tm, prs ) );
+        } else
+          {
+            newlist =  list ( list ( texp, tm ) );
+          };
 
 
       if ( size(newD[1]) == 0 )
-        {
-          newD[1] =  newlist; 
-          newD[2] =  tm;
-        } else
-          {
-
-            if( size(tm + newD[2]) > size(newD[2]) )
-              {
-                newD[1] = newD[1] + newlist;
-                newD[2] = newD[2] + tm;
-              } else
-                {
-                  if ( kind != 0 )
-                    {
-                      for ( i = 1; i<= size(newD[1]); i++ )
-                        {
-                          if ( newD[1][i][2] == tm )
-                            {
-                              newD[1][i][3] = mergePolysUniq( newD[1][i][3], prs );
-                              break;
-                            };
-                        };
-                    };
-                };
-          };
+        {
+          newD[1] =  newlist;
+          newD[2] =  tm;
+        } else
+          {
+
+            if( size(tm + newD[2]) > size(newD[2]) )
+              {
+                newD[1] = newD[1] + newlist;
+                newD[2] = newD[2] + tm;
+              } else
+                {
+                  if ( kind != 0 )
+                    {
+                      for ( i = 1; i<= size(newD[1]); i++ )
+                        {
+                          if ( newD[1][i][2] == tm )
+                            {
+                              newD[1][i][3] = mergePolysUniq( newD[1][i][3], prs );
+                              break;
+                            };
+                        };
+                    };
+                };
+          };
     };
 
@@ -1044 +1043 @@
 {
   BCall ("mergeRecordsUniq", "{old leads}, {new leads}, " + string(kind) );
-        
+
   if(  size(new[1]) > 0 )
     {
       if ( size (old[1]) == 0 )
-        {
-          old = new;
-        } else
-          {
-            if ( kind != 0 )
-              { 
-                int io;
-                for ( int in = 1; in <= size( new[1] ); in ++ )
-                  {
-                    if( size( new[1][in][2] + old[2] ) > size( old[2] ) )
-                      {
-                        old[1] = old[1] + list(new[1][in]);
-                        old[2] = old[2] + new[1][in][2];
-                      } else
-                        {
-                          for( io = 1; io <= size( old[1] ); io ++ )
-                            {
-                              if( old[1][io][2] == new[1][in][2] )
-                                {
-                                  old[1][io][3] = mergePolysUniq( old[1][io][3], new[1][in][3] );
-                                  break;
-                                };
-                            };                                          
-                        };
-                  };
-              } else
-                {
-                  old[1] = old[1] + new[1];
-                  old[2] = old[2] + new[2];
-                };
-          };
+        {
+          old = new;
+        } else
+          {
+            if ( kind != 0 )
+              {
+                int io;
+                for ( int in = 1; in <= size( new[1] ); in ++ )
+                  {
+                    if( size( new[1][in][2] + old[2] ) > size( old[2] ) )
+                      {
+                        old[1] = old[1] + list(new[1][in]);
+                        old[2] = old[2] + new[1][in][2];
+                      } else
+                        {
+                          for( io = 1; io <= size( old[1] ); io ++ )
+                            {
+                              if( old[1][io][2] == new[1][in][2] )
+                                {
+                                  old[1][io][3] = mergePolysUniq( old[1][io][3], new[1][in][3] );
+                                  break;
+                                };
+                            };
+                        };
+                  };
+              } else
+                {
+                  old[1] = old[1] + new[1];
+                  old[2] = old[2] + new[2];
+                };
+          };
     };
 
@@ -1096 +1095 @@
   for( int @i = 0; @i <= @deg; @i ++ )
     {
-      @l[index(@i)]     = list( list() , 0);
-      // new items: 
-      // { 
-      //        list of leads,    - empty list
-      //        sum poly "index", - poly(0)
+      @l[index(@i)]         = list( list() , 0);
+      // new items:
+      // {
+      //        list of leads,    - empty list
+      //        sum poly "index", - poly(0)
       // }
     };
@@ -1109 +1108 @@
 static proc zAddBad ( list @leads, list @newz, int @maxDeg, int kind )
   "
-        input: 
-                @leads: graded by deg list of 
-                        rec:
-                        { 
-                                [1] - list of 
-                                        rec:
-                                        { 
-                                                [1] - leadexp. 
-                                                [2] - leadmonom([1])
-                                        if kind != 0 (for zReduce) =>
-                                                [3] - !list! of all possible products which give this leadexp
-                                        }, 
-                                [2] - summ of all in [1] ('index' poly)
-                        }
-                @newz: new elements for adding to @leads
-                @maxDeg: maximal degree
-        
-                if kind != 0 => keeps also list of all possible products which give leadexp of a record
-
-        return:
-                updated @leads list
+        input:
+                @leads: graded by deg list of
+                        rec:
+                        {
+                                [1] - list of
+                                        rec:
+                                        {
+                                                [1] - leadexp.
+                                                [2] - leadmonom([1])
+                                        if kind != 0 (for zReduce) =>
+                                                [3] - !list! of all possible products which give this leadexp
+                                        },
+                                [2] - summ of all in [1] ('index' poly)
+                        }
+                @newz: new elements for adding to @leads
+                @maxDeg: maximal degree
+
+                if kind != 0 => keeps also list of all possible products which give leadexp of a record
+
+        return:
+                updated @leads list
 
 "
@@ -1136 +1135 @@
 
   int @newSize = size(@newz);
-  if ( @newSize < 1 ) 
+  if ( @newSize < 1 )
     {
       return (@leads);
@@ -1144 +1143 @@
 
 
-  poly  @m, @tm, @ttm;
+  poly         @m, @tm, @ttm;
   intvec @exp, @texp, @ttexp;
 
@@ -1151 +1150 @@
 
   poly @sum_old, @sum_new;
-        
+
   poly a, b, @temp;
 
@@ -1162 +1161 @@
 
   for ( @i = @newSize; @i > 0; @i -- )
-    {// for every new poly (@newz[@i]) do 
-
-      @m   = leadmonom( @newz[@i] ); 
+    {// for every new poly (@newz[@i]) do
+
+      @m   = leadmonom( @newz[@i] );
       @deg = deg(@m);
       @exp = leadexp(@m);
@@ -1172 +1171 @@
 
       for( @mydeg = @deg; @mydeg <= @maxDeg;  @mydeg = @mydeg + @deg )
-        {// adding all possiblities for @newz[@i]^@j;
-
-          if ( @mydeg > @deg ) 
-            {
-              @texp     = @texp + @exp;
-              @tm       = LM ( @texp );
-              if ( kind != 0)
-                {
-                  pr = QNF_poly( pr * @newz[@i] ); // degrees must be there!!!
-                };
-            } else
-              {
-                @texp   = @exp;
-                @tm     = @m;
-                if ( kind != 0)
-                  {
-                    pr = @newz[@i];
-                  };
-              };
-
-          @temp =  QNF_poly(@tm);
-          if( @temp != @tm )
-            {
-              break;
-            };
-
-          /*!!*/                        @newzz[index(@mydeg)] = 
-                                          /*!!*/        addRecordUniq( @leads[index(@mydeg)], @newzz[index(@mydeg)], @texp, @tm, kind, list(pr) );
-
-          for ( @dd = 1; (@dd <= @maxDeg) and ((@dd + @mydeg) <= @maxDeg ); @dd ++ )
-            { // for every good "deg" 
-                                
-              @newdeg = @dd + @mydeg; // any deg should be additive!!!
-                                
-              for ( @k = size(@leads[index(@dd)][1]); @k > 0; @k -- )
-                {
-
-                  @ttexp        = (@leads[index(@dd)][1][@k][1]) + @texp;
-                  @ttm  = LM (@ttexp);
-                                        
-                  if ( kind != 0 )
-                    {
-                      prs = list();
-
-                      for( pri = 1; pri <= size(@leads[index(@dd)][1][@k][3]); pri++)
-                        {
-                          // to do products into list and add one list !!!
-                          a = QNF_poly( pr*@leads[index(@dd)][1][@k][3][pri]);
-                          b = QNF_poly( @leads[index(@dd)][1][@k][3][pri]*pr);
-
-                          prs= prs + list(a);
-
-                          if ( a!=b )
-                            {
-                              prs= prs + list(b);
-                            };
-                        };
-
-                    } else
-                      {
-                        prs = list(pr);
-                      };
-
-                  @temp =  QNF_poly(@ttm);
-                  if( @temp == @ttm )
-                    {
-
-                      /*!!*/                                            @newzz[index(@newdeg)] = 
-                                                                          /*!!*/        addRecordUniq( @leads[index(@newdeg)], @newzz[index(@newdeg)], @ttexp, @ttm, kind, prs );
-                    };
-
-
-                };                              
-            }; // for
-
-          if ( @deg == 0 ) 
-            {
-              break;
-            };
-        };
+        {// adding all possiblities for @newz[@i]^@j;
+
+          if ( @mydeg > @deg )
+            {
+              @texp         = @texp + @exp;
+              @tm         = LM ( @texp );
+              if ( kind != 0)
+                {
+                  pr = QNF_poly( pr * @newz[@i] ); // degrees must be there!!!
+                };
+            } else
+              {
+                @texp         = @exp;
+                @tm         = @m;
+                if ( kind != 0)
+                  {
+                    pr = @newz[@i];
+                  };
+              };
+
+          @temp =  QNF_poly(@tm);
+          if( @temp != @tm )
+            {
+              break;
+            };
+
+          /*!!*/                        @newzz[index(@mydeg)] =
+                                          /*!!*/        addRecordUniq( @leads[index(@mydeg)], @newzz[index(@mydeg)], @texp, @tm, kind, list(pr) );
+
+          for ( @dd = 1; (@dd <= @maxDeg) and ((@dd + @mydeg) <= @maxDeg ); @dd ++ )
+            { // for every good "deg"
+
+              @newdeg = @dd + @mydeg; // any deg should be additive!!!
+
+              for ( @k = size(@leads[index(@dd)][1]); @k > 0; @k -- )
+                {
+
+                  @ttexp         = (@leads[index(@dd)][1][@k][1]) + @texp;
+                  @ttm         = LM (@ttexp);
+
+                  if ( kind != 0 )
+                    {
+                      prs = list();
+
+                      for( pri = 1; pri <= size(@leads[index(@dd)][1][@k][3]); pri++)
+                        {
+                          // to do products into list and add one list !!!
+                          a = QNF_poly( pr*@leads[index(@dd)][1][@k][3][pri]);
+                          b = QNF_poly( @leads[index(@dd)][1][@k][3][pri]*pr);
+
+                          prs= prs + list(a);
+
+                          if ( a!=b )
+                            {
+                              prs= prs + list(b);
+                            };
+                        };
+
+                    } else
+                      {
+                        prs = list(pr);
+                      };
+
+                  @temp =  QNF_poly(@ttm);
+                  if( @temp == @ttm )
+                    {
+
+                      /*!!*/                                                @newzz[index(@newdeg)] =
+                                                                          /*!!*/        addRecordUniq( @leads[index(@newdeg)], @newzz[index(@newdeg)], @ttexp, @ttm, kind, prs );
+                    };
+
+
+                };
+            }; // for
+
+          if ( @deg == 0 )
+            {
+              break;
+            };
+        };
 
       for ( @mydeg = 0; @mydeg <= @maxDeg; @mydeg ++ )
-        { // adding currently generated to result
-          @leads[index(@mydeg)] = mergeRecordsUniq ( @leads[index(@mydeg)], @newzz[index(@mydeg)], kind );
-        };
+        { // adding currently generated to result
+          @leads[index(@mydeg)] = mergeRecordsUniq ( @leads[index(@mydeg)], @newzz[index(@mydeg)], kind );
+        };
 
     };
@@ -1272 +1271 @@
 static proc zReducePoly ( list leads, poly new, poly anfang )
   "
-        reduce poly new wrt found leads,
-        return: list of all possible reductions... 
+        reduce poly new wrt found leads,
+        return: list of all possible reductions...
 "
 {
@@ -1284 +1283 @@
   list LEADS;
 
-  int i, n; 
+  int i, n;
   list prs;
 
@@ -1295 +1294 @@
 
       if( size(LEADS[2] + lm ) <=  size(LEADS[2]) )
-        { // need to reduce, since leacmonom already in LEADS
-                    
-          for ( i = 1; i <= size(LEADS[1]); i++ )
-            {
-              if( LEADS[1][i][2] == lm )
-                {
-                                
-                  lc = leadcoef( temp ); // no need be the unit
-
-                  prs = LEADS[1][i][3]; // shouldbe generated by zAddBad with kind == 1
-                  n = size(prs) ;
-
-                  if ( n == 1 )
-                    { // no recursion
-
-                      temp = leadcoef(prs[1]) * temp - lc * prs[1]; // leadmonom goes down
-
-                    } else 
-                      { // do recursion
-
-                        list result = list();
-                        poly newnew;
-                        int f_addrest = 0;
-                                                
-                        for( int pri = 1; pri <= n ; pri ++ )
-                          {     
-                            newnew = leadcoef(prs[pri]) * temp - lc * prs[pri]; // leadmonom goes down
-                                                        
-                            if( size( newnew ) > 0 )
-                              {
-                                result = result + zReducePoly(leads, newnew, rest);
-                              } else
-                                {
-                                  f_addrest = 1;
-                                };
-                          };
-
-                        if ( f_addrest == 1 )
-                          {
-                            result = result + list(rest);
-                          };
-                        return ( result );
-
-                      };
-                  break;
-                };
-            };
-
-        } else
-          { // no such leadmonom in leads
-        
-            rest = rest + lead ( temp );
-            temp = temp - lead ( temp ); // leadcoeff goes down
-          };
+        { // need to reduce, since leacmonom already in LEADS
+
+          for ( i = 1; i <= size(LEADS[1]); i++ )
+            {
+              if( LEADS[1][i][2] == lm )
+                {
+
+                  lc = leadcoef( temp ); // no need be the unit
+
+                  prs = LEADS[1][i][3]; // shouldbe generated by zAddBad with kind == 1
+                  n = size(prs) ;
+
+                  if ( n == 1 )
+                    { // no recursion
+
+                      temp = leadcoef(prs[1]) * temp - lc * prs[1]; // leadmonom goes down
+
+                    } else
+                      { // do recursion
+
+                        list result = list();
+                        poly newnew;
+                        int f_addrest = 0;
+
+                        for( int pri = 1; pri <= n ; pri ++ )
+                          {
+                            newnew = leadcoef(prs[pri]) * temp - lc * prs[pri]; // leadmonom goes down
+
+                            if( size( newnew ) > 0 )
+                              {
+                                result = result + zReducePoly(leads, newnew, rest);
+                              } else
+                                {
+                                  f_addrest = 1;
+                                };
+                          };
+
+                        if ( f_addrest == 1 )
+                          {
+                            result = result + list(rest);
+                          };
+                        return ( result );
+
+                      };
+                  break;
+                };
+            };
+
+        } else
+          { // no such leadmonom in leads
+
+            rest = rest + lead ( temp );
+            temp = temp - lead ( temp ); // leadcoeff goes down
+          };
     };
 
@@ -1359 +1358 @@
 static proc zCancel ( list @tt, list @leads )
   "
-        just kill entries of plane PBW base with leading monomials in @leads...
+        just kill entries of plane PBW base with leading monomials in @leads...
 "
 {
@@ -1372 +1371 @@
   poly g, f;
 
-  for ( @i = size(@tt); @i > 0 ; @i -- ) 
+  for ( @i = size(@tt); @i > 0 ; @i -- )
     // for all PBW entries:
     {
@@ -1379 +1378 @@
 
       if ( size(f + g) > size(f) ) // if g not in @leads (works only for monomials)
-        {
-          result = list( @tt[@i] ) + result;
-        };
+        {
+          result = list( @tt[@i] ) + result;
+        };
     };
 
@@ -1394 +1393 @@
 static proc zReduce( list @z )
   "
-        reduce a set @z - base of Center as V.S.
-        into a minimal set!!
+        reduce a set @z - base of Center as V.S.
+        into a minimal set!!
 "
 {
   BCall( "zReduce", @z );
-        
+
   @z = zRefine ( @z );
   int n = size( @z );
@@ -1408 +1407 @@
     };
 
-  int d = maxDeg( @z ); 
+  int d = maxDeg( @z );
 
   if( d== -1 )
@@ -1424 +1423 @@
 
   poly p;
-        
+
   for ( int i = 1; i <= n ; i++ )
     {// in this order... from least to maximal...
@@ -1433 +1432 @@
 
       f_add = 1;
-                
+
       for( j = 1; j <= size(@red); j++ )
-        {
-          if ( @red[j] == 0 )
-            {
-              f_add = 0; 
-              break; // nothing new....
-            };
-        };
-      
+        {
+          if ( @red[j] == 0 )
+            {
+              f_add = 0;
+              break; // nothing new....
+            };
+        };
+
       @red = zRefine( @red ); // there will be no zeroes after ???
 
       if( size(@red) > 0 )
-        {                   
-          leads = zAddBad( leads, @red, d, 1); 
-        };
-      
+        {
+          leads = zAddBad( leads, @red, d, 1);
+        };
+
       if ( f_add == 1 )
-        {
-          // we got something new....
-          result = result + list(@red); // ??? which one to add? => trying to add all 
-        };
-    };
-        
+        {
+          // we got something new....
+          result = result + list(@red); // ??? which one to add? => trying to add all
+        };
+    };
+
   ECall( "zReduce", result );
-        
+
   return (result);
 };
@@ -1476 +1475 @@
 PBW[ index(0) ] = PBW part of degree 0:
 record:
-        [1] : 1         // var(0) ;-)   
-        [2] : 0
-        [3] : 1
+        [1] : 1                // var(0) ;-)
+        [2] : 0
+        [3] : 1
 "
 {
   BCall( "PBW_init" );
-  return (list(list(1, 0, 1))); 
+  return (list(list(1, 0, 1)));
 };
 
@@ -1489 +1488 @@
 static proc PBW_sys(list VARS, poly p)
   "
-        calculate the array [1..NVARS] of records: 
-record[i] = 
-                [1] = var(i)            // i^{th} variable
-                [2] = p*[1]-[1]*p       // [ p, var(i) ]
-                [3] = deg(var(i))       // i^{th} variable's deg
-        
-        ?? need debug ??
+        calculate the array [1..NVARS] of records:
+record[i] =
+                [1] = var(i)                 // i^{th} variable
+                [2] = p*[1]-[1]*p         // [ p, var(i) ]
+                [3] = deg(var(i))         // i^{th} variable's deg
+
+        ?? need debug ??
 "
 {
@@ -1501 +1500 @@
   BCall( "PBW_sys" );
 
-  poly t; 
+  poly t;
   for (int v = size(VARS); v>0; v -- )
     {
-      t         = VARS[v];
+      t            = VARS[v];
       VARS[v] = list( t, QNF_poly( p*t - t*p ), deg(t) ) ;
     };
-                
+
   return (VARS);
 };
@@ -1514 +1513 @@
 static proc PBW_done( list PBW )
   "
-        collects all together, from graded lists into plane list.       
-        
-        Note: also the last vars... 
+        collects all together, from graded lists into plane list.
+
+        Note: also the last vars...
 "
 {
@@ -1541 +1540 @@
   list result = list(); // PBW[ index(k) ] ought to be empty ??
   int N = size(sys);
-        
+
   for ( int i = 1; i <= N; i ++ ) // for all vars
     {
       kk = (k - sys[i][3]);   // any deg should be additive function wrt multiplication
       if ( kk >= 0 )
-        {
-          nn = size( PBW[ index(kk) ] );
-          for ( ii = 1; ii <= nn; ii ++ )
-            {
-              temp = PBW[ index(kk) ][ii];
-
-              if ( temp[3] <= i ) 
-                {
-                  temp[2] = temp[2]*sys[i][1] + temp[1]*sys[i][2]; // recursive [,]
-                  temp[1] = temp[1]*sys[i][1];
-                  temp[3] = i;
-                                        
-                  result = result + list ( temp );
-                };
-            };
-        };
+        {
+          nn = size( PBW[ index(kk) ] );
+          for ( ii = 1; ii <= nn; ii ++ )
+            {
+              temp = PBW[ index(kk) ][ii];
+
+              if ( temp[3] <= i )
+                {
+                  temp[2] = temp[2]*sys[i][1] + temp[1]*sys[i][2]; // recursive [,]
+                  temp[1] = temp[1]*sys[i][1];
+                  temp[3] = i;
+
+                  result = result + list ( temp );
+                };
+            };
+        };
     };
 
@@ -1567 +1566 @@
   ECall( "PBW_next", "list result" );
   return (result);
-        
+
 };
 
@@ -1579 +1578 @@
 
   PBW[index(0)] = PBW_init();
-        
+
   for (int k = 1; k <= MaxDeg; k ++ )
-    {           
+    {
       PBW[index(k)] = PBW_next( PBW, k, SYS );
     };
 
   return (PBW_done( PBW ));
-}; 
+};
 
 
@@ -1593 +1592 @@
 
 /******************************************************/
-static proc FSS (list @given, poly @BASE_POLY) 
+static proc FSS (list @given, poly @BASE_POLY)
 "
     Gauss with computation of kernel v.s basis
@@ -1603 +1602 @@
   list @nums = list ();
   intvec @ones;
-  int @j, @k, 
+  int @j, @k,
     @n, @v,
     @a, @nn;
-    
+
   @n = size( @BASE_POLY );
   @v = size( @given );
-    
+
   if ( (@v == 0) or (@n == 0) )
-    {    
+    {
       return (@given);
     };
@@ -1637 +1636 @@
       @w = leadexp(@BASE_POLY[@a]);
       for( @k = @v; @k > 0; @k -- )
-        {
-          if( @w == LM[@k][1] )
-            {
-              @t = LM[@k][2];
-              MD[@a, @k] = leadcoef( @t );
-              @t = @t - lead ( @t );
-              LM[@k][2]  = @t;
-
-              LM[@k][1]  = leadexp(@t);
-            };
-        };
+        {
+          if( @w == LM[@k][1] )
+            {
+              @t = LM[@k][2];
+              MD[@a, @k] = leadcoef( @t );
+              @t = @t - lead ( @t );
+              LM[@k][2]  = @t;
+
+              LM[@k][1]  = leadexp(@t);
+            };
+        };
 
     };
@@ -1656 +1655 @@
   number @div;
   //    @nums = list();
-    
+
   // Gauss
 //  print("Before Gauss, Matrix: ");
 //  print( MD );
 
-    
+
   @x = 1;
   @y = 1;
@@ -1668 +1667 @@
     {
       @min =  leadcoef( MD[@y, @x] ); // curr diag.
-        
-      if ( @min == 0 ) 
-        // if zero on diag...
-        {
-          @j = 0;
-                
-          // let's find the minimal
-          for ( @k = @y+1; @k <= @n; @k ++ )
-            {
-              @max = leadcoef( MD[ @k, @x ] );
-              if ( @max != 0 )
-                {
-                  @j = @k;                      
-                  @min = @max;
-                  //                @k ++;
-                  break; // this pure for
-                  // continue; 
-                  // for find min
-                };
-            }; // for (@k) // found minimal
-                
-          if ( @j == 0 ) 
-            {       
-              // das ist gut! //                
-              @nums = @nums + list ( list ( @x, @y ) );
-              @x ++;
-              continue; // while
-            } ;
-            
-          for ( @k = @x ; @k <= @v ; @k ++ )
-            {
-              @t =  MD[ @j, @k ];
-              MD[ @j, @k ] = MD[ @y, @k ];
-              MD[ @y, @k ] = @t;
-            };
-                
-        }; // if diag === zero.
+
+      if ( @min == 0 )
+        // if zero on diag...
+        {
+          @j = 0;
+
+          // let's find the minimal
+          for ( @k = @y+1; @k <= @n; @k ++ )
+            {
+              @max = leadcoef( MD[ @k, @x ] );
+              if ( @max != 0 )
+                {
+                  @j = @k;
+                  @min = @max;
+                  //                    @k ++;
+                  break; // this pure for
+                  // continue;
+                  // for find min
+                };
+            }; // for (@k) // found minimal
+
+          if ( @j == 0 )
+            {
+              // das ist gut! //
+              @nums = @nums + list ( list ( @x, @y ) );
+              @x ++;
+              continue; // while
+            } ;
+
+          for ( @k = @x ; @k <= @v ; @k ++ )
+            {
+              @t =  MD[ @j, @k ];
+              MD[ @j, @k ] = MD[ @y, @k ];
+              MD[ @y, @k ] = @t;
+            };
+
+        }; // if diag === zero.
       @ones[@y] = @x;
-            
-      if ( @min == 0 ) 
-        {
-          //        write_latex_str ( " ******************* ERROR ******************* " );
-          quit;
-        };
-            
-            
+
+      if ( @min == 0 )
+        {
+          //            write_latex_str ( " ******************* ERROR ******************* " );
+          quit;
+        };
+
+
       if ( @min != 1) // let's norm the row... to make the '1' !
-        {
-          @min = 1 / @min;
-          for ( @k = @x; @k <= @v; @k++ )
-            {
-              @max = leadcoef( MD[@y, @k] );
-                    
-              if ( @max == 0)
-                {
-                  @k ++ ;
-                  continue; // for : norming the row...
-                };
-                    
-              MD[@y, @k] = @max * @min;  // here must be Field ...
-            };
-                
-          //        @min = 1;
-                
-        };
-            
+        {
+          @min = 1 / @min;
+          for ( @k = @x; @k <= @v; @k++ )
+            {
+              @max = leadcoef( MD[@y, @k] );
+
+              if ( @max == 0)
+                {
+                  @k ++ ;
+                  continue; // for : norming the row...
+                };
+
+              MD[@y, @k] = @max * @min;  // here must be Field ...
+            };
+
+          //            @min = 1;
+
+        };
+
       // here must be @min != 0;
       for ( @k = 1; @k <= @n; @k++ )
-        {
-          @max = leadcoef( MD[@k, @x] );
-                
-          if ( ( @k == @y) || (@max == 0) )
-            {
-              @k ++ ;
-              continue; 
-            };
-                
-          for ( @j = @x; @j <= @v ; @j ++ )
-            {
-              MD[ @k, @j ] = MD[ @k, @j ] - @max * MD[ @y, @j ];
-            };              
-          
-        }; //killing
-            
+        {
+          @max = leadcoef( MD[@k, @x] );
+
+          if ( ( @k == @y) || (@max == 0) )
+            {
+              @k ++ ;
+              continue;
+            };
+
+          for ( @j = @x; @j <= @v ; @j ++ )
+            {
+              MD[ @k, @j ] = MD[ @k, @j ] - @max * MD[ @y, @j ];
+            };
+
+        }; //killing
+
       @x ++;
       @y ++;
     }; //main while.
   /******************************************************/
-    
+
 //  print("Gaussed Matrix: ");
 //  print( MD );
@@ -1762 +1761 @@
   // computation of kernel's basis
 
-  if ( @x <= @v ) 
+  if ( @x <= @v )
     {
       for ( @k = @x; @k <= @v ; @k ++ )
-        {
-          @nums = @nums + list ( list ( @k, @n+1 ) );   
-        }
+        {
+          @nums = @nums + list ( list ( @k, @n+1 ) );
+        }
     }
-    
+
 //  print("Nums: " );
 //  print (@nums);
-    
+
   list result = list();
-    
+
   // real calculations of the Base of a Ker as V.S.
 
   for ( @k = 1; @k <= size(@nums) ; @k ++ )
     {
-      @x = @nums[@k][1]; 
-      @j  = @nums[@k][2]; 
-            
+      @x = @nums[@k][1];
+      @j  = @nums[@k][2];
+
       @t = @given[@x][1];
-            
+
       for ( @y = 1; @y < @j ; @y ++ )
-        // for every "@x" column
-        {
-          @max = leadcoef( MD[@y, @x] );
-          if ( (@max != 0) )
-            {
-              @a = @ones[@y];
-              @t = @t - @max * @given[@a][1];
-            };
-        };
-      
+        // for every "@x" column
+        {
+          @max = leadcoef( MD[@y, @x] );
+          if ( (@max != 0) )
+            {
+              @a = @ones[@y];
+              @t = @t - @max * @given[@a][1];
+            };
+        };
+
       result[@k] = @t;
     };
@@ -1806 +1805 @@
 {
   BCall( "reduce_one_per_row" );
-        
+
   int @k;
   int @l = size (@given);
-        
+
   if( @l == 0 )
     {
       return (@given);
     };
-        
+
   int @char = char(basering);
-        
+
   intvec @marks;
 
@@ -1826 +1825 @@
   list @unis = list ();
   poly p;
-        
+
   for ( @k = @l; @k > 0; @k -- )
     {
@@ -1833 +1832 @@
 
       if( p == 0 )
-        {
-          @marks[@k] = 2;
-        } else
-          {
-            @marks[@k] = 1;
-            if ( @char == 0 )
-              {
-                @t = @t + p;
-              };
-          };
-    };
-        
+        {
+          @marks[@k] = 2;
+        } else
+          {
+            @marks[@k] = 1;
+            if ( @char == 0 )
+              {
+                @t = @t + p;
+              };
+          };
+    };
+
   if ( @char != 0 )
     {
@@ -1850 +1849 @@
       execute( "ring NewRingWithGoodField = (0), (" + varstr(save) + "), (" + ordstr(save) + "); ");
       poly @t = 0;
-                
+
       if(! defined (@unis) )
-        {
-          list @unis = imap( save, @unis );
-        };
-                
+        {
+          list @unis = imap( save, @unis );
+        };
+
       for ( @k = @l; @k > 0; @k -- )
-        {
-          if( @marks[@k] == 1 )
-            {
-              @t = @t + @unis[@k];
-            };
-        };
-    };
-                
+        {
+          if( @marks[@k] == 1 )
+            {
+              @t = @t + @unis[@k];
+            };
+        };
+    };
+
   int @loop_size = size(@t);
   poly @for_delete, @tt;
   int @ll;
-        
+
   while( @loop_size > 0 )
     {
       @for_delete = poly(0);
-      @ll = size(@t);    
-                
+      @ll = size(@t);
+
       for ( @k = @ll; @k > 0; @k -- )
-        {
-          if ( leadcoef(@t[@k]) == 1 )
-            {
-              @for_delete = @for_delete + @t[@k];
-            };
-        };
+        {
+          if ( leadcoef(@t[@k]) == 1 )
+            {
+              @for_delete = @for_delete + @t[@k];
+            };
+        };
 
       @loop_size = size( @for_delete );
 
       if ( @loop_size>0 )
-        {
-          for( @k = @l ; @k > 0 ; @k -- )
-            {       
-              if ( @marks[@k] == 1) 
-                {
-                  @tt = @unis[@k];
-
-                  if( size( @for_delete + @tt ) != ( size( @for_delete )  + size( @tt ) ) ) 
-                    {
-                      @t = @t - @tt;
-                      @marks[@k] = 0;
-                    };
-                };
-            };          
-        };              
-    };
-        
+        {
+          for( @k = @l ; @k > 0 ; @k -- )
+            {
+              if ( @marks[@k] == 1)
+                {
+                  @tt = @unis[@k];
+
+                  if( size( @for_delete + @tt ) != ( size( @for_delete )  + size( @tt ) ) )
+                    {
+                      @t = @t - @tt;
+                      @marks[@k] = 0;
+                    };
+                };
+            };
+        };
+    };
+
   if ( @char != 0 )
     {
@@ -1909 +1908 @@
 
   list @reduced = list();
-        
+
   for ( @k = @l ; @k>0 ; @k --)
     {
       if (@marks[@k]==2)
-        {
-          @reduced = list ( @given[@k] ) + @reduced ;
-        } else
-          {
-            if (@marks[@k]==1)
-              {
-                @reduced = @reduced + list ( @given[@k] );
-              };
-          };
-    };
-    
+        {
+          @reduced = list ( @given[@k] ) + @reduced ;
+        } else
+          {
+            if (@marks[@k]==1)
+              {
+                @reduced = @reduced + list ( @given[@k] );
+              };
+          };
+    };
+
   ECall( "reduce_one_per_row", "structured list" );
   return (@reduced);
@@ -1954 +1953 @@
       @tt = @AD_GIVEN[@number][2];
       if ( size (@tt) == 0)
-        {
-          @AD_CALC = @AD_CALC + list ( @AD_GIVEN[@number][1] );
-        } else
-          {
-            @t = uni_poly( @tt );
-            @t_size = size(@t);
-        
-            @GR_TEMP = list ();
-            @GR_TEMP[1] = @t;
-            @GR_TEMP[2] = list ( @AD_GIVEN[@number] );
-
-            @loop_size = size(@GR);
-            if ( @loop_size == 0 )
-              {
-                @GR = list(@GR_TEMP);
-              } else
-                {
-                  for ( @k = @loop_size; @k > 0 ; @k -- )
-                    {
-                      @tt = @GR[@k][1];
-                      if ( size( @t + @tt ) != ( @t_size + size(@tt) ) ) 
-                        // whether @tt and @i intersencts? ( will not work in char == 2 !!!)
-                        {
-
-                          if ( char(basering) == 0 )
-                            {
-                              @GR_TEMP[1] = @GR_TEMP[1] + @tt;
-                            } else
-                              {
-                                @GR_TEMP[1] = uni_poly( @GR_TEMP[1] + @tt );
-                              };
-                        
-                          @GR_TEMP[2] = @GR_TEMP[2] + @GR[@k][2];
-                          @GR = delete ( @GR, @k );
-                        };
-                    };
-                  @GR = @GR + list(@GR_TEMP);
-                };
-          };
+        {
+          @AD_CALC = @AD_CALC + list ( @AD_GIVEN[@number][1] );
+        } else
+          {
+            @t = uni_poly( @tt );
+            @t_size = size(@t);
+
+            @GR_TEMP = list ();
+            @GR_TEMP[1] = @t;
+            @GR_TEMP[2] = list ( @AD_GIVEN[@number] );
+
+            @loop_size = size(@GR);
+            if ( @loop_size == 0 )
+              {
+                @GR = list(@GR_TEMP);
+              } else
+                {
+                  for ( @k = @loop_size; @k > 0 ; @k -- )
+                    {
+                      @tt = @GR[@k][1];
+                      if ( size( @t + @tt ) != ( @t_size + size(@tt) ) )
+                        // whether @tt and @i intersencts? ( will not work in char == 2 !!!)
+                        {
+
+                          if ( char(basering) == 0 )
+                            {
+                              @GR_TEMP[1] = @GR_TEMP[1] + @tt;
+                            } else
+                              {
+                                @GR_TEMP[1] = uni_poly( @GR_TEMP[1] + @tt );
+                              };
+
+                          @GR_TEMP[2] = @GR_TEMP[2] + @GR[@k][2];
+                          @GR = delete ( @GR, @k );
+                        };
+                    };
+                  @GR = @GR + list(@GR_TEMP);
+                };
+          };
       @number --;
     }; //  main while
-    
+
   list @res;
 
@@ -2001 +2000 @@
     {
       if ( size (@GR[@k][2]) > 1 ) // ! zeroes in AD_CALC so here must be non zero
-        {
-          @res = FSS ( @GR[@k][2], uni_poly(@GR[@k][1]));
-          
-          if ( size (@res) > 0 )
-            {
-              @AD_CALC = @AD_CALC + @res;
-            };
-        };
-    };    
+        {
+          @res = FSS ( @GR[@k][2], uni_poly(@GR[@k][1]));
+
+          if ( size (@res) > 0 )
+            {
+              @AD_CALC = @AD_CALC + @res;
+            };
+        };
+    };
 
   ECall( "calc_base" );
@@ -2031 +2030 @@
 
   poly f, t;
-  
-  if ( typeof(#[1]) == "int") 
+
+  if ( typeof(#[1]) == "int")
     {
       int next = #[1];
@@ -2038 +2037 @@
     } else
       {
-        if ( typeof(#[1]) == "poly") 
-          {
-            f = #[1];
-          } else
-            {
-              print("Error: cannot differentiate with '" + string(#)+"'");
-              return ();
-            };
+        if ( typeof(#[1]) == "poly")
+          {
+            f = #[1];
+          } else
+            {
+              print("Error: cannot differentiate with '" + string(#)+"'");
+              return ();
+            };
       };
 
@@ -2069 +2068 @@
   list t = reduce_one_per_row( l, 0); // optimization (a1)
   return( QNF_list ( ApplyAd( calc_base(t), # ), 2) );          // calculation of groupps (a2) + gauss.
-    
+
 };
 
@@ -2077 +2076 @@
 static proc makeIdeal ( list l )
   "
-        return: ideal: where the generators are polynomials from list, without 1 and zeroes
+        return: ideal: where the generators are polynomials from list, without 1 and zeroes
 "
 {
@@ -2085 +2084 @@
     {
       if ( typeof( l[i] ) == "list" )
-        {
-          p = l[i][1]; // just take the 1st polynom...
-        } else
-          {
-            p = l[i];
-          };
-                
+        {
+          p = l[i][1]; // just take the 1st polynom...
+        } else
+          {
+            p = l[i];
+          };
+
       p = cleardenom( p* (1/content(p)) );
       if ( (p != 1) and (p != 0) )
-        {
-          I = I, p;
-        };
-    };
-        
+        {
+          I = I, p;
+        };
+    };
+
   I = simplify ( I, 2 ); // no zeroes
-        
+
   return(I);
 };
@@ -2116 +2115 @@
       t = var(k);
       if ( QNF_poly(t * p - p * t) != 0 )
-        {
-          if( toprint() ) 
-            {
-              "POLY: ", string (p), " is NOT in center";
-            };
-          return (0);
-        };
-    };
-
-  if( toprint() ) 
+        {
+          if( toprint() )
+            {
+              "POLY: ", string (p), " is NOT in center";
+            };
+          return (0);
+        };
+    };
+
+  if( toprint() )
     {
       "POLY: ", string (p), " is in center";
@@ -2137 +2136 @@
   for ( int @i = 1; @i <= size(l); @i++ )
     {
-      if ( typeof(l[@i])=="poly" ) 
-        {
-          if (! inCenter_poly(l[@i]) )
-            {
-              return(0);
-            };
-                
-        } else
-          {
-            if ( (typeof(l[@i])=="list") or (typeof(l[@i])=="ideal") ) 
-              {
-                if (! inCenter_list(l[@i]) )
-                  {
-                    return(0);
-                  };
-              };
-          };
+      if ( typeof(l[@i])=="poly" )
+        {
+          if (! inCenter_poly(l[@i]) )
+            {
+              return(0);
+            };
+
+        } else
+          {
+            if ( (typeof(l[@i])=="list") or (typeof(l[@i])=="ideal") )
+              {
+                if (! inCenter_list(l[@i]) )
+                  {
+                    return(0);
+                  };
+              };
+          };
     };
   return(1);
@@ -2166 +2165 @@
 {
   if ( QNF_poly(f * p - p * f) != 0 )
-    {     
-      if( toprint() ) 
-        {
-          "POLY: ", string (p), " is NOT in centralizer(f)";
-        };
+    {
+      if( toprint() )
+        {
+          "POLY: ", string (p), " is NOT in centralizer(f)";
+        };
       return (0);
     };
-        
-  if( toprint() ) 
+
+  if( toprint() )
     {
       "POLY: ", string (p), " is in centralizer(f)";
@@ -2186 +2185 @@
   for ( int @i = 1; @i <= size(l); @i++ )
     {
-      if ( typeof(l[@i])=="poly" ) 
-        {
-          if (! inCentralizer_poly(l[@i], f) )
-            {
-              return(0);
-            };
-                
-        } else
-          {
-            if ( (typeof(l[@i])=="list") or (typeof(l[@i])=="ideal") ) 
-              {
-                if (! inCentralizer_list(l[@i], f) )
-                  {
-                    return(0);
-                  };
-              };
-          };
+      if ( typeof(l[@i])=="poly" )
+        {
+          if (! inCentralizer_poly(l[@i], f) )
+            {
+              return(0);
+            };
+
+        } else
+          {
+            if ( (typeof(l[@i])=="list") or (typeof(l[@i])=="ideal") )
+              {
+                if (! inCentralizer_list(l[@i], f) )
+                  {
+                    return(0);
+                  };
+              };
+          };
     };
   return(1);
@@ -2220 +2219 @@
 /* static */ proc center_min_iterative( int MaxDeg, list # )
   "
-        computes the 'minimal' set of central elements (of deg <= MaxDeg) in iterative way
-        Note: based on calc_k_base, zAddBad, zRefine, zCancel, PBW_*
+        computes the 'minimal' set of central elements (of deg <= MaxDeg) in iterative way
+        Note: based on calc_k_base, zAddBad, zRefine, zCancel, PBW_*
 "
 {
   BCall("center_min_iterative", MaxDeg, #);
-        
+
   int n = myInt(#);
   int m = ( MaxDeg < 0 ); // no bound on Degree
-        
+
   int MinDeg = 6; // starting guess for MaxDeg
   int Delta  = 4; // increment of MaxDeg
-        
+
   if( m )
-    {   
+    {
       // minimal guess
-      MaxDeg = MinDeg;          
-    };
-        
+      MaxDeg = MinDeg;
+    };
+
   list @q; int @i; int N = nvars(basering);
 
@@ -2250 +2249 @@
   list SYS = PBW_sys( my_vars(), my_var(1) );
 
-        
-  list @z = list ();                                    // center list
-  list @l = init_bads( MaxDeg );        // verbotten leadexps...
-        
+
+  list @z = list ();                                         // center list
+  list @l = init_bads( MaxDeg );         // verbotten leadexps...
+
   @q = PBW[ index(0) ];
 
@@ -2260 +2259 @@
     {
       for ( @i = 2; @i <= N; @i ++ )
-        {
-          @q = calc_k_base (@q, my_var(@i));
-        };
+        {
+          @q = calc_k_base (@q, my_var(@i));
+        };
 
       @q = zRefine (calc_k_base(@q)); // new center!
 
 
-      if ( size(@q) > 0 ) 
-        {
-          @z = @z + @q; // computed central elements
-                        
-          if( (n > 0) and (size(@z) > n) )
-            { 
-              break; // found all central elements                      
-            };
-        };
+      if ( size(@q) > 0 )
+        {
+          @z = @z + @q; // computed central elements
+
+          if( (n > 0) and (size(@z) > n) )
+            {
+              break; // found all central elements
+            };
+        };
 
       if( k == ( MaxDeg+1 ) )
-        {
-          if( (n == 0) and ( !m ) )
-            {
-              break; // that's all
-            };
-                        
-          MaxDeg = MaxDeg + Delta;
-                        
-          // renew bad list
-          @l = init_bads( MaxDeg );                     
-          @l = zAddBad( @l, @z, MaxDeg, 0 );
-                        
-        } else
-          {
-                
-            if ( size(@q) > 0 ) 
-              {
-                @l = zAddBad( @l, @q, MaxDeg, 0 ); // add all possible 'leadexps' !
-              };
-                        
-          };
+        {
+          if( (n == 0) and ( !m ) )
+            {
+              break; // that's all
+            };
+
+          MaxDeg = MaxDeg + Delta;
+
+          // renew bad list
+          @l = init_bads( MaxDeg );
+          @l = zAddBad( @l, @z, MaxDeg, 0 );
+
+        } else
+          {
+
+            if ( size(@q) > 0 )
+              {
+                @l = zAddBad( @l, @q, MaxDeg, 0 ); // add all possible 'leadexps' !
+              };
+
+          };
 
       PBW[index(k)] = PBW_next( PBW, k, SYS );
@@ -2318 +2317 @@
 static proc center_vectorspace( int MaxDeg )
   "
-        pure calculation of center as a finitely dimensional Vector Space (deg <= MaxDeg )
+        pure calculation of center as a finitely dimensional Vector Space (deg <= MaxDeg )
 "
 {
   my_var_init();
-        
+
   int  N = nvars( basering );
-  list P = PBW_base( MaxDeg, my_var(1) ); 
-        
+  list P = PBW_base( MaxDeg, my_var(1) );
+
   for( int v = 2; v <= N; v++ )
     {
@@ -2332 +2331 @@
 
   my_var_done();
-        
+
   return( calc_k_base ( P ) );
 };
@@ -2339 +2338 @@
 /* static */ proc center_min_vectorspace( int MaxDeg )
   "
-    computes the 'minimal' set of central elements (of deg <= MaxDeg) 
+    computes the 'minimal' set of central elements (of deg <= MaxDeg)
     by reducing the set of it's generators as vector space
-    
+
     Note: based on center_vectorspace.
     Note: reduction by zReduce.
@@ -2381 +2380 @@
   computes the 'minimal' set of elements (of deg <= MaxDeg) generating centralizer of p in iterative way
   Note: based on calc_k_base
-  
+
   !!! NEED DEBUG !!!
   Note: no proof that it is really centralizer and moreover 'minimal' centralizer
@@ -2390 +2389 @@
   int n = myInt(#);
   int m = (MaxDeg < 0);
-        
+
   int MinDeg = 6; // starting guess for MaxDeg
   int Delta  = 4; // increment of MaxDeg
-        
+
   if( m )
     {
@@ -2411 +2410 @@
   list @z  = list ();             // result list
   list @l  = init_bads( MaxDeg ); // verbotten loeadexps...
-        
+
   @q = PBW[ index(0) ];
 
   for (int k = 1; k <= ( MaxDeg+1 ); k ++ )
     {
-      @q = zRefine( calc_k_base(@q), 1 ); 
-
-      if ( size(@q) > 0 ) 
-        {
-          @z = @z + @q; // computed desired elements
-                  
-          if( (n > 0) and (size(@z) > n) )
-            {
-              break; // found needed elements
-            };
-        };
+      @q = zRefine( calc_k_base(@q), 1 );
+
+      if ( size(@q) > 0 )
+        {
+          @z = @z + @q; // computed desired elements
+
+          if( (n > 0) and (size(@z) > n) )
+            {
+              break; // found needed elements
+            };
+        };
 
       if( k == ( MaxDeg+1 ) )
-        {
-          if( (n == 0) or ( !m ) )
-            {
-              break; // that's all
-            };                  
-                  
-          MaxDeg = MaxDeg + Delta;
-                  
-          // renew bad list
-          @l = init_bads( MaxDeg );                     
-          @l = zAddBad( @l, @z, MaxDeg, 0 );
-                  
-        } else
-          {
-                    
-            if ( size(@q) > 0 ) 
-              {
-                @l = zAddBad( @l, @q, MaxDeg, 0 ); // add all possible 'leadexps' !
-              };
-                    
-          };
-                
+        {
+          if( (n == 0) or ( !m ) )
+            {
+              break; // that's all
+            };
+
+          MaxDeg = MaxDeg + Delta;
+
+          // renew bad list
+          @l = init_bads( MaxDeg );
+          @l = zAddBad( @l, @z, MaxDeg, 0 );
+
+        } else
+          {
+
+            if ( size(@q) > 0 )
+              {
+                @l = zAddBad( @l, @q, MaxDeg, 0 ); // add all possible 'leadexps' !
+              };
+
+          };
+
       PBW[index(k)] = PBW_next( PBW, k, SYS );
       PBW_PLAIN = PBW_PLAIN + zCancel( PBW[index(k-1)] , @l );
@@ -2475 +2474 @@
   QNF_init();
   def res;
-        
+
   if ( typeof(a) == "poly" )
     {
@@ -2481 +2480 @@
     } else
       {
-        if ( (typeof(a)=="list") or (typeof(a)=="ideal") )
-          {
-            res = inCenter_list(a);
-          } else 
-            {
-              res = a;
-            };
+        if ( (typeof(a)=="list") or (typeof(a)=="ideal") )
+          {
+            res = inCenter_list(a);
+          } else
+            {
+              res = a;
+            };
       };
-        
+
   QNF_done();
   return (res);
@@ -2513 +2512 @@
 
 
-/******************************************************************************/ 
+/******************************************************************************/
 proc inCentralizer( def a, poly f )
 "USAGE:   inCentralizer(a, f); a poly/list/ideal, f poly
@@ -2524 +2523 @@
   if ( typeof(a) == "poly" )
     {
-      res = inCentralizer_poly(a, f); 
+      res = inCentralizer_poly(a, f);
     } else
       {
-        if ( (typeof(a)=="list") or (typeof(a)=="ideal") )
-          {
-            res = inCentralizer_list(a, f); 
-          } else
-            {
-              res = a;
-            };
+        if ( (typeof(a)=="list") or (typeof(a)=="ideal") )
+          {
+            res = inCentralizer_list(a, f);
+          } else
+            {
+              res = a;
+            };
       };
 
@@ -2583 +2582 @@
   print( "Error: wrong arguments." );
   return();
-        
+
 }
 example
@@ -2595 +2594 @@
  ideal Z = center(2); // find all central elements of degree <= 2
  Z;
- inCenter(Z); 
+ inCenter(Z);
  ideal ZZ = center(-1, 1 ); // find the first non trivial central element
  ZZ; "";
@@ -2614 +2613 @@
 EXAMPLE:    example centralizer; shows an example"
 {
-        
+
   if( myInt(#) > 0 )
     {
       return( centralizer_min_iterative( p, MaxDeg, # ) );
     };
-        
+
   if( MaxDeg >= 0 )
     {
@@ -2625 +2624 @@
       return( centralizer_min_vectorspace( p, MaxDeg ) );
     };
-        
+
   print( "Error: wrong arguments." );
   return();
@@ -2642 +2641 @@
  ideal c = centralizer(f, 2); // find all elements of degree <= 2 which lies in centralizer of f
  c;
- inCentralizer(c, f); 
+ inCentralizer(c, f);
  ideal cc = centralizer(f, -1, 2 ); // find at least first two non trivial elements of the centralizer of f
  cc;
- inCentralizer(cc, f); 
+ inCentralizer(cc, f);
  poly g = z^2-2*z; // any polynomial
  g; "";
  c = centralizer(g, 2); // find all elements of degree <= 2 which lies in centralizer of g
  c; "";
- inCentralizer(c, g); 
+ inCentralizer(c, g);
  cc = centralizer(g, -1, 2 ); // find at least first two non trivial elements of the centralizer of g
  cc; "";
- inCentralizer(cc, g); 
-};
+ inCentralizer(cc, g);
+};

Singular/LIB/classify.lib

@@ -1 +1 @@
 // KK,GMG last modified: 17.12.00
 ///////////////////////////////////////////////////////////////////////////////
-version  = "$Id: classify.lib,v 1.49 2001-08-27 14:47:48 Singular Exp $";
+version  = "$Id: classify.lib,v 1.50 2005-05-06 14:38:10 hannes Exp $";
 category="Singularities";
 info="
@@ -1646 +1646 @@
         debug_log(6,"Koeffizient von x(" + string(RFlg[i]) + ")^2 ist:", a);
         if( (a != 0) || (i==n) )
-        {
+        {
           debug_log(6, "BREAK!!!!!!!!!!!!!!");
           break;
@@ -1654 +1654 @@
         B = maxideal(1);
         for( k=1; k<=n ; k=k+1)
-        {
+        {
           if(k==RFlg[j]) { B[rvar(x(k))] = x(k) + x(RFlg[i]); }
         }
@@ -1672 +1672 @@
                       string(P));
         if(P != 0)
-        {
+        {
           debug_log(6, "1 Koeffizient von x("+string(RFlg[i])+") ist: ",
                        string(P));
@@ -1688 +1688 @@
           P    = Coeff(fc, x(RFlg[i]), x(RFlg[i]));
           if( P != 0)
-          {
+          {
             fi = fc;
             continue;

Singular/LIB/control.lib

@@ -1 @@
-version="$Id: control.lib,v 1.30 2005-05-06 09:41:58 Singular Exp $";
+version="$Id: control.lib,v 1.31 2005-05-06 14:38:12 hannes Exp $";
 category="System and Control Theory";
 info="
@@ -35 +35 @@
 ";
 
-LIB "homolog.lib"; 
+LIB "homolog.lib";
 LIB "poly.lib";
 LIB "primdec.lib";
@@ -74 +74 @@
 RETURN:  no return value
 PURPOSE:  procedure for (well-) formatted output of modules, matrices, lists of modules, matrices; shows everything even if entries are long
-NOTE:  in case of other types( not 'module', 'matrix', 'list') works just as standard 'print' procedure  
+NOTE:  in case of other types( not 'module', 'matrix', 'list') works just as standard 'print' procedure
 EXAMPLE:  example view; shows an example
 "{
@@ -88 +88 @@
   int max;
   string s;
-  
+
   for(i=1;i<=@C;i++)
-  { 
-    max=0; 
-    
+  {
+    max=0;
+
     for(j=1;j<=@R;j++)
     {
@@ -103 +103 @@
     MaxLength[i] = max;
   };
-  
+
   for(i=1;i<=@R;i++)
   {
@@ -111 +111 @@
       s=s+string(M[i,j])+space( MaxLength[j]-size( string( M[i,j] ) ) ) +",";
     };
-    
+
     s=s+string(M[i,j])+space( MaxLength[j]-size( string( M[i,j] ) ) );
 
@@ -121 +121 @@
   };
 
-  return();    
+  return();
   };
-  
+
   if(typeof(M)=="list")
   {
@@ -132 +132 @@
       view(M[i]);
       print("");
-    }; 
+    };
 
     return();
@@ -152 +152 @@
 RETURN:  module
 EXAMPLE: example RightKernel; shows an example
-"{ 
+"{
   return(modulo(M,std(0)));
 }
@@ -215 +215 @@
 }
 example
-{ 
+{
   "EXAMPLE:";echo =2;
   // a trivial example:
@@ -221 +221 @@
   matrix M[2][1] = 1,x2z;
   print(M);
-  print( LeftInverse(M) );  
+  print( LeftInverse(M) );
   kill r;
   // derived from the example TwoPendula:
@@ -252 +252 @@
   matrix M[1][2] = 1,x2+z;
   print(M);
-  print( RightInverse(M) );  
+  print( RightInverse(M) );
   kill r;
   // derived from the TwoPendula example:
@@ -307 +307 @@
 };
 //------------------------------------------------------------------------
-static proc control_output(int i, int NVars, module R, module Ext_1, list Gen) 
-"USAGE:  control_output(i, NVars, R, Ext_1), 
+static proc control_output(int i, int NVars, module R, module Ext_1, list Gen)
+"USAGE:  control_output(i, NVars, R, Ext_1),
 PURPOSE: where
 @*         i is integer (number of first nonzero Ext or a number of variables in a basering + 1 in case that all the Exts are zero),
-@*         NVars:  integer, number of variables in a base ring,
-@*         R:  module R (cokernel representation),
-@*         Ext_1:  module, the first Ext(its cokernel representation)      
+@*           NVars:  integer, number of variables in a base ring,
+@*           R:  module R (cokernel representation),
+@*           Ext_1:  module, the first Ext(its cokernel representation)
 RETURN:  list with all the contollability properties of the system which is to be returned in 'control' procedure
 NOTE:  this procedure is used in 'control' procedure
@@ -323 +323 @@
   string Gen_mes = "Parameter constellations which might lead to a non-controllable system:";
 
-  module RK = RightKernel(R); 
+  module RK = RightKernel(R);
   int d=dim_Our(std(transpose(R)));
 
   if (i==1)
-  { 
-    return( 
+  {
+    return(
             list ( Fn,
-                   i,
-                  "not controllable , image representation for controllable part:",
-                   RK,      
-                  "kernel representation for controllable part:",
-                   LeftKernel( RK ),
-                  "obstruction to controllability",
-                   Ext_1,
-                  "annihilator of torsion module (of obstruction to controllability)",
-                   Ann_Our(Ext_1),
-                   DofS,
-                   d
-                 ) 
+                   i,
+                  "not controllable , image representation for controllable part:",
+                    RK,
+                  "kernel representation for controllable part:",
+                   LeftKernel( RK ),
+                  "obstruction to controllability",
+                   Ext_1,
+                  "annihilator of torsion module (of obstruction to controllability)",
+                   Ann_Our(Ext_1),
+                   DofS,
+                   d
+                 )
           );
   };
-  
+
   if(i>NVars)
-  { 
+  {
     return( list(  Fn,
-                   -1, 
+                   -1,
                   "strongly controllable(flat), image representation:",
-                   RK,
-                  "left inverse to image representation:",
-                   LeftInverse(RK),
-                   DofS,
-                   d,
-                   Gen_mes,
-                   Gen) 
+                   RK,
+                  "left inverse to image representation:",
+                   LeftInverse(RK),
+                   DofS,
+                   d,
+                   Gen_mes,
+                   Gen)
           );
   };
-  
+
   //
   //now i<=NVars
   //
-       
+
   if( (i==2) )
   {
     return( list( Fn,
-                  i, 
+                  i,
                  "controllable, not reflexive, image representation:",
-                  RK,
+                  RK,
                   DofS,
                   d,
-                  Gen_mes,
-                  Gen) 
-          ); 
+                  Gen_mes,
+                  Gen)
+          );
   };
-    
+
   if( (i>=3) )
   {
     return( list ( Fn,
-                   i, 
+                   i,
                   "reflexive, not strongly controllable, image representation:",
-                   RK,
-                   DofS,
-                   d,
-                   Gen_mes,
-                   Gen) 
+                   RK,
+                   DofS,
+                   d,
+                      Gen_mes,
+                   Gen)
           );
-  };  
-};  
+  };
+};
 //-------------------------------------------------------------------------
 
@@ -400 +400 @@
 {
   int i;
-  int NVars=nvars(basering); 
+  int NVars=nvars(basering);
   // TODO: NVars to be replaced with the global hom. dimension of basering!!!
   int ExtIsZero;
@@ -406 +406 @@
   module R_std=std(R);
   module Ext_1 = std(Ext_Our(1,R_std));
-   
+
   ExtIsZero=is_zero_Our(Ext_1);
   i=1;
@@ -421 +421 @@
 }
 example
-{"EXAMPLE:";echo = 2; 
+{"EXAMPLE:";echo = 2;
   // a WindTunnel example
   ring A = (0,a, omega, zeta, k),(D1, delta),dp;
@@ -444 +444 @@
   {
     return ("control2 cannot be applied, since R does not have full row rank");
-  }  
+  }
   intvec v=Opt_Our();
   module R_std=std(R);
@@ -457 +457 @@
 }
 example
-{"EXAMPLE:";echo = 2; 
+{"EXAMPLE:";echo = 2;
   //a WindTunnel example
   ring A = (0,a, omega, zeta, k),(D1, delta),dp;
@@ -489 +489 @@
     [-D(2),D(1),0];
   R=transpose(R);
-  colrank(R); 
-};
-  
+  colrank(R);
+};
+
 //------------------------------------------------------------------------
-static proc autonom_output( int i, int NVars, module RC, int R_rank ) 
+static proc autonom_output( int i, int NVars, module RC, int R_rank )
 "USAGE:  proc autonom_output(i, NVars, RC, R_rank)
-           i:  integer, number of first nonzero Ext or 
-               just number of variables in a base ring + 1 in case that all the Exts are zero
-           NVars:  integer, number of variables in a base ring  
-           RC: module, kernel-representation of controllable part of the system
-           R_rank: integer, column rank of the representation matrix
+           i:  integer, number of first nonzero Ext or
+               just number of variables in a base ring + 1 in case that all the Exts are zero
+           NVars:  integer, number of variables in a base ring
+           RC: module, kernel-representation of controllable part of the system
+           R_rank: integer, column rank of the representation matrix
 PURPOSE: compute all the autonomy properties of the system which is to be returned in 'autonom' procedure
-RETURN:  list 
+RETURN:  list
 NOTE:  this procedure is used in 'autonom' procedure
 "
@@ -509 +509 @@
   string Fn = "number of first nonzero Ext:";
   if(i==0)
-  { 
+  {
     return( list(  Fn,
                    i,
                   "not autonomous",
-                   "kernel representation for controllable part",
-                   RC,
-                   "column rank of the matrix",
-                   R_rank,
-                   DofS,
-                   d ) 
-          );
+                   "kernel representation for controllable part",
+                   RC,
+                   "column rank of the matrix",
+                   R_rank,
+                   DofS,
+                   d )
+          );
   };
-  
+
   if( i>NVars )
-  {  
+  {
     return( list( Fn,
                   -1,
                   "trivial",
-                  DofS,
-                  d ) 
+                  DofS,
+                  d )
           );
   };
-  
+
   //
   //now i<=NVars
   //
-    
-     
+
+
   if( i==1 )
   // in case that NVars==1 there is no sense to consider the notion
-  // of strongly autonomous behavior, because it does not imply 
+  // of strongly autonomous behavior, because it does not imply
   // that system is overdetermined in this case
   {
     return( list ( Fn,
-                   i, 
+                   i,
                   "autonomous, not overdetermined",
-                   DofS,
-                   d ) 
-          ); 
+                   DofS,
+                   d )
+          );
   };
-    
+
   if( i==NVars )
-  {  
+  {
     return( list(  Fn,
                    i,
                   "strongly autonomous(fin. dimensional),in particular overdetermined",
-                   DofS,
-                   d) 
-          );
+                   DofS,
+                   d)
+          );
   };
-  
+
   if( i<NVars )
   {
@@ -565 +565 @@
                    i,
                   "overdetermined, not strongly autonomous",
-                   DofS, 
-                   d) 
+                   DofS,
+                   d)
           );
   };
-};  
+};
 //--------------------------------------------------------------------------
 proc autonom2(module R)
@@ -578 +578 @@
 EXAMPLE:  example autonom2; shows an example
 "
-{ 
+{
   int d;
   int NVars = nvars(basering);
@@ -584 +584 @@
   module RC;  //for computation of controllable part if if exists
   int R_rank = ncols(R);
-  d     = dim_Our( std(RT) );  //this is the dimension of the system 
+  d     = dim_Our( std(RT) );  //this is the dimension of the system
   int i = NVars-d;  //First non-zero Ext
   if( d==0 )
@@ -599 +599 @@
   module R= [s1,-s2],
             [s2, s1],
-            [s3,-s4],
-            [s4, s3];       
+            [s3,-s4],
+            [s4, s3];
   R=transpose(R);
   view( R );
   view( autonom2(R) );
-};  
+};
 //----------------------------------------------------------
 proc autonom(module R)
@@ -618 +618 @@
   module RC;
   int R_rank=ncols(R);
-  ExtIsZero=is_zero_Our(Ext_Our(0,RT));     
+  ExtIsZero=is_zero_Our(Ext_Our(0,RT));
   int i=0;
   while( (ExtIsZero)&&(i<=NVars) )
@@ -638 +638 @@
   module R= [s1,-s2],
             [s2, s1],
-            [s3,-s4],
-            [s4, s3];       
+            [s3,-s4],
+            [s4, s3];
   R=transpose(R);
   view( R );
   view( autonom(R) );
-};  
+};
 
 
@@ -650 +650 @@
 "USAGE:  genericity(M), M is a matrix/module
 PURPOSE: determine parametric expressions which have been assumed to be non-zero in the process of computing the Groebner basis
-RETURN:  list (of strings) 
-NOTE: we strongly recommend to switch on the redSB and redTail options; 
+RETURN:  list (of strings)
+NOTE: 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
@@ -672 +672 @@
   "EXAMPLE:"; echo = 2;
   ring r=(0,m1,m2,M,g,L1,L2),Dt,dp;
-  module RR = 
-    [m1*L1*Dt^2, m2*L2*Dt^2, -1, (M+m1+m2)*Dt^2], 
+  module RR =
+    [m1*L1*Dt^2, m2*L2*Dt^2, -1, (M+m1+m2)*Dt^2],
     [m1*L1^2*Dt^2-m1*L1*g, 0, 0, m1*L1*Dt^2],
     [0, m2*L2^2*Dt^2-m2*L2*g, 0, m2*L2*Dt^2];
@@ -730 +730 @@
       cl++;
       p = p - lead(p); // for the next cycle
-    }      
+    }
     if ( p!= 0)
     {
@@ -782 +782 @@
       for (j=1; j<=size(F);j++)
       {
-        q = F[j]-lead(F[j]);
-        if (q!=0)
-        {
-          @L[cl] = F[j];
-          cl++;
-        }
+        q = F[j]-lead(F[j]);
+        if (q!=0)
+        {
+          @L[cl] = F[j];
+          cl++;
+        }
       }
     }
@@ -814 +814 @@
   {
     p = I[i];
-    while (p !=0) 
-    { 
-      Den = Den, denominator(leadcoef(p)); 
-      p   = p-lead(p); 
-    }
-  }
-  Den = simplify(Den,2+4);  
+    while (p !=0)
+    {
+      Den = Den, denominator(leadcoef(p));
+      p   = p-lead(p);
+    }
+  }
+  Den = simplify(Den,2+4);
   string newvars = parstr(basering);
   def save = basering;
@@ -830 +830 @@
   int s1 = size(Den);
   for (i=1; i<=s1; i++)
-  { 
+  {
     if (Den[i] !=1)
-    { 
-      F= F, factorize(Den[i],1); 
-    } 
-  }
-  F = simplify(F, 2+4+8); 
+    {
+      F= F, factorize(Den[i],1);
+    }
+  }
+  F = simplify(F, 2+4+8);
   ideal @L = F;
   list SL;
@@ -871 +871 @@
 "USAGE:  canonize(L), L a list
 PURPOSE: modules in the list are canonized by computing their reduced minimal (= unique up to constant factor w.r.t. the given ordering) Groebner bases
-RETURN:  list 
+RETURN:  list
 ASSUME:  L is the output of control/autonomy procedures
 EXAMPLE:  example canonize; shows an example
@@ -896 +896 @@
   "EXAMPLE:"; echo = 2;
   ring r=(0,m1,m2,M,g,L),Dt,dp;
-  module RR = 
-    [m1*L*Dt^2, m2*L*Dt^2, -1, (M+m1+m2)*Dt^2], 
+  module RR =
+    [m1*L*Dt^2, m2*L*Dt^2, -1, (M+m1+m2)*Dt^2],
     [m1*L^2*Dt^2-m1*L*g, 0, 0, m1*L*Dt^2],
     [0, m2*L^2*Dt^2-m2*L*g, 0, m2*L*Dt^2];
@@ -914 +914 @@
     {
       if(v[j]==i)
-        {
-          b=1;
-          return (b);
-        }
+        {
+          b=1;
+          return (b);
+        }
     }
   return (b);
@@ -923 +923 @@
 //-----------------------------------------------------------------
 proc iostruct(module R)
-"USAGE: iostruct( R ); R a module 
+"USAGE: iostruct( R ); R a module
 RETURN:  list L with entries: string s, intvec v, module P and module Q
 PURPOSE:  if R is the kernel-representation-matrix of some system, then we output a input-ouput representation Py=Qu of the system, the components that have been chosen as outputs(intvec v) and a comment s
@@ -941 +941 @@
   module Q;
   int n=0;
-  
+
   while(b==1)               //sort v through bubblesort
     {
       b=0;
       for(i=1;i<NRows;i++)
-        {
-          if(v[i]>v[i+1])
-          {
-            temp=v[i];
-            v[i]=v[i+1];
-            v[i+1]=temp;
-            b=1;
-          }
-        }
-    }
-  P=R[v];                     //generate P 
+        {
+          if(v[i]>v[i+1])
+          {
+            temp=v[i];
+            v[i]=v[i+1];
+            v[i+1]=temp;
+            b=1;
+          }
+        }
+    }
+  P=R[v];                     //generate P
   for(i=1;i<=NCols;i++)       //generate Q
     {
       if(elementof(i,v)==1)
-        {
-          i++;
-          continue;
-        }
+        {
+          i++;
+          continue;
+        }
       Q=Q,R[i];
     }
@@ -975 +975 @@
  ring r = (0, K1, K2, Te, Kp, Kc),(Dt, delta), (c,dp);
  module RR;
- RR = 
+ RR =
    [Dt, -K1, 0, 0, 0, 0, 0, 0, 0],
    [0, Dt+K2/Te, 0, 0, 0, 0, -Kp/Te*delta, -Kc/Te*delta, -Kc/Te*delta],
@@ -984 +984 @@
  module R = transpose(RR);
  view(iostruct(R));
-};      
+};
 
 //---------------------------------------------------------------
-static proc smdeg(matrix N)  
-"USAGE: smdeg( N ); N a matrix 
+static proc smdeg(matrix N)
+"USAGE: smdeg( N ); N a matrix
 RETURN:  intvec
 PURPOSE: returns an intvec of length 2 with the index of an element of N with smallest degree
@@ -999 +999 @@
   int i,j;            // counter
 
-  if (N==0) 
+  if (N==0)
   {
     v = 1,1;
     return(v);
-  } 
-  
-  for (i=1; i<=n; i++) 
+  }
+
+  for (i=1; i<=n; i++)
 // hier wird ein Element ausgewaehlt(!=0) und mit dessen Grad gestartet
   {
@@ -1012 +1012 @@
       if( deg(N[i,j])!=-1 )
       {
-        d=deg(N[i,j]);
-        break;
+        d=deg(N[i,j]);
+        break;
       }
     }
@@ -1019 +1019 @@
     {
       break;
-    }  
+    }
   }
   for(i=1; i<=n; i++)
@@ -1028 +1028 @@
       if ( (d_temp < d) && (N[i,j]!=0) )
       {
-        d=d_temp;
+        d=d_temp;
       }
     }
@@ -1038 +1038 @@
       if ( (deg(N[i,j]) == d) && (N[i,j]!=0) )
       {
-        v = i,j;
-        return(v);
+        v = i,j;
+        return(v);
       }
     }
@@ -1076 +1076 @@
     J = p,q; // J = N[k-1,k-1],N[k,k]; //J is of type ideal
     L[1] = liftstd(J,T);  //T is of type matrix
-    if(J[1]==p) //this is just for the case the SINGULAR swaps the 
+    if(J[1]==p) //this is just for the case the SINGULAR swaps the
     //      two elements due to ordering
-    {  
-      L[2] = T[1,1]; 
-      L[3] = T[2,1]; 
+    {
+      L[2] = T[1,1];
+      L[3] = T[2,1];
     }
     else
-    { 
-      L[2] = T[2,1]; 
-      L[3] = T[1,1]; 
+    {
+      L[2] = T[2,1];
+      L[3] = T[1,1];
     }
   }
   else
   {
-    L=extgcd(p,q); 
-    //    L=extgcd(N[k-1,k-1],N[k,k]);  
+    L=extgcd(p,q);
+    //    L=extgcd(N[k-1,k-1],N[k,k]);
     //one can use this line if extgcd-bug is fixed
   }
@@ -1100 +1100 @@
 PURPOSE: normalizes N and divides the columns of Q through the leading coefficients of the columns of N
 RETURN: normalized matrix N and altered Q(according to the scheme mentioned in purpose). If number of columns of N and Q do not coincide, N and Q are returned unchanged
-NOTE: number of columns of N and Q must coincide. 
+NOTE: number of columns of N and Q must coincide.
 "
 {
@@ -1106 +1106 @@
     {
       return (N,Q);
-    }   
+    }
   module M = module(N);
   module S = module(Q);
@@ -1123 +1123 @@
    Q = matrix(S);
    return (N,Q);
-}               
-        
+}
+
 //---------------------------------------------------------------
 proc smith( module M )
@@ -1130 +1130 @@
 PURPOSE: computes the Smith form of a matrix
 RETURN: a list of length 4 with the following entries:
-@*      [1]: The Smith-Form S of M, 
-@*      [2]: the rank of M, 
+@*      [1]: The Smith-Form S of M,
+@*      [2]: the rank of M,
 @*      [3]: a unimodular matrix U,
-@*      [4]: a unimodular matrix V, 
-such that U*M*V=S. An warning is returned when no Smith Form exists. 
+@*      [4]: a unimodular matrix V,
+such that U*M*V=S. An warning is returned when no Smith Form exists.
 NOTE: The Smith form only exists over PIDs (principal ideal domains). Use global ordering for computations!
 "
@@ -1157 +1157 @@
   matrix mu[1][m];             //to save leadcoefficients
   int ii;                       //counter
-  
-  while ((k!=n) && (k!=m) )    
+
+  while ((k!=n) && (k!=m) )
   {
     k++;
@@ -1165 +1165 @@
       while(k<=m )        //inner while-loop for row-operations
       {
-        if( (n>m) && (k < n) && (k<m))
-        {      
-          if( simplify((ideal(submat(N,k+1..n,k+1..m))),2)== 0)
-          {
-            return(N,k-1,P,Q);
-          }
-        }
+        if( (n>m) && (k < n) && (k<m))
+        {
+          if( simplify((ideal(submat(N,k+1..n,k+1..m))),2)== 0)
+          {
+            return(N,k-1,P,Q);
+          }
+        }
         i,j = smdeg(submat(N,k..n,k..m)); //choose smallest degree in the remaining submatrix
         i=i+(k-1);                        //indices adjusted to the whole matrix
-        j=j+(k-1);
-        if(i!=k)                    //take the element with smallest degree in the first position
+        j=j+(k-1);
+        if(i!=k)                    //take the element with smallest degree in the first position
         {
           N=permrow(N,i,k);
@@ -1193 +1193 @@
         for(ii=k+1;ii<=n;ii++)
         {
-          lambda[1,ii]=leadcoef(N[ii,k])/tmp;     
+          lambda[1,ii]=leadcoef(N[ii,k])/tmp;
           f[1,ii]=deg(N[ii,k])-deg_temp;
         }
         for(ii=k+1;ii<=n;ii++)
         {
-          N = addrow(N,k,-lambda[1,ii]*var(1)^f[1,ii],ii);               
+          N = addrow(N,k,-lambda[1,ii]*var(1)^f[1,ii],ii);
           P = addrow(P,k,-lambda[1,ii]*var(1)^f[1,ii],ii);
-          N,Q=normalize_Our(N,Q);
-        }
+          N,Q=normalize_Our(N,Q);
+        }
       }
       if (k>n)
       {
-        break;
+        break;
       }
       if(NoNon0Pol(transpose(N)[k])==1)
@@ -1213 +1213 @@
       tmp=leadcoef(N[k,k]);
       deg_temp=ord(N[k,k]); //ord outputs the leading degree of N[k][k]
-      
+
       for(ii=k+1;ii<=m;ii++)
       {
-        mu[1,ii]=leadcoef(N[k,ii])/tmp;     
+        mu[1,ii]=leadcoef(N[k,ii])/tmp;
         g[1,ii]=deg(N[k,ii])-deg_temp;
       }
@@ -1223 +1223 @@
         N=addcol(N,k,-mu[1,ii]*var(1)^g[1,ii],ii);
         Q=addcol(Q,k,-mu[1,ii]*var(1)^g[1,ii],ii);
-        N,Q=normalize_Our(N,Q);
+        N,Q=normalize_Our(N,Q);
       }
     }
     if( (k!=1) && (k<n) && (k<m) )
     {
-      L = extgcd_Our(N[k-1,k-1],N[k,k]);      
+      L = extgcd_Our(N[k-1,k-1],N[k,k]);
       if ( N[k-1,k-1]!=L[1] )  //means that N[k-1,k-1] is not a divisor of N[k,k]
       {
-        N=addrow(N,k-1,L[2],k);
-        P=addrow(P,k-1,L[2],k);
-        N,Q=normalize_Our(N,Q); 
-        
+        N=addrow(N,k-1,L[2],k);
+        P=addrow(P,k-1,L[2],k);
+        N,Q=normalize_Our(N,Q);
+
         N=addcol(N,k,-L[3],k-1);
-        Q=addcol(Q,k,-L[3],k-1);
-        N,Q=normalize_Our(N,Q);
-        k=k-2;
+        Q=addcol(Q,k,-L[3],k-1);
+        N,Q=normalize_Our(N,Q);
+        k=k-2;
       }
     }
-  }  
+  }
   if( (k<=n) && (k<=m) )
   {
@@ -1276 +1276 @@
 static proc list_tex(L, string name,link l,int nr_loop)
 "USAGE: list_tex(L,name,l), where L is a list, name a string, l a link
-         writes the content of list L in a tex-file 'name'
+         writes the content of list L in a tex-file 'name'
 RETURN: nothing
 "
@@ -1284 +1284 @@
     texobj(name,L);
   }
-  if(size(L)==0)  
+  if(size(L)==0)
   {
   }
@@ -1294 +1294 @@
       while(1)
       {
-        if(typeof(L[i])=="string")  //Fehler hier fuer normalen output->nur wenn string in liste dann verbatim
-        {
-          t=L[i];
-          if(nr_loop==1)
-          {
-            write(l,"\\begin\{center\}");
-            write(l,"\\begin\{verbatim\}");
-          }
-          write(l,t);
-          if(nr_loop==0)
-          {
-            write(l,"\\par");
-          }
-          if(nr_loop==1)
-          {
-            write(l,"\\end\{verbatim\}");
-            write(l,"\\end\{center\}");
-          }
-          break;
-        }
-        if(typeof(L[i])=="module")
-        {
-          texobj(name,matrix(L[i]));
-          break;
-        }
-        if(typeof(L[i])=="list")
-        {
-          list_tex(L[i],name,l,1);
-          break;
-        }
-        write(l,"\\begin\{center\}");
-        texobj(name,L[i]);
-        write(l,"\\end\{center\}");
-        write(l,"\\par");
-        break;
+        if(typeof(L[i])=="string")  //Fehler hier fuer normalen output->nur wenn string in liste dann verbatim
+        {
+          t=L[i];
+          if(nr_loop==1)
+          {
+            write(l,"\\begin\{center\}");
+            write(l,"\\begin\{verbatim\}");
+          }
+          write(l,t);
+          if(nr_loop==0)
+          {
+            write(l,"\\par");
+          }
+          if(nr_loop==1)
+          {
+            write(l,"\\end\{verbatim\}");
+            write(l,"\\end\{center\}");
+          }
+          break;
+        }
+        if(typeof(L[i])=="module")
+        {
+          texobj(name,matrix(L[i]));
+          break;
+        }
+        if(typeof(L[i])=="list")
+        {
+          list_tex(L[i],name,l,1);
+          break;
+        }
+        write(l,"\\begin\{center\}");
+        texobj(name,L[i]);
+        write(l,"\\end\{center\}");
+        write(l,"\\par");
+        break;
       }
     }
@@ -1341 +1341 @@
 "USAGE: verbatim_tex(s,l), where s is a string and l a link
 PURPOSE: writes the content of s in verbatim-environment in the file
-         specified by link
+         specified by link
 RETURN: nothing
 "
@@ -1405 +1405 @@
 @* 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
 @*  @code{def A = ControlExample(\"Antenna\");} and @code{setring A;},
-@* A will become a basering from the example \"Antenna\" with 
+@* A will become a basering from the example \"Antenna\" with
 the predefined system module R (transposed).
-After that one can just execute @code{control(R);} respectively 
+After that one can just execute @code{control(R);} respectively
 @code{autonom(R);} to perform the control resp. autonomy analysis of R.
 EXAMPLE: example ControlExample; shows an example
@@ -1469 +1469 @@
   R=transpose(R);
   export R;
-  return(@r);       
+  return(@r);
 };
 //----------------------------------------------------------
@@ -1477 +1477 @@
   module R= [s1,-s2],
             [s2, s1],
-            [s3,-s4],
-            [s4, s3];       
+            [s3,-s4],
+            [s4, s3];
   R=transpose(R);
   export R;
-  return(@r);       
-}; 
+  return(@r);
+};
 //----------------------------------------------------------
 static proc exZerz1()
-{ 
+{
   ring @r=0,(d1,d2),dp;
   module R=[d1^2-d2],
@@ -1491 +1491 @@
   R=transpose(R);
   export R;
-  return(@r);       
-};  
+  return(@r);
+};
 //----------------------------------------------------------
 //control
@@ -1501 +1501 @@
   module R=[0,-s3,s2],
            [s3,0,-s1];
-  R=transpose(R);          
+  R=transpose(R);
   export R;
   return(@r);
@@ -1507 +1507 @@
 //----------------------------------------------------------
 static proc exControl2()
-{ 
+{
   ring @r=0,(s1,s2,s3),dp;
   module R=[0,-s3,s2],
            [s3,0,-s1],
            [-s2,s1,0];
-  R=transpose(R);          
+  R=transpose(R);
   export R;
-  return(@r); 
+  return(@r);
 };
 //----------------------------------------------------------
@@ -1530 +1530 @@
   R=transpose(R);
   export R;
-  return(@r);  
+  return(@r);
 };
 
@@ -1540 +1540 @@
   module R =
   [D(2)^2+D(3)^2-D(4)^2, D(1)^2, D(1)^2, -D(1)^2, -2*D(1)*D(2), 0, 0, -2*D(1)*D(3), 0, 2*D(1)*D(4)],
-  [D(2)^2, D(1)^2+D(3)^2-D(4)^2, D(2)^2, -D(2)^2, -2*D(1)*D(2), -2*D(2)*D(3), 0, 0, 2*D(2)*D(4), 0], 
+  [D(2)^2, D(1)^2+D(3)^2-D(4)^2, D(2)^2, -D(2)^2, -2*D(1)*D(2), -2*D(2)*D(3), 0, 0, 2*D(2)*D(4), 0],
   [D(3)^2, D(3)^2, D(1)^2+D(2)^2-D(4)^2, -D(3)^2, 0, -2*D(2)*D(3), 2*D(3)*D(4), -2*D(1)*D(3), 0, 0],
   [D(4)^2, D(4)^2, D(4)^2, D(1)^2+D(2)^2+D(3)^2, 0, 0, -2*D(3)*D(4), 0, -2*D(2)*D(4), -2*D(1)*D(4)],
@@ -1547 +1547 @@
   [D(3)*D(4), D(3)*D(4), 0, 0, 0, -D(2)*D(4), D(1)^2+D(2)^2, -D(1)*D(4), -D(2)*D(3), -D(1)*D(3)],
   [0, D(1)*D(3), 0, -D(1)*D(3), -D(2)*D(3), -D(1)*D(2), D(1)*D(4), D(2)^2-D(4)^2, 0, D(3)*D(4)],
-  [D(2)*D(4), 0, D(2)*D(4), 0, -D(1)*D(4), -D(3)*D(4), -D(2)*D(3), 0, D(1)^2+D(3)^2, -D(1)*D(2)], 
+  [D(2)*D(4), 0, D(2)*D(4), 0, -D(1)*D(4), -D(3)*D(4), -D(2)*D(3), 0, D(1)^2+D(3)^2, -D(1)*D(2)],
   [0, D(1)*D(4), D(1)*D(4), 0, -D(2)*D(4), 0, -D(1)*D(3), -D(3)*D(4), -D(1)*D(2), D(2)^2+D(3)^2];
 
   R=transpose(R);
   export R;
-  return(@r);  
+  return(@r);
 };
 
@@ -1561 +1561 @@
   module R;
   R = [D1, -D1*delta, -1], [2*D1*delta, -D1-D1*delta^2, 0];
-  
+
   R=transpose(R);
   export R;
-  return(@r);  
+  return(@r);
 };
 
 //----------------------------------------------------------
 static proc exTwoPendula()
-{  
+{
   ring @r=(0,m1,m2,M,g,L1,L2),Dt,dp;
-  module R = [m1*L1*Dt^2, m2*L2*Dt^2, -1, (M+m1+m2)*Dt^2], 
+  module R = [m1*L1*Dt^2, m2*L2*Dt^2, -1, (M+m1+m2)*Dt^2],
              [m1*L1^2*Dt^2-m1*L1*g, 0, 0, m1*L1*Dt^2],
              [0, m2*L2^2*Dt^2-m2*L2*g, 0, m2*L2*Dt^2];
@@ -1577 +1577 @@
   R=transpose(R);
   export R;
-  return(@r);  
+  return(@r);
 };
 //----------------------------------------------------------
 static proc exWindTunnel()
-{ 
+{
   ring @r = (0,a, omega, zeta, k),(D1, delta),dp;
   module R = [D1+a, -k*a*delta, 0, 0],
@@ -1589 +1589 @@
   R=transpose(R);
   export R;
-  return(@r);  
+  return(@r);
 };
 
@@ -1596 +1596 @@
 proc declare(string NameOfRing, string Variables, list #)
 "USAGE: declare(NameOfRing, Variables,[Parameters, Ordering]);  where
-@*         NameOfRing is string with name of ring, 
+@*         NameOfRing is string with name of ring,
 @*         Variables is a string with names of variables separated by commas (e.g. \"x,y,z\"),
-@*          Parameters is string of parameters in the ring separated by commas (e.g. \"a,b,c\"),
-@*          Ordering is   string with name of ordering (by default, the ordering (dp,C) is used).
+@*            Parameters is string of parameters in the ring separated by commas (e.g. \"a,b,c\"),
+@*            Ordering is   string with name of ordering (by default, the ordering (dp,C) is used).
 PURPOSE: define the ring easily
 RETURN:  no return value
-EXAMPLE:  example declare; shows an example 
+EXAMPLE:  example declare; shows an example
 "
 {
@@ -1616 +1616 @@
      }
      else
-     { 
+     {
        if( (size(#[1])!=0)&&(#[1]!=" ") )
        {
@@ -1623 +1623 @@
        else
        {
-         execute( "ring " + NameOfRing + "=0,("+Variables+"),("+#[2]+");" ); 
+         execute( "ring " + NameOfRing + "=0,("+Variables+"),("+#[2]+");" );
        };
      };
@@ -1658 +1658 @@
 // maybe reasonable to add this in declare
 //
-//  print("Please enter your representation matrix in the following form: 
+//  print("Please enter your representation matrix in the following form:
 //  module R=[1st row],[2nd row],...");
 //  print("Type the command: R=transpose(R)");

Singular/LIB/deform.lib

@@ -1 @@
-// $Id: deform.lib,v 1.34 2005-04-28 15:12:24 Singular Exp $
+// $Id: deform.lib,v 1.35 2005-05-06 14:38:14 hannes Exp $
 // author: Bernd Martin email: martin@math.tu-cottbus.de
 //(bm, last modified 4/98)
 ///////////////////////////////////////////////////////////////////////////////
-version="$Id: deform.lib,v 1.34 2005-04-28 15:12:24 Singular Exp $";
+version="$Id: deform.lib,v 1.35 2005-05-06 14:38:14 hannes Exp $";
 category="Singularities";
 info="
@@ -28 +28 @@
 RETURN: list L of 4 rings:
          L[1] extending the basering Po by new variables given by
-          \"A,B,..\" (deformation parameters); the new variables precede 
+          \"A,B,..\" (deformation parameters); the new variables precede
          the old ones, the ordering is the product of \"ls\" and \"ord(Po)\" @*
          L[2] = L[1]/Fo extending Qo=Po/Fo, @*
@@ -40 +40 @@
       If d is defined (!=0), it computes up to degree d.
       @*If 'any' is defined and any[1] is no string, interactive version.
-      @*Otherwise 'any' is interpreted as a list of predefined strings: 
+      @*Otherwise 'any' is interpreted as a list of predefined strings:
       \"my\",\"param\",\"order\",\"out\": @*
-      (\"my\" internal prefix, \"param\" is a letter (e.g. \"A\") for the 
-      name of the first parameter or (e.g. \"A(\") for index parameter 
-      variables, \"order\" ordering string for ring extension), \"out\" name 
-      of output file). 
+      (\"my\" internal prefix, \"param\" is a letter (e.g. \"A\") for the
+      name of the first parameter or (e.g. \"A(\") for index parameter
+      variables, \"order\" ordering string for ring extension), \"out\" name
+      of output file).
 NOTE:   printlevel < 0        no additional output,
         printlevel >=0,1,2,.. informs you, what is going on;
@@ -291 +291 @@
    list L=versal(Fo);
    L;
-   def Px=L[1]; 
+   def Px=L[1];
    setring Px;
    // ___ Equations of miniversal base space ___:
@@ -305 +305 @@
 RETURN:  list L of 4 rings:
          L[1] extending the basering Po by new variables given by
-          \"A,B,..\" (deformation parameters); the new variables precede 
+          \"A,B,..\" (deformation parameters); the new variables precede
          the old ones, the ordering is the product of \"ls\" and \"ord(Po)\" @*
          L[2] = L[1]/Io extending Qo, @*
@@ -313 +313 @@
          @*Js  = giving the versal base space (obstructions),
          @*Fs  = giving the versal family of Mo,
-         @*Rs  = giving the lifting of syzygies Lo=syz(Mo).   
+         @*Rs  = giving the lifting of syzygies Lo=syz(Mo).
       If d is defined (!=0), it computes up to degree d.
       @*If 'any' is defined and any[1] is no string, interactive version.
-      @*Otherwise 'any' is interpreted as a list of predefined strings: 
+      @*Otherwise 'any' is interpreted as a list of predefined strings:
       \"my\",\"param\",\"order\",\"out\": @*
-      (\"my\" internal prefix, \"param\" is a letter (e.g. \"A\") for the 
-      name of the first parameter or (e.g. \"A(\") for index parameter 
-      variables, \"order\" ordering string for ring extension), \"out\" name 
-      of output file). 
+      (\"my\" internal prefix, \"param\" is a letter (e.g. \"A\") for the
+      name of the first parameter or (e.g. \"A(\") for index parameter
+      variables, \"order\" ordering string for ring extension), \"out\" name
+      of output file).
 NOTE:   printlevel < 0        no additional output,
         printlevel >=0,1,2,.. informs you, what is going on,
@@ -662 +662 @@
    def my_Px=extendring(e1,my_var,my_ord);
    setring my_Px;
-   ideal Io  = imap(Po,Io);         
+   ideal Io  = imap(Po,Io);
    attrib(Io,"isSB",1);
    qring my_Qx = Io;
@@ -841 +841 @@
     t1=size(vvvv);
 // ==========================================================
-    
+
     int l,l1;
     for (l=1;l<=t1;l=l+1)
@@ -927 +927 @@
     if (size(tv)>1)
     { k = tv[2];
-      tv = tv[2..size(tv)]; 
+      tv = tv[2..size(tv)];
       tv = tv -k;
       if (tv==0) { @nv = @nv+string(-k)+",";}

Singular/LIB/digimult.lib

@@ -1 +1 @@
 ///////////////////////////////////////////////////////////////////////////////
-version="$Id: digimult.lib,v 1.1 2005-05-04 15:41:12 bricken Exp $";
+version="$Id: digimult.lib,v 1.2 2005-05-06 14:38:17 hannes Exp $";
 category="Logic";
 info="
@@ -7 +7 @@
 
 OVERVIEW:
-        Various algorithms for verifiying digital circuits, including SAT-Solvers
+        Various algorithms for verifiying digital circuits, including SAT-Solvers
 
 PROCEDURES:
@@ -40 +40 @@
     return(poly_cancel_mod_number(f-l,n));
   }
-  
+
   return(l+poly_cancel_mod_number(f-l,n));
 }
@@ -74 +74 @@
     for(j=1;j<=size(l);j++){
       if(i!=j){
-        summand=summand*(var(1)-l[j][1]);
-        
+        summand=summand*(var(1)-l[j][1]);
       }
     }
@@ -163 +162 @@
   j=simplify(j,2);
   j=simplify(j,8);
-  
+
   poly v=var(var_order[1]);
   var_order=delete(var_order,1);
@@ -177 +176 @@
     return(simple_gps(j0,var_order, step));
   }
-  
+
 }

Singular/LIB/equising.lib

@@ -1 @@
-version="$Id: equising.lib,v 1.11 2005-04-25 10:13:06 Singular Exp $";
+version="$Id: equising.lib,v 1.12 2005-05-06 14:38:17 hannes Exp $";
 category="Singularities";
 info="
 LIBRARY:  equising.lib  Equisingularity Stratum of a Family of Plane Curves
-AUTHOR:   Christoph Lossen, lossen@mathematik.uni-kl.de 
+AUTHOR:   Christoph Lossen, lossen@mathematik.uni-kl.de
           Andrea Mindnich, mindnich@mathematik.uni-kl.de
 
 MAIN PROCEDURES:
  tau_es(f);             codim of mu-const stratum in semi-universal def. base
- esIdeal(f);            (Wahl's) equisingularity ideal of f 
+ esIdeal(f);            (Wahl's) equisingularity ideal of f
  esStratum(F[,m,L]);    equisingularity stratum of a family F
  isEquising(F[,m,L]);   tests if a given deformation is equisingular
@@ -55 +55 @@
 static proc m_Jet(poly F,int m);
 {
-  intvec w=xyVector();  
-  poly Fd=jet(F,m,w);  
+  intvec w=xyVector();
+  poly Fd=jet(F,m,w);
   return(Fd);
 }
@@ -63 +63 @@
 ////////////////////////////////////////////////////////////////////////////////
 // computes the 4 control matrices (input is multsequence(L))
-proc control_Matrix(list M); 
+proc control_Matrix(list M);
 "USAGE:   control_Matrix(L); L list
 ASSUME:  L is the output of multsequence(hnexpansion(f)).
 RETURN:  list M of 4 intmat's:
 @format
-  M[1] contains the multiplicities at the respective infinitely near points 
-       p[i,j] (i=step of blowup+1, j=branch) -- if branches j=k,...,k+m pass 
-       through the same p[i,j] then the multiplicity is stored in M[1][k,j], 
-       while M[1][k+1]=...=M[1][k+m]=0.   
-  M[2] contains the number of branches meeting at p[i,j] (again, the information 
-       is stored according to the above rule)   
-  M[3] contains the information about the splitting of M[1][i,j] with respect to 
-       different tangents of branches at p[i,j] (information is stored only for 
-       minimal j>=k corresponding to a new tangent direction). 
-       The entries are the sum of multiplicities of all branches with the 
+  M[1] contains the multiplicities at the respective infinitely near points
+       p[i,j] (i=step of blowup+1, j=branch) -- if branches j=k,...,k+m pass
+       through the same p[i,j] then the multiplicity is stored in M[1][k,j],
+       while M[1][k+1]=...=M[1][k+m]=0.
+  M[2] contains the number of branches meeting at p[i,j] (again, the information
+       is stored according to the above rule)
+  M[3] contains the information about the splitting of M[1][i,j] with respect to
+       different tangents of branches at p[i,j] (information is stored only for
+       minimal j>=k corresponding to a new tangent direction).
+       The entries are the sum of multiplicities of all branches with the
        respective tangent.
-  M[4] contains the maximal sum of higher multiplicities for a branch passing 
-       through p[i,j] ( = degree Bound for blowing up)  
+  M[4] contains the maximal sum of higher multiplicities for a branch passing
+       through p[i,j] ( = degree Bound for blowing up)
 @end format
-NOTE:    the branches are ordered in such a way that only consecutive branches 
+NOTE:    the branches are ordered in such a way that only consecutive branches
          can meet at an infinitely near point. @*
-         the final rows of the matrices M[1],...,M[3] is (1,1,1,...,1), and 
-         correspond to infinitely near points such that the strict transforms 
-         of the branches are smooth and intersect the exceptional divisor 
+         the final rows of the matrices M[1],...,M[3] is (1,1,1,...,1), and
+         correspond to infinitely near points such that the strict transforms
+         of the branches are smooth and intersect the exceptional divisor
          transversally.
 SEE ALSO: multsequence
@@ -96 +96 @@
   dummy=0;
   for (j=1;j<=ncols(M[2]);j++)
-  { 
+  {
     dummy=dummy+M[1][nrows(M[1])-1,j]-M[1][nrows(M[1]),j];
   }
@@ -103 +103 @@
   intmat U[nrows(M[1])+dummy][ncols(M[1])];
   intmat maxDeg[nrows(M[1])+dummy][ncols(M[1])];
-  
+
   for (i=1;i<=nrows(M[2]);i++)
   {
@@ -110 +110 @@
     {
       for (k=dummy;k<dummy+M[2][i,j];k++)
-      { 
-        T[i,dummy]=T[i,dummy]+1; 
-        S[i,dummy]=S[i,dummy]+M[1][i,k]; 
+      {
+        T[i,dummy]=T[i,dummy]+1;
+        S[i,dummy]=S[i,dummy]+M[1][i,k];
         if (i>1)
         {
@@ -127 +127 @@
   {
     for (j=1;j<=ncols(M[2]);j++)
-    { 
-      S[i,j]=1;  
-      T[i,j]=1;  
+    {
+      S[i,j]=1;
+      T[i,j]=1;
       U[i,j]=1;
     }
   }
-  
+
   // Computing the degree Bounds to be stored in M[4]:
   for (i=1;i<=nrows(S);i++)
@@ -141 +141 @@
     {
       for (k=dummy;k<dummy+T[i,j];k++)
-      { 
+      {
         maxDeg[i,k]=S[i,dummy];  // multiplicity at i-th blowup
       }
@@ -147 +147 @@
     }
   }
-  // adding up multiplicities 
-  for (i=nrows(S);i>=2;i--)  
+  // adding up multiplicities
+  for (i=nrows(S);i>=2;i--)
   {
     for (j=1;j<=ncols(S);j++)
@@ -155 +155 @@
     }
   }
-  
+
   list L=S,T,U,maxDeg;
   return(L);
@@ -165 +165 @@
 //  returns list: 1) tangent directions
 //                2) swapping information (x <--> y)
-static proc inf_Tangents(list L,int s); // L aus hnexpansion, 
+static proc inf_Tangents(list L,int s); // L aus hnexpansion,
 {
   int nv=nvars(basering);
@@ -178 +178 @@
     V[k]=L[k][3];  // switch: 0 --> tangent 2nd parameter
                    //         1 --> tangent 1st parameter
-    e=0;    
+    e=0;
     M=L[k][1];
     counter=1;
     B[counter,k]=M[1,1];
-    
+
     for (i=1;i<=nrows(M);i++)
     {
@@ -193 +193 @@
           {
             B[counter,k]=M[i,j];
-            j=ncols(M)+1; // goto new row of HNmatrix... 
+            j=ncols(M)+1; // goto new row of HNmatrix...
             if (counter<>s)
-            { 
+            {
               if (counter+1<=nrows(Mult))
               {
@@ -206 +206 @@
             }
           }
-          else 
+          else
           {
             B[counter,k]=0;
-            j=ncols(M)+1; // goto new row of HNmatrix... 
+            j=ncols(M)+1; // goto new row of HNmatrix...
           }
         }
@@ -215 +215 @@
         {
           if (e<=0)
-          { 
+          {
             B[counter,k]=M[i,j];
           }
@@ -231 +231 @@
           }
         }
-        
-        if (counter==s) // given number of points determined 
+
+        if (counter==s) // given number of points determined
         {
-            j=ncols(M)+1;  
+            j=ncols(M)+1;
             i=nrows(M)+1;
             // leave procedure
@@ -247 +247 @@
 ////////////////////////////////////////////////////////////////////////////////
 // compute "good" upper bound for needed number of help variables
-// 
+//
 static proc Determine_no_b(intmat U,matrix B)
 // U is assumed to be 3rd output of control_Matrix
@@ -265 +265 @@
         }
       }
-      
+
     }
   }
@@ -273 +273 @@
 
 ////////////////////////////////////////////////////////////////////////////////
-// compute number of infinitely near free points corresponding to non-zero 
+// compute number of infinitely near free points corresponding to non-zero
 // entries in control_Matrix[1] (except first row)
-// 
+//
 static proc no_freePoints(intmat Mult,matrix B)
 // Mult is assumed to be 1st output of control_Matrix
@@ -330 +330 @@
 
 ///////////////////////////////////////////////////////////////////////////////
-// 
+//
 // DEFINES: A new basering, "myRing",
 //          with new names for the parameters and variables.
@@ -337 +337 @@
 //          The ring ordering is ordStr.
 // NOTE:    This proc uses 'execute'.
-static proc createMyRing_new(poly p_F, string ordStr, 
-                                string minPolyStr, int no_b) 
+static proc createMyRing_new(poly p_F, string ordStr,
+                                string minPolyStr, int no_b)
 {
   def r_old = basering;
@@ -393 +393 @@
   export p_F,mIdeal;
 
-  // Extension by no_b auxiliary variables 
+  // Extension by no_b auxiliary variables
   if (no_b>0)
   {
@@ -401 +401 @@
       helpStr = "ring myRing ="
                 + string(chara)+ ", (b(1..no_b), t(1..nDefParams), x, y),"
-                + ordStr +";"; 
+                + ordStr +";";
       execute(helpStr);
     }
@@ -419 +419 @@
 
           helpStr = "minpoly =" + minPolyStr + ";";
-          execute (helpStr);  
+          execute (helpStr);
         }
         else // no minpoly given
-        {  
+        {
           ordStr = "(dp(" + string(no_b) + ")," + ordStr + ")";
           helpStr = "ring myRing =
@@ -441 +441 @@
     }
     ideal qIdeal = imap(myRing1, qIdeal);
-  
+
     if(qIdeal != 0)
     {
@@ -455 +455 @@
     kill myRing1;
   }
-  else 
-  { 
+  else
+  {
     if(qIdeal != 0)
     {
@@ -471 +471 @@
       def myRing=myRing1;
     }
-    kill myRing1;    
-  }
-  
+    kill myRing1;
+  }
+
   setring r_old;
   return(myRing);
@@ -479 +479 @@
 
 ////////////////////////////////////////////////////////////////////////////////
-// returns list of coef, leadmonomial  
+// returns list of coef, leadmonomial
 //
 static proc determine_coef (poly Fm)
@@ -532 +532 @@
   kill myRing1;
   def M=coef(Fm,xy);
-  
+
   for (i=1; i<=ncols(M); i++)
   {
@@ -578 +578 @@
 
 ////////////////////////////////////////////////////////////////////////////////
-static proc make_ring_small(ideal J) 
-// returns varstr for new ring, the map and the number of vars 
+static proc make_ring_small(ideal J)
+// returns varstr for new ring, the map and the number of vars
 {
   attrib(J,"isSB",1);
-  int counter=0; 
+  int counter=0;
   ideal newmap;
   string newvar="";
@@ -590 +590 @@
     {
       newmap[i]=var(i);
-      
+
       if (newvar=="")
       {
         newvar=newvar+string(var(i));
-        counter=counter+1;       
+        counter=counter+1;
       }
       else
       {
         newvar=newvar+","+string(var(i));
-        counter=counter+1;       
-      }
-    }
-    else 
+        counter=counter+1;
+      }
+    }
+    else
     {
       newmap[i]=0;
-    }  
+    }
   }
   list L=newvar,newmap,counter;
@@ -626 +626 @@
   int auxVar=1;
   int nVars;
-  
+
   intvec upper_bound, upper_bound_old, fertig, soll;
   list blowup_string;
@@ -643 +643 @@
     {
       option(set,ov);
-      return(1);  
+      return(1);
     }
     else
@@ -658 +658 @@
       def artin_bd=#[1];  // compute modulo maxideal(artin_bd)
       if (artin_bd <= 1)
-      { 
+      {
         print("Do you really want to compute over Basering/maxideal("
               +string(artin_bd)+") ?");
@@ -665 +665 @@
         {
           option(set,ov);
-          return(1);  
+          return(1);
         }
         else
@@ -674 +674 @@
       }
       if (size(#)>1)
-      { 
+      {
         if (typeof(#[2])=="list")
         {
           def @L=#[2];  // is assumed to be the Hamburger-Noether matrix
         }
-      }      
+      }
     }
     else
@@ -710 +710 @@
     poly f=phi(p_F);
 
-    // Heuristics: if x,y are transversal parameters then computation of HNE 
-    // can be much faster when exchanging variables...! 
+    // Heuristics: if x,y are transversal parameters then computation of HNE
+    // can be much faster when exchanging variables...!
     if (2*size(coeffs(f,x))<size(coeffs(f,y)))
     {
@@ -717 +717 @@
       f=swapXY(f);
     }
-    
+
     int error=checkPoly(f);
     if (error)
@@ -726 +726 @@
         print("Return value (=0) has no meaning!");
         option(set,ov);
-        return(0);  
+        return(0);
       }
       else
-      { 
+      {
         option(set,ov);
         return(list( ideal(0),error));
       }
     }
-    
+
     dbprint(i_print,"// ");
     dbprint(i_print,"// Compute HN expansion");
@@ -740 +740 @@
     i=printlevel;
     printlevel=printlevel-5;
-    list LLL=hnexpansion(f); 
+    list LLL=hnexpansion(f);
 
     if (size(LLL)==0) { // empty list returned by hnexpansion
       setring old_ring;
-      print(i_print,"Unable to compute HN expansion !");      
+      print(i_print,"Unable to compute HN expansion !");
       if (typ==1) //isEquising
       {
         print("Return value (=0) has no meaning!");
         option(set,ov);
-        return(0);  
+        return(0);
       }
       else
@@ -762 +762 @@
     {
       if (typeof(LLL[1])=="ring") {
-        def HNering = LLL[1]; 
-        setring HNering; 
+        def HNering = LLL[1];
+        setring HNering;
         def @L=stripHNE(hne);
       }
@@ -776 +776 @@
   def HNEring=basering;
   list M=multsequence(@L);
-  M=control_Matrix(M);     // this returns the 4 control matrices  
+  M=control_Matrix(M);     // this returns the 4 control matrices
   def maxDeg=M[4];
 
@@ -792 +792 @@
 
   // Determine maximal number of needed auxiliary parameters (free tangents):
-  no_b=Determine_no_b(M[3],B);  
+  no_b=Determine_no_b(M[3],B);
 
   // test whether HNexpansion needed field extension....
@@ -817 +817 @@
   number_of_branches=ncols(M[1]);
   for (i=1;i<=number_of_branches;i++)
-  { 
+  {
     poly F(i);
-    ideal bl_Map(i);  
+    ideal bl_Map(i);
   }
   upper_bound[number_of_branches]=0;
@@ -829 +829 @@
   // Hole:  B = matrix of blowup points
   if (ring_is_changed==0) { matrix B=hole(B); }
-  else                    { matrix B=imap(HNEring,B); } 
+  else                    { matrix B=imap(HNEring,B); }
   m=M[1][blowup,branch];    // multiplicity at 0
-   
+
   // now, we start by checking equimultiplicity along trivial section
   poly Fm=m_Jet(p_F,m-1);