Changeset 82716e in git

Timestamp:

May 14, 1998, 8:45:19 PM (25 years ago)

Author:

Hans Schönemann <hannes@…>

Branches:

(u'spielwiese', '8e0ad00ce244dfd0756200662572aef8402f13d5')

Children:

68e324ca946be87c2ab75edd4cc0fd161e1f6ead

Parents:

30c91fe3835d6ff4504cc9ddeeb5866465754c2a

Message:

*hannes: typos in the info-help-string


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

Location:

Singular/LIB

Files:

• all.lib (modified) (2 diffs)
• classify.lib (modified) (97 diffs)
• deform.lib (modified) (63 diffs)
• factor.lib (modified) (4 diffs)
• fastsolv.lib (modified) (1 diff)
• finvar.lib (modified) (3 diffs)
• general.lib (modified) (7 diffs)
• hnoether.lib (modified) (24 diffs)
• inout.lib (modified) (2 diffs)
• invar.lib (modified) (39 diffs)
• makedbm.lib (modified) (4 diffs)
• matrix.lib (modified) (3 diffs)
• normal.lib (modified) (57 diffs)
• poly.lib (modified) (7 diffs)
• presolve.lib (modified) (75 diffs)
• primdec.lib (modified) (74 diffs)
• primitiv.lib (modified) (3 diffs)
• sing.lib (modified) (8 diffs)
• standard.lib (modified) (1 diff)
• tex.lib (modified) (79 diffs)
• tst.lib (modified) (10 diffs)

Singular/LIB/all.lib

@@ -1 @@
-// $Id: all.lib,v 1.10 1998-05-14 18:26:51 Singular Exp $
+// $Id: all.lib,v 1.11 1998-05-14 18:44:54 Singular Exp $
 ///////////////////////////////////////////////////////////////////////////////
 
-version="$Id: all.lib,v 1.10 1998-05-14 18:26:51 Singular Exp $";
+version="$Id: all.lib,v 1.11 1998-05-14 18:44:54 Singular Exp $";
 info="
 LIBRARY:  all.lib   Load all libraries
-          
-  classify.lib  PROCEDURES FOR THE ARNOLD-CLASSIFIER OF SINGULARITIES  
+
+  classify.lib  PROCEDURES FOR THE ARNOLD-CLASSIFIER OF SINGULARITIES
   deform.lib    PROCEDURES FOR COMPUTING MINIVERSAL DEFORMATION
   elim.lib      PROCEDURES FOR ELIMINATION, SATURATION AND BLOWING UP
@@ -15 +15 @@
   graphics.lib  PROCEDURES TO DRAW WITH MATHEMATICA
   hnoether.lib  PROCEDURES FOR THE HAMBURGER-NOETHER-DEVELOPMENT
-  homolog.lib   PROCEDURES FOR HOMOLOGICAL ALGEBRA 
+  homolog.lib   PROCEDURES FOR HOMOLOGICAL ALGEBRA
   inout.lib     PROCEDURES FOR MANIPULATING IN- AND OUTPUT
   invar.lib     PROCEDURES FOR COMPUTING INVARIANTS OF (C,+)-ACTIONS
   matrix.lib    PROCEDURES FOR MATRIX OPERATIONS
   normal.lib    PROCEDURES FOR COMPUTING THE NORMALIZATION
-  poly.lib      PROCEDURES FOR MANIPULATING POLYS, IDEALS, MODULES        
+  poly.lib      PROCEDURES FOR MANIPULATING POLYS, IDEALS, MODULES
   presolve.lib  PROCEDURES FOR PRE-SOLVING POLYNOMIAL EQUATIONS
   primdec.lib   PROCEDURES FOR PRIMARY DECOMPOSITION

Singular/LIB/classify.lib

@@ -1 @@
-// $Id: classify.lib,v 1.24 1998-05-14 12:49:29 krueger Exp $
-///////////////////////////////////////////////////////////////////////////////
-
-version  =       "$Id: classify.lib,v 1.24 1998-05-14 12:49:29 krueger Exp $";
+// $Id: classify.lib,v 1.25 1998-05-14 18:44:55 Singular Exp $
+///////////////////////////////////////////////////////////////////////////////
+
+version  = "$Id: classify.lib,v 1.25 1998-05-14 18:44:55 Singular Exp $";
 info="
-LIBRARY:  classify.lib  PROCEDURES FOR THE ARNOLD-CLASSIFIER OF SINGULARITIES  
+LIBRARY:  classify.lib  PROCEDURES FOR THE ARNOLD-CLASSIFIER OF SINGULARITIES
 
    A library for classifying isolated hypersurface singularities w.r.t. right
@@ -13 +13 @@
 basicinvariants(f);  computes Milnor number, determinacy-bound and corank of f
 classify(f);         normal form of poly f determined with Arnold's method
-corank(f);           computes the corank of f (i.e. of the Hessian of f) 
-Hcode(v);            coding of intvec v acoording to the number repetitions 
-init_debug([n]);     print trace and debugging information depending on int n  
-internalfunctions(); display names of internal procedures of this library 
+corank(f);           computes the corank of f (i.e. of the Hessian of f)
+Hcode(v);            coding of intvec v acoording to the number repetitions
+init_debug([n]);     print trace and debugging information depending on int n
+internalfunctions(); display names of internal procedures of this library
 milnorcode(f[,e]);   Hilbert poly of [e-th] Milnor algebra coded with Hcode
 morsesplit(f);       residual part of f after applying the splitting lemma
@@ -54 +54 @@
 "USAGE:    classify(f);  f=poly
 COMPUTE:  normal form and singularity type of f with respect to right
-          equivalence, as given in the book \"Singularities of 
+          equivalence, as given in the book \"Singularities of
           differentiables maps, Volume I\" by V.I. Arnold, S.M. Gusein-Zade,
           A.N. Varchenko
@@ -63 +63 @@
           Updates can be found under:
           URL=http://www.mathematik.uni-kl.de/~krueger/Singular/
-NOTE:     type init_debug(n); (0 <= n <= 10) in order to get intermediate 
+NOTE:     type init_debug(n); (0 <= n <= 10) in order to get intermediate
           information, higher values of n give more information.
           The proc creates several global objects with names all starting
-          with @, hence there should be no name conflicts 
+          with @, hence there should be no name conflicts
 EXAMPLE:  example classify; shows an example"
 {
@@ -74 +74 @@
   string s2;
   list   v;
-  def ring_ext = basering; 
+  def ring_ext = basering;
 
   init_debug();                    // initialize trace/debug mode
@@ -96 +96 @@
 
 //---------------- collect results and create return-value --------------------
-  if( s2=="error!" || s2=="NoClass") { 
+  if( s2=="error!" || s2=="NoClass") {
       setring ring_ext;
       return(f_in);
@@ -125 +125 @@
 static
 proc Klassifiziere (poly f)
-{ 
+{
 //--------------------------- initialisation ----------------------------------
     string s1;
@@ -131 +131 @@
     list   v, cstn;
     map    PhiG;
-    def ring_top = basering; 
+    def ring_top = basering;
 
     n = nvars(basering);    // Zahl der Variablen des aktuellen Rings.
     PhiG = ring_top, maxideal(1);
     cstn[4] = PhiG;
-    if( defined(@ringdisplay) == 0) { 
+    if( defined(@ringdisplay) == 0) {
       string @ringdisplay;               // Define always 'ringdisplay' to be
       export @ringdisplay;               // able to run 'Show(f)'
@@ -147 +147 @@
 
 //---------------------- compute basciinvariants ------------------------------
-    if(jet(f,0) != 0 ) { 
+    if(jet(f,0) != 0 ) {
       cstn[1] = corank(f); cstn[2]=-1; cstn[3]=1;
       return(printresult(1, f, "a unit", cstn, -1));
@@ -162 +162 @@
     cstn[3] = K;
 
-    if( Mu == 0) { 
+    if( Mu == 0) {
       cstn[1]=1; cstn[3]=1;
       return(printresult(1, f, "A[0]", cstn, 0)); }
@@ -175 +175 @@
     v = HKclass(milnorcode(f));
     if(v[2]>0) { debug_log(0, "Guessing type via Milnorcode: ", v[1]);}
-    else { 
+    else {
       debug_log(0, "Hilbert polynomial not recognised. Milnor code = ",
                 milnorcode(f));
@@ -183 +183 @@
 
 //------------ step 1, classification according to corank(f) ------------------
-    if(corank_f == 0) { 
+    if(corank_f == 0) {
        return(printresult(2, f, "A["+string(Mu)+"]", cstn, 0)); }
-    if(corank_f == 1) { 
+    if(corank_f == 1) {
        return(printresult(2, f, "A["+string(Mu)+"]", cstn, 0)); }
     cstn[4] = 0;
@@ -204 +204 @@
    string s1;
    list   v_res, v_class, v, iv;
-  
+
    corank = cstn[1];
    K = cstn[3];
@@ -211 +211 @@
 //-------------------- apply morsesplit if n>corank ---------------------------
    if( n > corank) {
-     debug_log(0, 
+     debug_log(0,
       "I have to apply the splitting lemma. This will take some time....:-)");
      v_res = Morse(f, K, corank, 0);
@@ -223 +223 @@
      if(defined(RingB) != 0 ) { kill RingB; }
      ring ring_rest=char(basering),(x(1..corank)),(c,ds);
-  
+
      map MapReduce=ring_top,maxideal(1);
      poly G = MapReduce(g);
      map PhiG=ring_top,maxideal(1);// Konstruiere Id auf r
      PhiG = MapReduce(PhiG);
-  
+
      execute("ring RingB="+charstr(basering)+",("+A_Z("x",corank)+"),(c,ds);");
      export RingB;
      setring ring_rest;
    }
-   else { 
+   else {
      ring ring_rest=char(basering),(x(1..corank)),(c,ds);
      map  PhiG=ring_top,maxideal(1);
      poly G = PhiG(f);
    }
-  
+
 //--------------------- step 1 of Arnold now finished -------------------------
     map phi = ring_rest,maxideal(1);
@@ -263 +263 @@
 static
 proc Funktion3 (poly f, list cstn)
-{ 
+{
 //---------------------------- initialisation ---------------------------------
     poly f3 = jet(f, 3);
@@ -282 +282 @@
       if( Mult == 1) { return(printresult(5,f,"D["+string(Mu)+"]", cstn, 0)); }
       if( Mult == 2) { return(Funktion6(f, cstn));}         // series E,J
-      debug_log(0, "dimension 1 und deg != 1, 2 => error, ", 
+      debug_log(0, "dimension 1 und deg != 1, 2 => error, ",
                         "this should never occur");
       return(printresult(3, f, "error!", cstn, -1));
@@ -351 +351 @@
         if(Dim==0) { return(printresult(11,f,"J["+string(k)+",0]",cstn,k-1)); }
         Mult = mult(Jf);
-        if( Dim ==1  && Mult==1) { 
+        if( Dim ==1  && Mult==1) {
           return(printresult(12,f,"J["+string(k)+","+string(Mu - 6*k +2)+"]",
                  cstn, k-1));
@@ -373 +373 @@
 static
 proc Funktion13 (poly f, list cstn)
-{ 
+{
 //---------------------------- initialisation ---------------------------------
     poly f4;
@@ -391 +391 @@
     Mult = mult(Jf);
     if( Dim == 1) {
-      if( Mult == 1 ) { 
-        return(printresult(15, f, 
+      if( Mult == 1 ) {
+        return(printresult(15, f,
               "X[1,"+string(Mu-9)+"] = T[2,4,"+string(Mu-5)+"]", cstn, 1));
       }
@@ -403 +403 @@
       }
       if( Mult == 3 ) { return(Funktion25(f, cstn)); }
-    } 
+    }
     // Should never reach this line
     return(printresult(13, f, "error!", cstn, -1));
@@ -441 +441 @@
       JetId = x(1)^3*x(2) + x(2)^(3*p+2);     // check jet x3y,y3k+2  : Z[6p+5]
       fk = jet(f, 3*(3*p+2), weight(JetId));
-      if( Coeff(fk, x(2), x(2)^(3*p+2)) != 0) { 
+      if( Coeff(fk, x(2), x(2)^(3*p+2)) != 0) {
         return(printresult(19,f, "Z["+string(6*p+5)+"]", cstn, p));
       }
@@ -447 +447 @@
       JetId = x(1)^3*x(2)+x(1)*x(2)^(2*p+2);  // check jet x3y,xy2k+2 : Z[6p+6]
       fk = jet(f, 2*(3*p+2)+1, weight(JetId));
-      if( Coeff(fk, x(1)*x(2), x(1)*x(2)^(2*p+2)) != 0) { 
+      if( Coeff(fk, x(1)*x(2), x(1)*x(2)^(2*p+2)) != 0) {
         return(printresult(20, f, "Z["+string(6*p+6)+"]", cstn, p));
       }
@@ -466 +466 @@
       Mult = mult(Jf);
       if(Dim==0) { return(printresult(23,f,"Z["+string(p-1)+",0]", cstn, p)); }
-      if( Mult == 1 ) { 
-         return(printresult(24, f, "Z["+string(p-1)+","+string(Mu-3-6*p)+"]", 
+      if( Mult == 1 ) {
+         return(printresult(24, f, "Z["+string(p-1)+","+string(Mu-3-6*p)+"]",
                 cstn, p));
       }
@@ -518 +518 @@
       JetId = x(1)^4 + x(2)^(4*k+2);
       fk    = jet(f, 2*(4*k+2), weight(JetId));
-      if( Coeff(fk, x(2), x(2)^(4*k+2)) != 0) { 
+      if( Coeff(fk, x(2), x(2)^(4*k+2)) != 0) {
         Jf  = std(jacob(fk));
         Dim = dim(Jf);
         if(Dim==0) {return(printresult(30,f,"W["+string(k)+",0]",cstn,3*k-1));}
-        if(Dim==1) { 
-           return(printresult(32, f, 
+        if(Dim==1) {
+           return(printresult(32, f,
                   "W#["+string(k)+","+string(Mu-12*k-2)+"]", cstn, 3*k-1));
         }
@@ -533 +533 @@
         Jf  = std(jacob(ft));
         Dim = dim(Jf);
-        if( Dim == 0 ) { 
+        if( Dim == 0 ) {
            return(printresult(31, f, "W["+string(k)+","+string(Mu-12*k-3)+"]",
                   cstn, 3*k-1));
@@ -560 +560 @@
         Mult  = mult(Jf);
         if(Dim==0) {return(printresult(37,f,"X["+string(k)+",0]",cstn,3*k-1));}
-        if(Dim==1) { 
-          if(Mult==1) { 
+        if(Dim==1) {
+          if(Mult==1) {
              return(printresult(38, f,"X["+string(k)+","+string(Mu-12*k+3)+"]",
                     cstn, 3*k-1));
           }
-          if(Mult==2) { 
+          if(Mult==2) {
             ft  = Teile(fk, x(1)^2);
             Jf  = std(jacob(ft));
@@ -574 +574 @@
             }
           }
-          if(Mult!=3) { 
+          if(Mult!=3) {
             return(printresult(36, f, "error!", cstn, -1)); }
         }
@@ -618 +618 @@
     r   = kr-k;
     setring ring_top;
-    if( Typ == "E[6k]" ) { 
-       return(printresult(42, f, "Z["+string(k)+","+string(12*k+6*r-1)+"]", 
+    if( Typ == "E[6k]" ) {
+       return(printresult(42, f, "Z["+string(k)+","+string(12*k+6*r-1)+"]",
               cstn, 3*k+r-2));
     }
-    if( Typ == "E[6k+1]" ) { 
+    if( Typ == "E[6k+1]" ) {
        return(printresult(43, f, "Z["+string(k)+","+string(12*k+6*r)+"]",
               cstn, 3*k+r-2));
@@ -645 +645 @@
 static
 proc Funktion50 (poly f, list cstn)
-{ 
+{
 //---------------------------- initialisation ---------------------------------
     poly  f3;
@@ -655 +655 @@
     if( f3 == 0 ) { return(printresult(104, f, "NoClass", cstn, -1)); }
 
-    // f3 ~ 
+    // f3 ~
     Jf1  = jacob(f3);
     Jf   = std(Jf1);
@@ -662 +662 @@
     Mu   = cstn[2];
 
-    if(Dim == 0) { 
+    if(Dim == 0) {
        return(printresult(51, f, "P[8] = T[3,3,3]", cstn, 1));
     } // x3 + y3 + z3 + axyz
-    if(Dim == 1) { 
+    if(Dim == 1) {
       if (Mult == 1) {
         return(printresult(52, f,"P["+string(Mu)+"] = T[3,3,"+string(Mu-5)+"]",
@@ -725 +725 @@
     M    = J1;
     J2   = minor(M, 2), S;
- 
+
     //------------------ determine coordinate named 'x' -----------------------
     S  = sat(J2, maxideal(1))[1];
@@ -741 +741 @@
     debug_log(6, "f3,s1=", Show(f3));
     if( b1 != 0) {
-      VERT=ring_top,-1*b1*x(1), -1*b2*x(1)+x(2), -1*b3*x(1) + x(3); 
+      VERT=ring_top,-1*b1*x(1), -1*b2*x(1)+x(2), -1*b3*x(1) + x(3);
       kx=1; ky=2; kz=3;
     }
@@ -765 +765 @@
     //---------------- compute f_2 such that j3f = xf_2+f_3 -------------------
     debug_log(6, "1) x=", kx, "  y=", ky, "  z=", kz );
-    matrix C = Coeffs(f3, x(kx)); 
+    matrix C = Coeffs(f3, x(kx));
     fb=C[2,1];  // Coeff von x^1
     fc=C[1,1];  // Coeff von x^0
@@ -776 +776 @@
         b = Coeff(Relation, x(kz), x(kz));
         B[rvar(x(ky))] = x(ky)-b*x(kz);
-      } 
+      }
       else {
         Jfsyz = fb, diff(fb, x(kz));
@@ -791 +791 @@
       f3 = jet(f,3);
       kill Mat;
-    } 
+    }
     else { ky,kz = swap(ky,kz); }
 
     //------- compute tschirnhaus for 'z' and get f3=f_1(x,y,z)y^2+z^3 --------
-    C    = Coeffs(f3, x(kx)); 
+    C    = Coeffs(f3, x(kx));
     fb   = C[2,1];  // Coeff von x^1
     fc   = C[1,1];  // Coeff von x^0
@@ -804 +804 @@
     cstn[4] = PhiG;
     f3 = jet(f,3);
-  
+
     //------------------- compute f_1 and get f3=xy^2+z^3 ---------------------
     fb = (f3 - 1*(Coeffs(f3, x(kz))[4,1])*x(kz)^3)/(x(ky)^2);
@@ -820 +820 @@
 
     //--------------------- permutation of x,y,z  -----------------------------
-    if(Coeffs(f3, x(1))[4,1]!=0) { 
+    if(Coeffs(f3, x(1))[4,1]!=0) {
       kx=1;
       if(Coeffs(f3, x(2))[3,1]==0) { ky=2; kz=3; }
@@ -826 +826 @@
     }
     else {
-      if(Coeffs(f3, x(2))[4,1]!=0) { 
+      if(Coeffs(f3, x(2))[4,1]!=0) {
         kx=2;
         if(Coeffs(f3, x(3))[3,1]==0) { ky=3; kz=1; }
         else { ky=1; kz=3; }
       }
-      else { 
+      else {
         kx=3;
         if(Coeffs(f3, x(1))[3,1]==0) { ky=1; kz=2; }
@@ -902 +902 @@
       Mult  = mult(JetId);
       if(Dim==0) { return(printresult(64, f, "Q["+string(p)+",0]", cstn, p)); }
-      if(Dim==1) { 
+      if(Dim==1) {
         if(Mult == 1) {
            return(printresult(65, f, "Q["+string(p)+","+string(Mu-(6*p+2))+"]",
                   cstn, p));
         }
-        if(Mult == 2) { 
+        if(Mult == 2) {
           fk    = jet(fr, 3*w[1], w);
           f_tmp = Coeffs(phi, x(1))[4,1] *x(1)^3+fk;
@@ -1013 +1013 @@
 
 //------------ find coordinatechange for f3 ~ x3+xz2, if possible  ------------
-    matrix C = coeffs(f3, x(kx)); 
+    matrix C = coeffs(f3, x(kx));
     if(size(C) == 3) { C = coeffs(f3, x(kz)); kx,kz=swap(kx, kz); }
     if(C[1,1] == 0 && C[3,1] == 0) { Fall = 1; }
@@ -1023 +1023 @@
       VERT=ring_top,x(kx),x(ky),x(kz);
     }
-    if(Fall == 2) { 
+    if(Fall == 2) {
        v = tschirnhaus(f3/x(kz), x(kx));
        b1, VERT = [1..2];
     }
-    if(Fall == 3) { 
+    if(Fall == 3) {
       v = tschirnhaus(f3/x(kx), x(kx));
       b1, VERT = [1..2];
@@ -1041 +1041 @@
 
 //------------- if f3 ~ x3+xz2 then continue with classification  -------------
-    C = coeffs(f3, x(1)); 
-    if( C[1,1] == 0 && C[2,1] != 0 && C[3,1] == 0 && C[4,1] != 0 ) { 
+    C = coeffs(f3, x(1));
+    if( C[1,1] == 0 && C[2,1] != 0 && C[3,1] == 0 && C[4,1] != 0 ) {
       return(Funktion83(f, cstn));
     }
@@ -1155 +1155 @@
       if ( Dim == 1 ) {
         if ( Mult == 4 ) {
-          if( fk - phi != 0) { // b!=0  und/oder b'!=0 
+          if( fk - phi != 0) { // b!=0  und/oder b'!=0
             if( Coeff(fk,x(1)*x(2), x(1)^2*x(2)^k) == 0 ) { // b=0 und b'!=0
               a    = (fk - Coeff(fk, x(1), x(1)^3)*x(1)^3) / x(1);
               v    = Isomorphie_s82_z(f, a, k);
-            } 
+            }
             else {
-              if( Coeff(fk,x(1)*x(2)*x(3), x(1)*x(2)^k*x(3)) == 0 ){ 
+              if( Coeff(fk,x(1)*x(2)*x(3), x(1)*x(2)^k*x(3)) == 0 ){
                         // b!=0 und b'=0
                 a    = subst(fk, x(3), 0);
@@ -1248 +1248 @@
       b = Coeff(l2, x(ky), x(ky));
       if( b== 0) { ky, kz = swap(ky, kz); }
-  
+
       // Koordinaten-Transf. s.d. f=x2y
       b  = Coeff(l2, x(ky), x(ky));
@@ -1260 +1260 @@
       PhiG = VERT(PhiG);
       cstn[4] = PhiG;
-    } 
+    }
 
 //------------------------------- step 98 ---------------------------------
@@ -1301 +1301 @@
     Phi  = ring_top, B;
     v[1] = f;
-    if ( EH(b) != 0)    // pruefe ob der Koeff von x_i^hc 
+    if ( EH(b) != 0)    // pruefe ob der Koeff von x_i^hc
     { B[rvar(x)] = x -1*(cf[hc,1]/(hc*b));
       v[1] = Phi(f);
@@ -1341 +1341 @@
       d = Coeff(fk, x(1)*x(2), x(1)*x(2)^3);
 
-      if( (a != 0) && (b != 0) ) {  
+      if( (a != 0) && (b != 0) ) {
         B = -int(Coeff(Matx[1,1], x(2), x(2)));
         C = -int(Coeff(Maty[1,1], x(1), x(1)));
@@ -1402 +1402 @@
         f    = VERT(f);
         PhiG = VERT(PhiG);
-      } 
+      }
       else {  //      "Weder b noch a sind 0";
         if(ct > 5) { v[1]=f; v[2]=PhiG; return(v); }
@@ -1408 +1408 @@
         return(Isomorphie_s17(f, fk, k, ct+1, PhiG));
       }
-    } 
+    }
     else {  // k >1
       a     = fk/x(2);
@@ -1468 +1468 @@
 
     s = s +"' has 4-jet equal to zero. (F47), mu="+string(Mu);
-  
+
     s; // +"  ("+SG_Typ+")";
     return(Show(f), tp, corank);
@@ -1576 +1576 @@
 static
 proc Morse(poly f, int K, int corank, int ShowPhi)
-{ 
+{
 //---------------------------- initialisation ---------------------------------
     poly   fc, f2, a, P, Beta, fi;
@@ -1591 +1591 @@
 
     def ring_top=basering;
-  
+
     debug_log(3, "Spalte folgendes Polynom mit Bestimmtheit: ", string(K));
     debug_log(3, Show(fi));
-  
+
     for( j=1; j<=n ; j++) { Abb[j] = 0; }
-  
+
     RFlg = GetRf(fi, n);
     debug_log(2, "Reihenfolge fuer Vertauschungen:", RFlg );
     PhiG=ring_top,maxideal(1);
-  
+
 //----------------- find quadratic term, if there is only one -----------------
     B = maxideal(1);
@@ -1626 +1626 @@
       }
       Phi  =ring_top,B;
-      fi   = Phi(fi);   
+      fi   = Phi(fi);
       PhiG = Phi(PhiG);
     }
     if( ShowPhi > 1) { PhiG; }
-  
+
 //------------------------ compute spliting lemma -----------------------------
     fc = fi;
@@ -1647 +1647 @@
           a = Coeff(jet(fc,2), x(RFlg[i]), x(RFlg[i])^2);
           debug_log(6,"Koeffizient von x(" + string(RFlg[i]) + ")^2 ist:", a);
-          if( (a != 0) || (i==n) ) { 
+          if( (a != 0) || (i==n) ) {
             debug_log(6, "BREAK!!!!!!!!!!!!!!");
             break;
@@ -1661 +1661 @@
           j   = j + 1;
         }               // Ende while( (j<=n) || (i==n) )
-  
+
         debug_log(6, "Moegliche Verschiebung fertig!");
         PhiG = Phi(PhiG);
         if( ShowPhi > 1) { "NachVersch.:"; Phi; }
-  
+
         if( (j<=n) || (i==n)) {
           P = Coeff(fc, x(RFlg[i]), x(RFlg[i]));
@@ -1693 +1693 @@
         }               // Ende if( (j<=n) || (i==n))
       }                 // Ende if( (f2 - subst(f2, x(RFlg[i]), 0)) != 0 )
-  
+
       fi = fc;
       i  = i + 1;
@@ -1699 +1699 @@
     }
     debug_log(6, "Ende  ---------------------------------------------------");
-  
+
 //--------------------------- collect results ---------------------------------
     if( ShowPhi > 0 ) {
@@ -1708 +1708 @@
       "fi     = " + Show(fi);
     }
-  
+
     Rang = 0;
     B    = maxideal(1);
@@ -1724 +1724 @@
 static
 proc Coeff(poly f, list #)
-{ 
+{
 //---------------------------- initialisation ---------------------------------
   poly   a, term;
@@ -1762 +1762 @@
   for( i=1; i<=n; i=i+1)
   { result = subst(f,x(i), 0) - f;
-    if( result != 0 ) { B[rvar(x(i))] = x(Ctv); Ctv++; } 
+    if( result != 0 ) { B[rvar(x(i))] = x(Ctv); Ctv++; }
     else { B[rvar(x(i))] = x(Ctn); Ctn--; }
   }
@@ -1787 +1787 @@
   // check basic condition on the basering.
   if(checkring()) { return(f); }
-  if( f==0 ) { 
+  if( f==0 ) {
     "Normal form : 0";
     return(f);
   }
-  if( jet(f,0)!=0 ) { 
+  if( jet(f,0)!=0 ) {
     "Normal form : 1";
     return(f);
@@ -1811 +1811 @@
     return();
   }
-  if(cnt==1) { 
+  if(cnt==1) {
     debug_log(1,"Getting normal form from database.");
     "normal form :",A_L(Typ);
@@ -1841 +1841 @@
   ideal jf=std(jacob(f)^e);
   intvec v=hilb(jf,2);
-  
+
   return(Hcode(v));
 }
@@ -1899 +1899 @@
 static
 proc Cubic (poly f)
-{ 
+{
 //---------------------------- initialisation ---------------------------------
   poly  f3;
@@ -1915 +1915 @@
 
   if(Dim == 0) { return("P[8]:smooth cubic"); } // x3 + y3 + z3 + axyz
-  if(Dim == 1) { 
+  if(Dim == 1) {
     if(Mult == 2) {
       Jf2  = wedge(jacob(Jf1),3-Dim), Jf1;
@@ -1945 +1945 @@
 proc parity  (int e)
 "USAGE:    parity()"
-{ 
+{
   int r = e/2;
   if( 2*r == e ) { return(0); }
@@ -1959 +1959 @@
   string SG_Typ = "";
   list   v;
-  
+
   // if trace/debug mode not set, do it!
   init_debug();
@@ -1975 +1975 @@
 static
 proc HKclass3 (intvec sg, string SG_Typ, int cnt)
-{ 
+{
   list v;
 
@@ -1986 +1986 @@
 static
 proc HKclass3_teil_1 (intvec sg, string SG_Typ, int cnt)
-{ 
+{
   int  k, r, s;
   list v;
@@ -1995 +1995 @@
     if( parity(sg[2])) { // sg[2] ist ungerade
       if(sg[2]<=sg[3]) {
-        k = (sg[2]+1)/2; 
-        if(k>1) { 
+        k = (sg[2]+1)/2;
+        if(k>1) {
           cnt++;
           SG_Typ=SG_Typ+" J[k,r]=J["+string(k)+","+string(sg[3]+1-2*k)+"]";
@@ -2023 +2023 @@
 static
 proc HKclass5 (intvec sg, string SG_Typ, int cnt)
-{ 
+{
   list v;
 
@@ -2055 +2055 @@
         r = sg[5] - sg[4];
         SG_Typ=SG_Typ +" X[k,r]=X["+string(k)+","+string(r)+"]"; cnt++;
-      } 
+      }
       if( (sg[3]==1) && (sg[4]==3) && (sg[5]>=sg[4])){    // Z[1,r]
         r = sg[5] - sg[4];
@@ -2067 +2067 @@
             SG_Typ = SG_Typ + " Z[k,r,0]=Z["+string(k)+","+string(r)+",0]";
           }
-        } 
+        }
         else {                                                // Z[k,12k+6r]
           r = (sg[4] - 2*k)/2; cnt++;
@@ -2166 +2166 @@
       }
       if(sg[4]<sg[5]) {                 // Q[k,r]
-        k = (sg[4]+2)/2; 
+        k = (sg[4]+2)/2;
         if(k>=2) {
           r=sg[5]+1-2*k; cnt++;
@@ -2216 +2216 @@
 static
 proc HKclass7 (intvec sg, string SG_Typ, int cnt)
-{ 
+{
   list v;
 
@@ -2267 +2267 @@
 ///////////////////////////////////////////////////////////////////////////////
 proc singularity(string typ, list #)
-"USAGE:    singularity(t, l); t=string (name of singularity), 
+"USAGE:    singularity(t, l); t=string (name of singularity),
           l=list of integers (index/indices of singularity)
 COMPUTE:  get the Singularity named by type t from the database.
@@ -2291 +2291 @@
   if(len>=3) { s = #[3]; }
   else { s = 0; }
-  if( k<0 || r<0 || s<0) { 
+  if( k<0 || r<0 || s<0) {
     "Initial condition failed: k>=0; r>=0; s>=0";
     "k="+string(k)+" r="+string(r)+"   s="+string(s);
@@ -2301 +2301 @@
   def ring_top=basering;
 
-  if(len>=4) { a1 = #[4]; } 
+  if(len>=4) { a1 = #[4]; }
   else { a1=1; }
-  if(len>=5) { a2 = #[5]; } 
+  if(len>=5) { a2 = #[5]; }
   else { a2=1; }
-  if(len>=6) { a3 = #[6]; } 
+  if(len>=6) { a3 = #[6]; }
   else { a3=1; }
-  if(len>=7) { a4 = #[7]; } 
+  if(len>=7) { a4 = #[7]; }
   else { a4=1; }
 
-  debug_log(4, "Values: len=", string(len), " k=", string(k), " r=", 
+  debug_log(4, "Values: len=", string(len), " k=", string(k), " r=",
         string(r));
   if(defined(RingNF) != 0 ) { kill RingNF; }
@@ -2340 +2340 @@
 proc Singularitaet (string typ,int k,int r,int s,poly a,poly b,poly c,poly d)
 {
-  list   v;  
+  list   v;
   string DBMPATH=system("getenv","DBMPATH");
   string DatabasePath, Database, S, Text, Tp;
@@ -2353 +2353 @@
   link dbmLink=Database;
   debug_log(2, "Opening Singalarity-database: ", newline, Database);
-  Tp = read(dbmLink, typ); 
+  Tp = read(dbmLink, typ);
   debug_log(2,"DBMread(", typ, ")=", Tp, ".");
   if( Tp != "(null)" && Tp !="" ) {
@@ -2361 +2361 @@
     execute S;
     execute read(dbmLink, Key)+";";
-    debug_log(1, "Polynom f=", f,  "  crk=", crk, "  Mu=", Mu, 
+    debug_log(1, "Polynom f=", f,  "  crk=", crk, "  Mu=", Mu,
                 " MlnCd=", MlnCd);
     v = f, crk, Mu, MlnCd;
@@ -2437 +2437 @@
 EXAMPLE:  example debug_log; shows an example
 SEE ALSO: init_debug();"
-{ 
+{
    int len = size(#);
 //   int printresult = printlevel - level +1;
@@ -2445 +2445 @@
 //   else { dbprint(printresult, #[1..len]); }
    if( defined(@DeBug) == 0 ) { init_debug(); }
-   if(@DeBug>=level) { 
+   if(@DeBug>=level) {
       if(level>1) { "Debug:("+ string(level)+ "): ", #[1..len]; }
       else { #[1..len]; }
@@ -2458 +2458 @@
 proc init_debug(list #)
 "USAGE:    init_debug([level]);  level=int
-COMPUTE:  Set the global variable @DeBug to level. The variable @DeBug is 
-          used by the function debug_log(level, list of strings) to know 
-          when to print the list of strings. init_debug() reports only 
+COMPUTE:  Set the global variable @DeBug to level. The variable @DeBug is
+          used by the function debug_log(level, list of strings) to know
+          when to print the list of strings. init_debug() reports only
           changes of @DeBug.
 NOTE:     The procedure init_debug(n); is usefull as trace-mode. n may
           range from 0 to 10, higher values of n give more information.
 EXAMPLE:  example init_debug; shows an example"
-{ 
+{
   int newDebug=0;
   if( defined(@DeBug) != 0 ) { newDebug = @DeBug; }
 
-  if( size(#) > 0 ) { 
+  if( size(#) > 0 ) {
     newDebug=#[1];
   }
@@ -2479 +2479 @@
     }
   }
-  if( defined(@DeBug) == 0) { 
+  if( defined(@DeBug) == 0) {
     int @DeBug = newDebug;
     export @DeBug;
@@ -2515 +2515 @@
 RETURN:   intvec: d, mu, c
 EXAMPLE:  example basicinvariants; shows an example"
-{ 
+{
   intvec v;
   ideal Jfs = std(jacob(f));
@@ -2615 +2615 @@
 proc GetRf (poly fi, int n)
 "USAGE:    GetRf();"
-{ 
+{
 //---------------------------- initialisation ---------------------------------
   int    j, k, l1, l1w;
@@ -2643 +2643 @@
 static
 proc Show(poly g)
-{ 
+{
   string s;
   def ring_save=basering;
@@ -2721 +2721 @@
       b = i - 12*k;
       if( b == 1 ) { s3 = "k"; }
-      else { 
+      else {
         if(b==0) { s3 = "12k"+string(b-1); }
         else { s3 = "12k+"+string(b-1); }
@@ -2742 +2742 @@
       if(r==0) { s4 = string(0); }
       if(k==0 && Typ=="Z[") { s3 = string(1); }
-      if(Typ[2] == "#") { 
+      if(Typ[2] == "#") {
         i = r+1;
         r = i/2;
         b = i - 2*r;
-        if( b == 1 ) { s4 = "2r"; } 
+        if( b == 1 ) { s4 = "2r"; }
         else { s4 = "2r-1"; }
       }
@@ -2752 +2752 @@
     }  // es kommt mindestens zwei komma vor...
     //----------------------- get third parameter -----------------------------
-    else { 
+    else {
       debug_log(8, "  Number of columns >=2");
       debug_log(2, "Y[k,r,s] / Z[k,r,s] / T[k,r,s]");
@@ -2782 +2782 @@
           the singularity given by its name.
 EXAMPLE:  example A_L; shows an example"
-{ 
+{
   // if trace/debug mode not set, do it!
   init_debug();
@@ -2794 +2794 @@
     return(quickclass(#[1]));
   }
-  
+
 }
 example
 { "EXAMPLE:"; echo=2;
-  ring r=0,(a,b,c),ds;  
+  ring r=0,(a,b,c),ds;
   poly f=A_L("E[13]");
   f;
@@ -2809 +2809 @@
 RETURN:   Arnold's normal form of singularity with name s
 EXAMPLE:  example normalform; shows an example."
-{ 
+{
   string Typ;
   int    k, r, s, crk;
@@ -2832 +2832 @@
 example
 { "EXAMPLE:"; echo=2;
-  ring r=0,(a,b,c),ds;  
+  ring r=0,(a,b,c),ds;
   normalform("E[13]");
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-proc swap 
+proc swap
 "USAGE:    swap(a,b);
 RETURN:   b,a if b,a is the input (any type)"
 {
-  return(#[2],#[1]); 
+  return(#[2],#[1]);
 }
 example

Singular/LIB/deform.lib

@@ -1 @@
-// $Id: deform.lib,v 1.10 1998-05-05 11:55:22 krueger Exp $
+// $Id: deform.lib,v 1.11 1998-05-14 18:44:57 Singular Exp $
 // author: Bernd Martin email: martin@math.tu-cottbus.de
-//(bm, last modified 4/98)   
-///////////////////////////////////////////////////////////////////////////////
-version="$Id: deform.lib,v 1.10 1998-05-05 11:55:22 krueger Exp $";
+//(bm, last modified 4/98)
+///////////////////////////////////////////////////////////////////////////////
+version="$Id: deform.lib,v 1.11 1998-05-14 18:44:57 Singular Exp $";
 info="
 LIBRARY:  deform.lib       PROCEDURES FOR COMPUTING MINIVERSAL DEFORMATION
@@ -10 +10 @@
  versal(Fo[,d,any])        miniversal deformation of isolated singularity Fo
  mod_versal(Mo,I,[,d,any]) miniversal deformation of module Mo modulo ideal I
- lift_kbase(N,M);          lifting N into standard kbase of M 
+ lift_kbase(N,M);          lifting N into standard kbase of M
  lift_rel_kb(N,M[,kbM,p])  relative lifting N into a kbase of M
  kill_rings([\"prefix\"])    kills the exported rings from above
- 
+
   SUB-PROCEDURES            used by main procedure:
                   get_rings,compute_ext,get_inf_def,interact1,
@@ -33 +33 @@
 COMUPTE: miniversal deformation of Fo up to degree d (default d=100),
 CREATE:  Rings (exported):
-         'my'Px = extending the basering Po by new variables given by \"A,B,..\" 
+         'my'Px = extending the basering Po by new variables given by \"A,B,..\"
                   (deformation parameters), returns as basering,
                   the new variables come before the old ones,
@@ -40 +40 @@
          'my'So = being the embedding-ring of the versal base space,
          'my'Ox = Px/Js extending So/Js.   (default my=\"\")
-      Matrices (in Px, exported): 
+      Matrices (in Px, exported):
          Js  = giving the versal base space (obstructions),
          Fs  = giving the versal family of Fo,
@@ -48 +48 @@
       Otherwise 'any' gives predefined strings: \"my\",\"param\",\"order\",\"out\"
       (\"my\" prefix-string, \"param\" is a letter (e.g. \"A\")  for the name of
-      first parameter or (e.g. \"A(\") for index parameter variables, \"order\" 
+      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 output at all,
-        printlevel >=0,1,2,.. informs you, what is going on;            
+        printlevel >=0,1,2,.. informs you, what is going on;
         this proc uses 'execute'.
 EXAMPLE:example versal; shows an example
@@ -62 +62 @@
   int time = timer;
   intvec @iv,@jv,@is_qh,@degr;
-  d_max    = 100;  
+  d_max    = 100;
   @my = ""; @param="A"; @order="ds"; @out="no";
   @size    = size(#);
   if( @size>0 ) { d_max = #[1]; }
-  if( @size>1 ) 
-  { if(typeof(#[2])!="string") 
+  if( @size>1 )
+  { if(typeof(#[2])!="string")
     { string @active;
       @my,@param,@order,@out = interact1();
@@ -86 +86 @@
   int    @rowR= size(Fo);
   def    Po   = basering;
-setring  Po; 
+setring  Po;
   poly   X_s  = product(maxideal(1));
 //-------  reproduce T12 ------------------------------------------------------
@@ -106 +106 @@
   @t2 = Ls[4];                                 // vdim of T2
   kill Ls;
-  t1' = @t1;  
-  if( @t1==0) { dbprint(p,"// rigit!"); return();}  
-  if( @t2==0) { @smooth=1; dbprint(p,"// smooth base space");}   
+  t1' = @t1;
+  if( @t1==0) { dbprint(p,"// rigit!"); return();}
+  if( @t2==0) { @smooth=1; dbprint(p,"// smooth base space");}
   dbprint(p,"// ready: T1 and T2");
   @colR = ncols(Ro);
@@ -114 +114 @@
   @degrees = homog_test(@is_qh,matrix(Fo),InfD);
   @jv = 1..@t1;
-  if (@degrees!="") 
+  if (@degrees!="")
   { dbprint(p-1,"// T1 is quasi-homogeneous represented with weight-vector",
     @degrees);
   }
   if (defined(@active))
-  { "// matrix of infinitesimal deformations:";print(InfD); 
+  { "// matrix of infinitesimal deformations:";print(InfD);
     "// weights of infinitesimal deformations (  emty ='not qhomog'):";
      @degrees;
      matrix dummy;
      InfD,dummy,t1' = interact2(InfD,@jv);kill dummy;
-  } 
+  }
  //---- create new rings and objects ------------------------------------------
   get_rings(Fo,t1',1,@my,@order,@param);
  setring `myPx`;
-  @jv=0; @jv[t1']=0; @jv=@jv+1; @jv[nvars(basering)]=0;       
+  @jv=0; @jv[t1']=0; @jv=@jv+1; @jv[nvars(basering)]=0;
                                                //weight-vector for calculating
                                                //rel-jet with resp to def-para
-  ideal  Io   = imap(Po,Fo);                
+  ideal  Io   = imap(Po,Fo);
   ideal  J,m_J,tid;     attrib(J,"isSB",1);
   matrix Fo   = matrix(Io);                   //initial equations
@@ -139 +139 @@
   matrix homFR= concat(homR,homF);
   module hom' = std(homFR);
-  matrix Js[1][@t2]; 
-  matrix F_R,Fs,Rs,Fn,Rn; 
-  export Js,Fs,Rs;                         
-  matrix Mon[t1'][1]=maxideal(1);             
+  matrix Js[1][@t2];
+  matrix F_R,Fs,Rs,Fn,Rn;
+  export Js,Fs,Rs;
+  matrix Mon[t1'][1]=maxideal(1);
   Fn  = transpose(imap(Po,InfD)*Mon);         //infinitesimal deformations
-  Fs  = Fo + Fn; 
+  Fs  = Fo + Fn;
   dbprint(p-1,"// infinitesimal deformation: Fs: ",Fs);
   Rn  = (-1)*lift(Fo,Fs*Ro);                  //infinit. relations
@@ -151 +151 @@
   tid = 0 + ideal(F_R);
   if (tid[1]==0) {d_max=1;}                   //finished ?
- setring `myOx`;  
+ setring `myOx`;
   matrix Fs,Rs,Cup,Cup',F_R,homFR,New,Rn,Fn;
   module hom';
-  ideal  null,tid;  attrib(null,"isSB",1); 
- setring `myQx`;    
-  poly X_s = imap(Po,X_s);       
-  matrix Cup,Cup',MASS;              
+  ideal  null,tid;  attrib(null,"isSB",1);
+ setring `myQx`;
+  poly X_s = imap(Po,X_s);
+  matrix Cup,Cup',MASS;
   ideal  tid,null;               attrib(null,"isSB",1);
-  ideal  J,m_J;                  attrib(J,"isSB",1); 
+  ideal  J,m_J;                  attrib(J,"isSB",1);
                                  attrib(m_J,"isSB",1);
-  matrix PreO = imap(Po,PreO); 
+  matrix PreO = imap(Po,PreO);
   module PreO'= imap(Po,PreO');  attrib(PreO',"isSB",1);
   module PreT = imap(Po,PreT);   attrib(PreT,"isSB",1);
@@ -172 +172 @@
    {
      if( @t1==0) {break};
-     dbprint(p,"// start computation in degree "+string(@d)+".");      
+     dbprint(p,"// start computation in degree "+string(@d)+".");
      dbprint(p-3,">>> TIME = "+string(timer-time));
      dbprint(p-3,"==> memory = "+string(kmemory())+"k");
@@ -178 +178 @@
      if (@smooth) { @noObstr=1;}
      else
-     { Cup = jet(F_R,@d,@jv); 
-       Cup = matrix(reduce(ideal(Cup),m_J),@colR,1);   
-       Cup = jet(Cup,@d,@jv);          
-     }   
+     { Cup = jet(F_R,@d,@jv);
+       Cup = matrix(reduce(ideal(Cup),m_J),@colR,1);
+       Cup = jet(Cup,@d,@jv);
+     }
 //------- express obstructions in kbase of T2  --------------------------------
      if ( @noObstr==0 )
@@ -191 +191 @@
         }
         Cup   = lift(PreO,Cup);
-        MASS  = lift_rel_kb(Cup,PreT,kbT2,X_s); 
-        dbprint(p-3,"// next MASSEY-products:",MASS-jet(MASS,@d-1,@jv)); 
+        MASS  = lift_rel_kb(Cup,PreT,kbT2,X_s);
+        dbprint(p-3,"// next MASSEY-products:",MASS-jet(MASS,@d-1,@jv));
         if    (MASS==transpose(Js))
-              { @noObstr=1;dbprint(p-1,"// no obstruction"); } 
+              { @noObstr=1;dbprint(p-1,"// no obstruction"); }
          else { @noObstr=0; }
       }
@@ -204 +204 @@
  setring `myPx`;
         Js   = imap(`myQx`,Js);
-      degBound = @d+1; 
+      degBound = @d+1;
         J    = std(ideal(Js));
         m_J  = std(J*ideal(Mon));
@@ -210 +210 @@
 //--------------- obtain new base-ring ----------------------------------------
         kill `myOx`;
-  qring `myOx` = J;  
+  qring `myOx` = J;
         matrix Fs,Rs,F_R,Cup,Cup',homFR,New,Rn,Fn;
         module hom';
@@ -217 +217 @@
 //---------------- lift equations F and relations R ---------------------------
  setring `myOx`;
-      Fs    = fetch(`myPx`,Fs);                  
-      Rs    = fetch(`myPx`,Rs);   
-      F_R   = Fs*Rs;    
-      F_R   = matrix(reduce(ideal(F_R),null));  
+      Fs    = fetch(`myPx`,Fs);
+      Rs    = fetch(`myPx`,Rs);
+      F_R   = Fs*Rs;
+      F_R   = matrix(reduce(ideal(F_R),null));
       tid   = 0 + ideal(F_R);
-      if (tid[1]==0) { dbprint(p-1,"// finished"); break;}   
-      Cup   = (-1)*transpose(jet(F_R,@d,@jv));  
-      homFR = fetch(`myPx`,homFR);  
+      if (tid[1]==0) { dbprint(p-1,"// finished"); break;}
+      Cup   = (-1)*transpose(jet(F_R,@d,@jv));
+      homFR = fetch(`myPx`,homFR);
       hom'  = fetch(`myPx`,hom');  attrib(hom',"isSB",1);
       Cup'  = simplify(reduce(Cup,hom'),10);
@@ -238 +238 @@
       Rs    = Rs+Rn;
       F_R   = Fs*Rs;
-      tid   = 0+reduce(ideal(F_R),null); 
+      tid   = 0+reduce(ideal(F_R),null);
 //---------------- fetch results into other rings -----------------------------
   setring `myPx`;
@@ -248 +248 @@
       m_J = fetch(`myPx`,m_J);  attrib(m_J,"isSB",1);
       J   = fetch(`myPx`,J);    attrib(J,"isSB",1);
-      Js  = fetch(`myPx`,Js); 
-      tid = fetch(`myOx`,tid); 
-      if (tid[1]==0) { dbprint(p-1,"// finished");break;}         
+      Js  = fetch(`myPx`,Js);
+      tid = fetch(`myOx`,tid);
+      if (tid[1]==0) { dbprint(p-1,"// finished");break;}
    }
 //---------  end loop and final output ----------------------------------------
@@ -256 +256 @@
    if (@out!="no")
    {  string out = @out+"_"+string(@d);
-      "// writing file "+out+" with matrix Js, matrix Fs, matrix Rs ready 
+      "// writing file "+out+" with matrix Js, matrix Fs, matrix Rs ready
       for reading in rings "+myPx+" or "+myQx;
       write(out,"matrix Js[1][",@t2,"]=",Js,";matrix Fs[1][",@rowR,"]=",Fs,
       ";matrix Rs[",@rowR,"][",@colR,"]=",Rs,";");
-   } 
+   }
    dbprint(p-3,">>> TIME = "+string(timer-time));
    if (@is_qh != 0)
@@ -266 +266 @@
      @degr = @degr[1..t1'];
      dbprint(p-1,"// quasi-homogeneous weights of miniversal base",@degr);
-   } 
+   }
    dbprint(p-1,
    "// ___ Equations of miniversal base space ___",Js,
@@ -277 +277 @@
    "   setring "+myPx+"; show("+myPx+");","   listvar(matrix);",
    "// NOTE: rings "+myQx+", "+myPx+", "+mySo+" are alive!",
-   "// (use 'kill_rings(\""+@my+"\");' to remove)"); 
+   "// (use 'kill_rings(\""+@my+"\");' to remove)");
    return();
 }
@@ -286 +286 @@
    ring r1        = 0,(x,y,z,u,v),ds;
    matrix m[2][4] = x,y,z,u,y,z,u,v;
-   ideal Fo       = minor(m,2);    
+   ideal Fo       = minor(m,2);
                     // cone over rational normal curve of degree 4
    versal(Fo);
@@ -305 +305 @@
 proc mod_versal(matrix Mo, ideal I, list #)
 "
-USAGE:   mod_versal(Mo,I[,d,any]); I=ideal, M=module, d=int, any =list 
+USAGE:   mod_versal(Mo,I[,d,any]); I=ideal, M=module, d=int, any =list
 COMUPTE: miniversal deformation of coker(Mo) over Qo=Po/Io, Po=basering;
 CREATE:  Ringsr (exported):
@@ -314 +314 @@
          'my'Qx  = Px/Io extending Qo (returns as basering),
          'my'Ox  = Px/(Io+Js) ring of the versal deformation of coker(Ms),
-         'my'So  = embedding-ring of the versal base space.  (default 'my'=\"\") 
+         'my'So  = embedding-ring of the versal base space.  (default 'my'=\"\")
       Matrices (in Qx, exported):
          Js  = giving the versal base space (obstructions),
          Ms  = giving the versal family of Mo,
-         Ls  = giving the lifting of syzygies Lo=syz(Mo), 
+         Ls  = 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' gives predefined strings:\"my\",\"param\",\"order\",\"out\"
       (\"my\" prefix-string, \"param\" is a letter (e.g. \"A\")  for the name of
-      first parameter or (e.g. \"A(\") for index parameter variables, \"ord\" 
+      first parameter or (e.g. \"A(\") for index parameter variables, \"ord\"
       ordering string for ringextension), \"out\" name of output-file).
 NOTE:   printlevel < 0        no output at all,
-        printlevel >=0,1,2,.. informs you, what is going on,             
+        printlevel >=0,1,2,.. informs you, what is going on,
         this proc uses 'execute'.
 EXAMPLE:example mod_versal; shows an example
@@ -337 +337 @@
   int time = timer;
   intvec @iv,@jv,@is_qh,@degr;
-  d_max    = 100;  
+  d_max    = 100;
   @my = ""; @param="A"; @order="ds"; @out="no";
   @size = size(#);
   if( @size>0 ) { d_max = #[1]; }
-  if( @size>1 ) 
-  { if(typeof(#[2])!="string") 
+  if( @size>1 )
+  { if(typeof(#[2])!="string")
     { string @active;
       @my,@param,@order,@out = interact1();
@@ -352 +352 @@
       if (@size>4) {@out   = #[5];}
     }
-  }  
+  }
   string myPx = @my+"Px";
   string myQx = @my+"Qx";
@@ -363 +363 @@
 //-------- compute Ext's ------------------------------------------------------
          I   = std(I);
- qring   Qo  = I;   
+ qring   Qo  = I;
   matrix Mo  = fetch(Po,Mo);
-  list   Lo  = compute_ext(Mo,p); 
+  list   Lo  = compute_ext(Mo,p);
          f0,f1,f2,e1,e2,ok_ann=Lo[1];
   matrix Ls,kb1,lift1 = Lo[2],Lo[3],Lo[4];
@@ -373 +373 @@
   dbprint(p,"// ready: Ext1 and Ext2");
 //-----  test: quasi-homogeneous, choice of inf. def.--------------------------
-  @degrees = homog_test(@is_qh,Mo,kb1);  
+  @degrees = homog_test(@is_qh,Mo,kb1);
   e1' = e1;  @jv = 1..e1;
-  if (@degrees != "") 
+  if (@degrees != "")
   { dbprint(p-1,"// Ext1 is quasi-homogeneous represented: "+@degrees);
   }
   if (defined(@active))
   { "// kbase of Ext1:";
-    print(kb1); 
+    print(kb1);
     "// weights of kbase of Ext1 ( empty = 'not qhomog')";@degrees;
     kb1,lift1,e1' = interact2(kb1,@jv,lift1);
-  } 
+  }
 //-------- get new rings and objects ------------------------------------------
  setring Po;
@@ -392 +392 @@
   ideal  Io   = I_J;
   matrix Mon[e1'][1] = maxideal(1);
-  matrix Ms   = imap(Qo,Mo);              
-  matrix Ls   = imap(Qo,Ls);       
-  matrix Js[1][e2];            
+  matrix Ms   = imap(Qo,Mo);
+  matrix Ls   = imap(Qo,Ls);
+  matrix Js[1][e2];
  setring `myQx`;
   ideal  J,I_J,tet,null;              attrib(null,"isSB",1);
   ideal  m_J  = fetch(`myPx`,m_J);   attrib(m_J,"isSB",1);
   @jv=0;  @jv[e1] = 0; @jv = @jv+1;   @jv[nvars(`myPx`)] = 0;
-  matrix Ms   = imap(Qo,Mo);          export(Ms);       
+  matrix Ms   = imap(Qo,Mo);          export(Ms);
   matrix Ls   = imap(Qo,Ls);          export(Ls);
   matrix Js[e2][1];                   export(Js);
-  matrix MASS; 
+  matrix MASS;
   matrix Mon  = fetch(`myPx`,Mon);
   matrix Mn,Ln,ML,Cup,Cup',Lift;
@@ -410 +410 @@
   matrix D'   = imap(Qo,D');
   module Do   = imap(Qo,Do);          attrib(Do,"isSB",1);
-  matrix kb2  = imap(Qo,kb2);    
+  matrix kb2  = imap(Qo,kb2);
   matrix kb1  = imap(Qo,kb1);
   matrix lift1= imap(Qo,lift1);
   poly   X_s  = imap(Po,X_s);
-  intvec intv = e1',e1,f0,f1,f2; 
-         Ms,Ls= get_inf_def(Ms,Ls,kb1,lift1,X_s);     
+  intvec intv = e1',e1,f0,f1,f2;
+         Ms,Ls= get_inf_def(Ms,Ls,kb1,lift1,X_s);
   kill   kb1,lift1;
   dbprint(p-1,"// infinitesimal extension",Ms);
 //----------- start the loop --------------------------------------------------
   for (@d=2;@d<=d_max;@d=@d+1)
-  { 
+  {
     dbprint(p-3,">>> time = "+string(timer-time));
     dbprint(p-3,"==> memory = "+string(memory(0)/1000)+
                 ",  allocated = "+string(memory(1)/1000));
-    dbprint(p,"// start deg = "+string(@d));   
+    dbprint(p,"// start deg = "+string(@d));
 //-------- get obstruction ----------------------------------------------------
     Cup  = matrix(ideal(Ms*Ls),f0*f2,1);
@@ -433 +433 @@
     Cup' = reduce(Cup,Do);
     tet  = simplify(ideal(Cup'),10);
-    if (tet[1]!=0) 
+    if (tet[1]!=0)
     { dbprint(p-4,"// *");
       Cup = Cup-Cup';
@@ -441 +441 @@
     { MASS = lift_rel_kb(Cup,ex2,kb2,X_s);}
     else
-    { MASS = reduce(Cup,ex2);}      
+    { MASS = reduce(Cup,ex2);}
     dbprint(p-3,"// next MATRIC-MASSEY-products",
     MASS-jet(MASS,@d-1,@jv));
     if   ( MASS==transpose(Js))
          { @noObstr = 1;dbprint(p-1,"//no obstruction"); }
-    else { @noObstr = 0; }        
+    else { @noObstr = 0; }
 //-------- obtain equations of base space -------------------------------------
     if (@noObstr == 0)
@@ -458 +458 @@
      degBound=0;
       I_J = Io,J;                attrib(I_J,"isSB",1);
-//-------- obtain new base ring ----------------------------------------------- 
+//-------- obtain new base ring -----------------------------------------------
       kill `myOx`;
- qring `myOx` = I_J;     
+ qring `myOx` = I_J;
       ideal null,tet;            attrib(null,"isSB",1);
       matrix Ms  = imap(`myQx`,Ms);
       matrix Ls  = imap(`myQx`,Ls);
       matrix Mn,Ln,ML,Cup,Cup',Lift;
-      matrix C'  = imap(Qo,C');  
+      matrix C'  = imap(Qo,C');
       module Co  = imap(Qo,Co);   attrib(Co,"isSB",1);
       module ex2 = imap(Qo,ex2);  attrib(ex2,"isSB",1);
       matrix kb2 = imap(Qo,kb2);
       poly   X_s = imap(Po,X_s);
-    }  
+    }
 //-------- get lifts ----------------------------------------------------------
    setring `myOx`;
@@ -477 +477 @@
     Cup = jet(Cup,@d,@jv);
     Cup'= reduce(Cup,Co);
-    tet = simplify(ideal(Cup'),10);    
-    if (tet[1]!=0) 
+    tet = simplify(ideal(Cup'),10);
+    if (tet[1]!=0)
     { dbprint(p-4,"// #");
      Cup = Cup-Cup';
     }
-    Lift = lift(C',Cup);                  
+    Lift = lift(C',Cup);
     Mn   = matrix(ideal(Lift),f0,f1);
     Ln   = matrix(ideal(Lift[f0*f1+1..nrows(Lift),1]),f1,f2);
@@ -490 +490 @@
     dbprint(p-3,"// next extension of syz(Mo)",Ln);
     ML   = reduce(ideal(Ms*Ls),null);
-//--------- test: finished ---------------------------------------------------- 
+//--------- test: finished ----------------------------------------------------
     tet  = simplify(ideal(ML),10);
     if (tet[1]==0) { dbprint(p-1,"// finished in degree ",@d);}
@@ -496 +496 @@
    setring `myPx`;
     Ms   = fetch(`myOx`,Ms);
-    Ls   = fetch(`myOx`,Ls); 
+    Ls   = fetch(`myOx`,Ls);
    setring `myQx`;
     Ms   = fetch(`myOx`,Ms);
-    Ls   = fetch(`myOx`,Ls); 
+    Ls   = fetch(`myOx`,Ls);
     ML   = Ms*Ls;
-    ML   = matrix(reduce(ideal(ML),null),f0,f2); 
+    ML   = matrix(reduce(ideal(ML),null),f0,f2);
     tet  = imap(`myOx`,tet);
     if (tet[1]==0) { break;}
-  }  
-//------- end of loop, final output ------------------------------------------- 
+  }
+//------- end of loop, final output -------------------------------------------
   if (@out != "no")
   { string out = @out+"_"+string(@d);
-    "// writing file '"+out+"' with matrix Js, matrix Ms, matrix Ls 
+    "// writing file '"+out+"' with matrix Js, matrix Ms, matrix Ls
     ready for reading in rings "+myPx+" or "+myQx;
     write(out,"matrix Js[1][",e2,"]=",Js,";matrix Ms[",f0,"][",f1,"]=",Ms,
@@ -518 +518 @@
     @degr = @degr[1..e1'];
     dbprint(p-1,"// quasi-homogeneous weights of miniversal base",@degr);
-  } 
+  }
   dbprint(p-1,"// Result belongs to qring "+myQx,
   "// Equations of total space of miniversal deformation are in Js",
@@ -540 +540 @@
   mod_versal(Mo,Io);
   printlevel = p;
-  kill Px,Qx,So; 
-}
-//============================================================================= 
+  kill Px,Qx,So;
+}
+//=============================================================================
 ///////////////////////////////////////////////////////////////////////////////
 proc kill_rings(list #)
 "USAGE: kill_rings([string]);
-Sub-procedure: kills exported rings of 'versal' and 
+Sub-procedure: kills exported rings of 'versal' and
                'mod_versal' with prefix 'string'
 "
@@ -574 +574 @@
 Sub-procedure: obtain Ext1 and Ext2 and other objects used by mod_versal
 "
-{ 
+{
    int    l,f0,f1,f2,f3,e1,e2,ok_ann;
    module Co,Do,ima,ex1,ex2;
-   matrix M0,M1,M2,ker,kb1,lift1,kb2,A,B,C,D;  
+   matrix M0,M1,M2,ker,kb1,lift1,kb2,A,B,C,D;
 //------- resM ---------------------------------------------------------------
-   list resM = res(Mo,3);   
+   list resM = res(Mo,3);
    M0 = resM[1];
    M1 = resM[2];
@@ -588 +588 @@
    f3 = ncols(M2);
 //------ compute Ext^2  ------------------------------------------------------
-   B    = kohom(M0,f3); 
+   B    = kohom(M0,f3);
    A    = kontrahom(M2,f0);
-   D    = modulo(A,B); 
-   Do   = std(D);   
+   D    = modulo(A,B);
+   Do   = std(D);
    ima  = kohom(M0,f2),kontrahom(M1,f0);
    ex2  = modulo(D,ima);
@@ -603 +603 @@
    }
    if (ok_ann==0)
-   {  e2 =nrows(ex2);    
+   {  e2 =nrows(ex2);
       dbprint(p,"// Ann(Ext2) is maximal");
    }
 //------ compute Ext^1 -------------------------------------------------------
-   B     = kohom(M0,f2); 
+   B     = kohom(M0,f2);
    A     = kontrahom(M1,f0);
    ker   = modulo(A,B);
-   ima   = kohom(M0,f1),kontrahom(M0,f0);  
+   ima   = kohom(M0,f1),kontrahom(M0,f0);
    ex1   = modulo(ker,ima);
    ex1   = std(ex1);
@@ -621 +621 @@
 //------ compute the liftings of Ext^1 ---------------------------------------
    lift1 = A*kb1;
-   lift1 = lift(B,lift1); 
+   lift1 = lift(B,lift1);
    intvec iv = f0,f1,f2,e1,e2,ok_ann;
    list   L' = ex2,kb2,C,Co,D,Do;
@@ -629 +629 @@
 proc get_rings(ideal Io,int e1,int switch, list #)
 "
-Sub-procedure: creating ring-extensions 
-"
-{ 
-   def Po = basering; 
+Sub-procedure: creating ring-extensions
+"
+{
+   def Po = basering;
    string my;
    string my_ord = "ds";
-   string my_var = "A"; 
+   string my_var = "A";
    if (size(#)>2)
    {
@@ -642 +642 @@
      my_var = #[3];
    }
-   string my_Px = my+"Px"; 
-   string my_Qx = my+"Qx"; 
-   string my_Ox = my+"Ox"; 
-   string my_So = my+"So"; 
+   string my_Px = my+"Px";
+   string my_Qx = my+"Qx";
+   string my_Ox = my+"Ox";
+   string my_So = my+"So";
   extendring(my_Px,e1,my_var,my_ord);
    ideal Io  = imap(Po,Io);         attrib(Io,"isSB",1);
@@ -666 +666 @@
 proc get_inf_def(list #)
 "
-Sub-procedure: compute infinitesimal family of a module and its syzygies 
+Sub-procedure: compute infinitesimal family of a module and its syzygies
                from a kbase of Ext1 and its lifts
 "
@@ -687 +687 @@
   }
   return(Ms,Ls);
-} 
+}
 //////////////////////////////////////////////////////////////////////////////
 proc lift_rel_kb (module N, module M, list #)
@@ -695 +695 @@
         N, M modules of same rank,
         M depending only on variables not in p and vdim(M) finite in this ring,
-        [ kbaseM the kbase of M in the subring given by variables not in p ] 
+        [ kbaseM the kbase of M in the subring given by variables not in p ]
         warning: check that these assumtions are fulfilled!
 RETURN  matrix A, whose j-th columnes present the coeff's of N[j] in kbaseM,
@@ -704 +704 @@
   poly p = product(maxideal(1));
        M = std(M);
-  matrix A; 
+  matrix A;
   if (size(#)>0) { p=#[2]; module kbaseM=#[1];}
-  else 
+  else
   { if (vdim(M)<=0) { "// vdim(M) not finite";return(A);}
     module kbaseM = kbase(M);
@@ -714 +714 @@
   A = coeffs(N,kbaseM,p);
   return(A);
-} 
+}
 example
 {
@@ -736 +736 @@
   print(kbase(std(M))*A);
   print(reduce(N,std(M)));
-} 
+}
 ///////////////////////////////////////////////////////////////////////////////
 proc lift_kbase (N, M)
@@ -769 +769 @@
 proc interact1 ()
 "
-Sub_procedure: asking for and reading your input-strings 
+Sub_procedure: asking for and reading your input-strings
 "
 {
@@ -775 +775 @@
  string str,out,my_ord,my_var;
  my_ord = "ds";
- my_var = "A"; 
+ my_var = "A";
  "INPUT: name of output-file (ENTER = no output, do not use \"my\"!)";
-   str = read("");                                 
-   if (size(str)>1) 
+   str = read("");
+   if (size(str)>1)
    { out = str[1..size(str)-1];}
    else
    { out = "no";}
  "INPUT: prefix-string of ring-extension (ENTER = '@')";
-   str = read(""); 
-   if ( size(str) > 1 ) 
-   { my = str[1..size(str)-1]; }      
- "INPUT:parameter-string 
+   str = read("");
+   if ( size(str) > 1 )
+   { my = str[1..size(str)-1]; }
+ "INPUT:parameter-string
    (give a letter corresponding to first new variable followed by the next letters,
    or 'T('       - a letter + '('  - getting a string of indexed variables)
    (ENTER = A) :";
-   str = read(""); 
+   str = read("");
    if (size(str)>1) { my_var=str[1..size(str)-1]; }
  "INPUT:order-string (local or weighted!) (ENTER = ds) :";
-   str = read(""); 
-   if (size(str)>1) { my_ord=str[1..size(str)-1]; }    
+   str = read("");
+   if (size(str)>1) { my_ord=str[1..size(str)-1]; }
    if( find(my_ord,"s")+find(my_ord,"w") == 0 )
    { "// ordering must be an local! changed into 'ds'";
@@ -816 +816 @@
   if (size(str)>1)
   { ">> Choose columnes of the matrix";
-    ">> (Enter = all columnes)"; 
+    ">> (Enter = all columnes)";
     "INPUT (number of columnes to use as integer-list 'i_1,i_2,.. ,i_t' ):";
     string columnes = read("");
@@ -826 +826 @@
       execute("l1= "+columnes[2*l-1]+";");
       B[l] = A[l1];
-      if(flag) { C[l]=D[l1];}   
+      if(flag) { C[l]=D[l1];}
     }
     A = matrix(B,nrows(A),size(B));
@@ -836 +836 @@
 proc negative_part(intvec iv)
 "
-RETURNS intvec of indices of jv having negative entries (or iv, if non) 
+RETURNS intvec of indices of jv having negative entries (or iv, if non)
 "
 {
@@ -842 +842 @@
    int    l,k;
    for (l=1;l<=size(iv);l=l+1)
-   { if (iv[l]<0) 
+   { if (iv[l]<0)
      {  k = k+1;
         jv[k]=l;
@@ -865 +865 @@
   matrix A    = imap(br,A);
   intmat degA[@r][@c];
-  if (homog(ideal(A))) 
+  if (homog(ideal(A)))
   { for (i=1;i<=@r;i=i+1)
     { for(j=1;j<=@c;j=j+1)
@@ -872 +872 @@
   }
  setring br;
-  kill nr; 
+  kill nr;
   return(degA);
 }
@@ -878 +878 @@
 proc homog_test(intvec w_vec, matrix Mo, matrix A)
 "
-Sub proc: return relative weight string of columnes of A with respect 
-          to the given w_vec and to Mo, or \"\" if not qh 
+Sub proc: return relative weight string of columnes of A with respect
+          to the given w_vec and to Mo, or \"\" if not qh
     NOTE: * means weight is not determined
 "
@@ -888 +888 @@
   int @r = nrows(A);
   int @c = ncols(A);
-  A = concat(matrix(ideal(Mo),@r,1),A); 
-  intmat a = find_ord(A,w_vec);      
+  A = concat(matrix(ideal(Mo),@r,1),A);
+  intmat a = find_ord(A,w_vec);
   intmat b[@r][@c];
   for (l=1;l<=@c;l=l+1)
-  { 
+  {
     for (k=1;k<=@r;k=k+1)
-    {  if (A[k,l+1]!=0) 
+    {  if (A[k,l+1]!=0)
        { b[k,l] = a[k,l+1]-a[k,1];}
     }
     tv = 0;
     for (k=1;k<=@r;k=k+1)
-    {  if (A[k,l+1]*A[k,1]!=0) 
+    {  if (A[k,l+1]*A[k,1]!=0)
        {tv = tv,b[k,l];}
     }
     if (size(tv)>1)
-    { k = tv[2]; 
+    { k = tv[2];
       tv = tv[2..size(tv)]; tv = tv -k;
-      if (tv==0) { @nv = @nv+string(-k)+",";} 
+      if (tv==0) { @nv = @nv+string(-k)+",";}
       else {return("");}
     }
@@ -916 +916 @@
 proc homog_t(intvec d_vec, matrix Fo, matrix A)
 "
-Sub-procedure: Computing relative (with respect to flatten(Fo)) weight_vec 
+Sub-procedure: Computing relative (with respect to flatten(Fo)) weight_vec
                of columnes of A (return zero if Fo or A not qh)
 "
@@ -934 +934 @@
    dv = dv[2..size(dv)];
    dv = dv-l;
- setring br; 
+ setring br;
    kill nr;
    return(dv);

Singular/LIB/factor.lib

@@ -1 @@
-// $Id: factor.lib,v 1.5 1998-05-05 11:55:23 krueger Exp $
+// $Id: factor.lib,v 1.6 1998-05-14 18:44:59 Singular Exp $
 //(RS)
 ///////////////////////////////////////////////////////////////////////////////
 
-version="$Id: factor.lib,v 1.5 1998-05-05 11:55:23 krueger Exp $";
+version="$Id: factor.lib,v 1.6 1998-05-14 18:44:59 Singular Exp $";
 info="
 LIBRARY:  factor.lib    PROCEDURES FOR CALLING THE REDUCE FACTORIZER
@@ -16 +16 @@
 "USAGE:   delete_dollar(s);  s = string
 RETURN:  string, with '$' replaced by ' '
-EXAMPLE: example delete_dollar; shows an example 
+EXAMPLE: example delete_dollar; shows an example
 "
 {
@@ -43 +43 @@
 NOTE:    due to a limitation of REDUCE, multivariate polynomials can only
          be factorized in characteristic 0
-             This proc runs under UNIX only
+         This proc runs under UNIX only
 EXAMPLE: example reduce_factor; shows an example
 "
@@ -69 +69 @@
   system( "sh", "chmod 700 " + scriptname );
   system( "sh", scriptname );
-  string resultstring = read( outname ); 
+  string resultstring = read( outname );
   if ( resultstring <> "" )
   {

Singular/LIB/fastsolv.lib

@@ -1 @@
-// 
-version="$Id: fastsolv.lib,v 1.3 1998-05-05 11:55:24 krueger Exp $";
+//
+version="$Id: fastsolv.lib,v 1.4 1998-05-14 18:44:59 Singular Exp $";
 info="";
 

Singular/LIB/finvar.lib

@@ -1 @@
-// $Id: finvar.lib,v 1.10 1998-05-05 11:55:25 krueger Exp $
+// $Id: finvar.lib,v 1.11 1998-05-14 18:45:00 Singular Exp $
 // author: Agnes Eileen Heydtmann, email:agnes@math.uni-sb.de
-// last change: 3.5.98 
+// last change: 3.5.98
 //////////////////////////////////////////////////////////////////////////////
-version="$Id: finvar.lib,v 1.10 1998-05-05 11:55:25 krueger Exp $"
+version="$Id: finvar.lib,v 1.11 1998-05-14 18:45:00 Singular Exp $"
 info="
 LIBRARY:  finvar.lib       LIBRARY TO CALCULATE INVARIANT RINGS & MORE
@@ -383 +383 @@
         { if (#[size(#)-2]=="")
           { "ERROR:   <string> may not be empty";
-            return();
-          }
+            return();
+          }
           string newring=#[size(#)-2];
           g=size(#)-3;
@@ -926 +926 @@
       { if (#[size(#)-1]=="")
         { "ERROR:   <string> may not be empty";
-          return();
-        }
+          return();
+        }
         string newring=#[size(#)-1];
         gen_num=size(#)-2;

Singular/LIB/general.lib

@@ -1 @@
-// $Id: general.lib,v 1.7 1998-05-05 11:55:27 krueger Exp $
+// $Id: general.lib,v 1.8 1998-05-14 18:45:03 Singular Exp $
 //system("random",787422842);
 //(GMG, last modified 22.06.96)
 ///////////////////////////////////////////////////////////////////////////////
 
-version="$Id: general.lib,v 1.7 1998-05-05 11:55:27 krueger Exp $";
+version="$Id: general.lib,v 1.8 1998-05-14 18:45:03 Singular Exp $";
 info="
 LIBRARY:  general.lib   PROCEDURES OF GENERAL TYPE
@@ -21 +21 @@
  sort(ideal/module);    sort generators according to monomial ordering
  sum(vector/id/..[,v]); add components of vector/ideal/...[with indices v]
- which(command);        searches for command and returns absolute
+ which(command);        searches for command and returns absolute
                         path, if found
            (parameters in square brackets [] are optional)
@@ -200 +200 @@
          killall(\"not\", \"type_name\");
 COMPUTE: killall(); kills all user-defined variables but not loaded procedures
-         killall(\"type_name\"); kills all user-defined variables, of type \"type_name\" 
+         killall(\"type_name\"); kills all user-defined variables, of type \"type_name\"
          killall(\"not\", \"type_name\"); kills all user-defined
          variables, except those of type \"type_name\" and except loaded procedures
@@ -216 +216 @@
       }
    }
-   else 
+   else
    {
      if( size(#)==1 )
@@ -224 +224 @@
           for ( joni=size(L); joni>0; joni-- )
           {
-             if( L[joni]=="LIB" or typeof(`L[joni]`)=="proc" ) 
+             if( L[joni]=="LIB" or typeof(`L[joni]`)=="proc" )
                { kill `L[joni]`; }
           }
        }
-       else 
+       else
        {
           for ( ; joni>2; joni-- )
@@ -649 +649 @@
    string fn = "/tmp/which_" + string(system("pid"));
    string pn;
-   if( typeof(command) != "string") 
-   {
-        return (pn);
+   if( typeof(command) != "string")
+   {
+     return (pn);
    }
    i = system("sh", "which " + command + " > " + fn);
@@ -665 +665 @@
    i = system("sh", "rm " + fn);
    if (rs == 0) {return (pn);}
-   else 
+   else
    {
      print (command + " not found ");

Singular/LIB/hnoether.lib

@@ -1 @@
-// $Id: hnoether.lib,v 1.6 1998-05-05 11:55:27 krueger Exp $
+// $Id: hnoether.lib,v 1.7 1998-05-14 18:45:05 Singular Exp $
 // author:  Martin Lamm,  email: lamm@mathematik.uni-kl.de
 // last change:           26.03.98
 ///////////////////////////////////////////////////////////////////////////////
 
-version="$Id: hnoether.lib,v 1.6 1998-05-05 11:55:27 krueger Exp $";
+version="$Id: hnoether.lib,v 1.7 1998-05-14 18:45:05 Singular Exp $";
 info="
 LIBRARY:  hnoether.lib   PROCEDURES FOR THE HAMBURGER-NOETHER-DEVELOPMENT
@@ -91 +91 @@
 }
 ///////////////////////////////////////////////////////////////////////////////
-proc T_Transform (poly f, int Q, int N) 
+proc T_Transform (poly f, int Q, int N)
 "// returns f(y,xy^Q)/y^NQ
 "
@@ -99 +99 @@
 }
 ///////////////////////////////////////////////////////////////////////////////
-proc T1_Transform (poly f, number d, int M) 
+proc T1_Transform (poly f, number d, int M)
 "// returns f(x,y+d*x^M)
 "
@@ -116 +116 @@
   int ggt=gcd(M,N);
   M=M/ggt; N=N/ggt;
-  list ts=extgcd(M,N); 
+  list ts=extgcd(M,N);
   int tau,sigma=ts[2],-ts[3];
   if (sigma<0) { tau=-tau; sigma=-sigma;}
@@ -144 +144 @@
   poly hilf;
  // dividiere f so lange durch x, wie die Div. aufgeht:
-  for (hilf=f/x; hilf*x==f; hilf=f/x) {f=hilf;} 
+  for (hilf=f/x; hilf*x==f; hilf=f/x) {f=hilf;}
   for (hilf=f/y; hilf*y==f; hilf=f/y) {f=hilf;} // gleiches fuer y
   return(list(T1(f),d));
@@ -156 +156 @@
 "{
   matrix mat = coeffs(coeffs(f,y)[J+1,1],x);
-  if (size(mat) <= I) { return(0);} 
+  if (size(mat) <= I) { return(0);}
   else { return(leadcoef(mat[I+1,1]));}
 }
@@ -198 +198 @@
   poly dif,g,l;
   if (gcd_ok!=0) {
- //-------------------- Berechne f/ggT(f,df/dx,df/dy) ------------------------ 
+ //-------------------- Berechne f/ggT(f,df/dx,df/dy) ------------------------
     dif=diff(f,x);
     if (dif==0) { g=f; }        // zur Beschleunigung
@@ -322 +322 @@
   if ((leadcoef(f)<-16001) or (leadcoef(f)>16001)) {verbrecher=lead(f);}
   leitexp=leadexp(f);
-  if (( ((leitexp[1] % 32003) == 0)   and (leitexp[1]<>0)) 
+  if (( ((leitexp[1] % 32003) == 0)   and (leitexp[1]<>0))
      or ( ((leitexp[2] % 32003) == 0) and (leitexp[2]<>0)) )
        {verbrecher=lead(f);}
@@ -445 +445 @@
  string ringchar=charstr(basering);
  map xytausch = basering,y,x;
- if ((p!=0) and (ringchar != string(p))) { 
+ if ((p!=0) and (ringchar != string(p))) {
                             // coefficient field is extension of Z/pZ
-   execute "int n_elements="+ringchar[1,size(ringchar)-2]+";"; 
+   execute "int n_elements="+ringchar[1,size(ringchar)-2]+";";
                             // number of elements of actual ring
    number generat=par(1);   // generator of the coefficient field of the ring
@@ -509 +509 @@
     }
     else {
-      if ((str=="s") and (testerg==1)) { 
+      if ((str=="s") and (testerg==1)) {
        "(*) attention: it could be that the factor is only one in char 32003!";
         f=polyhinueber(test_sqr);
@@ -612 +612 @@
         delta = koeff(f,(M/ e)*p^l,(N/ e)*p^l*(eps-1)) / (-1*eps*c);
 
-        if ((ringchar != string(p)) and (delta != 0)) { 
+        if ((ringchar != string(p)) and (delta != 0)) {
  //- coeff. field is not Z/pZ => we`ve to correct delta by taking (p^l)th root-
           if (delta == generat) {exponent=1;}
@@ -1204 +1204 @@
 }
 example
-{ 
+{
   if (nameof(basering)=="HNEring") {
    def rettering=HNEring;
@@ -1303 +1303 @@
  }
 if (size(#) != 0) {
-   "// basering is now 'displayring' containing ideal 'HNE'"; 
+   "// basering is now 'displayring' containing ideal 'HNE'";
    keepring(displayring);
    export(HNE);
@@ -1373 +1373 @@
  //- finde alle Monome auf der Geraden durch A und C (unterhalb gibt's keine) -
    hilf=jet(f,A[2]*C[1]-A[1]*C[2],intvec(A[2]-C[2],C[1]-A[1]));
-       
+
    H=leadexp(xytausch(hilf));
    D=H[2],H[1];
@@ -1562 +1562 @@
      }
      else {
-       execute "ring extdguenstig=("+charstr(basering)+"),(x,y),ls;";      
+       execute "ring extdguenstig=("+charstr(basering)+"),(x,y),ls;";
      }
   }
@@ -1753 +1753 @@
      delta = koeff(f,(M/ e)*p^l,(N/ e)*p^l*(eps-1)) / (-1*eps*c);
 
-     if ((charstr(basering) != string(p)) and (delta != 0)) { 
+     if ((charstr(basering) != string(p)) and (delta != 0)) {
  //------ coefficient field is not Z/pZ => (p^l)th root is not identity -------
        delta=0;
@@ -1781 +1781 @@
 "USAGE:   reddevelop(f); f poly
 RETURN:  Hamburger-Noether development of f :
-         A list of lists in the form of develop(f); each entry contains the 
+         A list of lists in the form of develop(f); each entry contains the
          data for one of the branches of f.
          For more details type 'help develop;'
@@ -1910 +1910 @@
    }
    else {
-     if ((str=="s") and (testerg==1)) { 
+     if ((str=="s") and (testerg==1)) {
        "(*)attention: it could be that the factor is only one in char 32003!";
        f=polyhinueber(test_sqr);
@@ -1976 +1976 @@
  }
  //---------------------- Test, ob f teilbar durch x oder y -------------------
- if (subst(f,y,0)==0) { 
+ if (subst(f,y,0)==0) {
    f=f/y; NullHNEy=1; }             // y=0 is a solution
- if (subst(f,x,0)==0) { 
+ if (subst(f,x,0)==0) {
    f=f/x; NullHNEx=1; }             // x=0 is a solution
 
@@ -2077 +2077 @@
 }
 example
-{ 
+{
   if (nameof(basering)=="HNEring") {
    def rettering=HNEring;
@@ -2283 +2283 @@
         }
         else {
-          " Change of basering necessary!!";
-          if (defined(Protokoll)) { teiler,"is not properly factored!"; }
-          if (needext==0) { poly zerlege=teiler; }
-          needext=1;
+          " Change of basering necessary!!";
+          if (defined(Protokoll)) { teiler,"is not properly factored!"; }
+          if (needext==0) { poly zerlege=teiler; }
+          needext=1;
         }
       }
@@ -2293 +2293 @@
     else { deltais=ideal(delta); eis=e;}
     if (defined(Protokoll)) {"roots of char. poly:";deltais;
-                             "with multiplicities:",eis;}
+                             "with multiplicities:",eis;}
     if (needext==1) {
  //--------------------- fuehre den Ringwechsel aus: --------------------------
       ringischanged=1;
       if ((size(parstr(basering))>0) && string(minpoly)=="0") {
-        " ** We've had bad luck! The HNE cannot completely be calculated!";
+        " ** We've had bad luck! The HNE cannot completely be calculated!";
                                    // HNE in transzendenter Erw. fehlgeschlagen
         kill zerlege;
-        ringischanged=0; break;    // weiter mit gefundenen Faktoren
+        ringischanged=0; break;    // weiter mit gefundenen Faktoren
       }
       if (parstr(basering)=="") {
-        EXTHNEnumber++;
-        splitring(zerlege,"EXTHNEring("+string(EXTHNEnumber)+")");
-        poly transf=0;
-        poly transfproc=0;
+        EXTHNEnumber++;
+        splitring(zerlege,"EXTHNEring("+string(EXTHNEnumber)+")");
+        poly transf=0;
+        poly transfproc=0;
       }
       else {
-        if (defined(translist)) { kill translist; } // Vermeidung einer Warnung
-        if (numberofRingchanges>1) {  // ein Ringwechsel hat nicht gereicht
-         list translist=splitring(zerlege,"",list(transf,transfproc));
-         poly transf=translist[1]; poly transfproc=translist[2];
+        if (defined(translist)) { kill translist; } // Vermeidung einer Warnung
+        if (numberofRingchanges>1) {  // ein Ringwechsel hat nicht gereicht
+         list translist=splitring(zerlege,"",list(transf,transfproc));
+         poly transf=translist[1]; poly transfproc=translist[2];
         }
         else {
-         if (defined(transfproc)) { // in dieser proc geschah schon Ringwechsel
-          EXTHNEnumber++;
-          list translist=splitring(zerlege,"EXTHNEring("
+         if (defined(transfproc)) { // in dieser proc geschah schon Ringwechsel
+          EXTHNEnumber++;
+          list translist=splitring(zerlege,"EXTHNEring("
                +string(EXTHNEnumber)+")",list(a,transfproc));
-          poly transf=translist[1];
+          poly transf=translist[1];
           poly transfproc=translist[2];
-         }
-         else {
-          EXTHNEnumber++;
-          list translist=splitring(zerlege,"EXTHNEring("
+         }
+         else {
+          EXTHNEnumber++;
+          list translist=splitring(zerlege,"EXTHNEring("
                +string(EXTHNEnumber)+")",a);
-          poly transf=translist[1];
-          poly transfproc=transf;
-        }}
+          poly transf=translist[1];
+          poly transfproc=transf;
+        }}
       }
  //----------------------------------------------------------------------------
@@ -2395 +2395 @@
                                   // aktualisiere Vektor mit den hqs
        if (eis[j]>1) {
-        transformiert=transformiert/y;
-        if (subst(transformiert,y,0)==0) {
+        transformiert=transformiert/y;
+        if (subst(transformiert,y,0)==0) {
  "THE TEST FOR SQUAREFREENESS WAS BAD!! The polynomial was NOT squarefree!!!";}
-        else {
+        else {
  //------ Spezialfall (###) eingetreten: Noch weitere Zweige vorhanden --------
           eis[j]=eis[j]-1;
-        }
+        }
        }
       }
@@ -2433 +2433 @@
  //-------- Bereitstellung von Speicherplatz fuer eine neue Zeile: ------------
         HNEs=set_list(HNEs,intvec(hnezaehler,zeile+zl),ideal(0));
-               
+
         M1=N1; N1=R1; R1=M1%N1; Q1=M1 / N1;
        }

Singular/LIB/inout.lib

@@ -1 @@
-// $Id: inout.lib,v 1.5 1998-05-05 11:55:29 krueger Exp $
+// $Id: inout.lib,v 1.6 1998-05-14 18:45:07 Singular Exp $
 // system("random",787422842);
 // (GMG/BM, last modified 22.06.96)
 ///////////////////////////////////////////////////////////////////////////////
 
-version="$Id: inout.lib,v 1.5 1998-05-05 11:55:29 krueger Exp $";
+version="$Id: inout.lib,v 1.6 1998-05-14 18:45:07 Singular Exp $";
 info="
 LIBRARY:  inout.lib     PROCEDURES FOR MANIPULATING IN- AND OUTPUT
@@ -549 +549 @@
    }
    newvar = newvar[2,size(newvar)-1];
-   
+
    execute "ring newP=("+newchar+"),("+newvar+"),("+neword+");";
    def id = imap(P,id);

Singular/LIB/invar.lib

@@ -1 @@
-// $Id: invar.lib,v 1.6 1998-05-05 11:55:30 krueger Exp $
+// $Id: invar.lib,v 1.7 1998-05-14 18:45:08 Singular Exp $
 ///////////////////////////////////////////////////////
 // invar.lib
@@ -7 +7 @@
 //////////////////////////////////////////////////////
 
-version="$Id: invar.lib,v 1.6 1998-05-05 11:55:30 krueger Exp $";
+version="$Id: invar.lib,v 1.7 1998-05-14 18:45:08 Singular Exp $";
 info="
 LIBRARY: invar.lib PROCEDURES FOR COMPUTING INVARIANTS OF (C,+)-ACTIONS
@@ -21 +21 @@
   // the ring of invariants is finitey generated)
   // if choose<>0 it computes invariants up to degree choose
-    
+
   actionIsProper(matrix m)
   // returns 1 if the action of the additive group defined by the
@@ -50 +50 @@
   return(m);
 }
-example 
+example
 { "EXAMPLE:"; echo = 2;
    ring q=0,(x,y,z,u,v,w),dp;
@@ -64 +64 @@
 proc der (matrix m, poly f)
 "USAGE:   der(m,f);  m matrix, f poly
-RETURN:  poly= application of the vectorfield m befined by the matrix m 
+RETURN:  poly= application of the vectorfield m befined by the matrix m
          (m[i,1] are the coefficients of d/dx(i)) to f
-NOTE:    
+NOTE:
 EXAMPLE: example der; shows an example
 "
@@ -73 +73 @@
   return(mh[1,1]);
 }
-example 
+example
 { "EXAMPLE:"; echo = 2;
    ring q=0,(x,y,z,u,v,w),dp;
@@ -91 +91 @@
 "USAGE:   actionIsProper(m); m matrix
 RETURN:  int= 1 if is proper, 0 else
-NOTE:    
+NOTE:
 EXAMPLE: example actionIsProper; shows an example
 "
@@ -120 +120 @@
         delta=der(@m,delta);
      }
-     id=id+ideal(inv);   
+     id=id+ideal(inv);
   }
   i=inSubring(@t,id)[1];
@@ -126 +126 @@
   return(i);
 }
-example 
+example
 { "EXAMPLE:"; echo = 2;
 
@@ -149 +149 @@
 proc reduction(poly p, ideal dom, list #)
 "USAGE:   reduction(p,dom,q); p poly, dom ideal, q (optional) monomial
-RETURN:  poly= (p-H(f1,...,fr))/q^a, if Lt(p)=H(Lt(f1),...,Lt(fr)) for 
+RETURN:  poly= (p-H(f1,...,fr))/q^a, if Lt(p)=H(Lt(f1),...,Lt(fr)) for
                some polynomial H in r variables over the base field,
                a maximal such that q^a devides p-H(f1,...,fr),
                dom =(f1,...,fr)
-NOTE:    
+NOTE:
 EXAMPLE: example reduction; shows an example
 "
@@ -160 +160 @@
   int z=size(dom);
   def bsr=basering;
- 
+
   //arranges the monomial v for elimination
   poly v=var(1);
@@ -170 +170 @@
   //changes the basering bsr to bsr[@(0),...,@(z)]
   execute "ring s="+charstr(basering)+",("+varstr(basering)+",@(0..z)),dp;";
-  
+
   //costructes the ideal dom=(p-@(0),dom[1]-@(1),...,dom[z]-@(z))
   ideal dom=imap(bsr,dom);
@@ -178 +178 @@
   }
   dom=lead(imap(bsr,p))-@(0),dom;
- 
+
   //eliminates the variables of the basering bsr
   //i.e. computes dom intersected with K[@(0),...,@(z)]
@@ -197 +197 @@
         poly re=psi(h);
 
-        // devides by the maximal power of #[1] 
+        // devides by the maximal power of #[1]
         if (size(#)>0)
         {
@@ -206 +206 @@
         }
 
-        return(re); 
+        return(re);
      }
   }
@@ -212 +212 @@
   return(p);
 }
-example 
+example
 { "EXAMPLE:"; echo = 2;
    ring q=0,(x,y,z,u,v,w),dp;
@@ -224 +224 @@
 
 proc completeReduction(poly p, ideal dom, list #)
-"USAGE:   completeReduction(p,dom,q); p poly, dom ideal, 
+"USAGE:   completeReduction(p,dom,q); p poly, dom ideal,
                                      q (optional) monomial
 RETURN:  poly= the polynomial p reduced with dom via the procedure
                reduction as long as possible
-NOTE:    
+NOTE:
 EXAMPLE: example completeReduction; shows an example
 "
@@ -241 +241 @@
   return(p2);
 }
-example 
+example
 { "EXAMPLE:"; echo = 2;
    ring q=0,(x,y,z,u,v,w),dp;
@@ -256 +256 @@
               0,string(h(@(0),...,@(size(dom)))) :if there is only a nonlinear relation
               h(p,dom[1],...,dom[size(dom)])=0.
-NOTE:    
+NOTE:
 EXAMPLE: example inSubring; shows an example
 "
@@ -303 +303 @@
   return(l);
 }
-example 
+example
 { "EXAMPLE:"; echo = 2;
    ring q=0,(x,y,z,u,v,w),dp;
@@ -320 +320 @@
                it is assumed that m(q) and h are invariant
                the sum above is divided by h as much as possible
-NOTE:    
+NOTE:
 EXAMPLE: example localInvar; shows an example
 "
@@ -339 +339 @@
     return(inv);
   }
-  while (dif!=0) 
+  while (dif!=0)
   {
     inv=(a*inv)+(coeff*dif);
@@ -352 +352 @@
   return(inv);
 }
-example 
+example
 { "EXAMPLE:"; echo = 2;
    ring q=0,(x,y,z),dp;
@@ -372 +372 @@
                in the subring generated by id which are divisible by q
                it is assumed that m(p) and q are invariant
-               the elements mentioned  above are computed and divided by q 
+               the elements mentioned  above are computed and divided by q
                as much as possible
                the ideal karl contains all invariants computed yet
-NOTE:    
+NOTE:
 EXAMPLE: example furtherInvar; shows an example
 "
@@ -394 +394 @@
   setring @r;
   map phi=r1,su;
-  setring r1;  
+  setring r1;
   // computes the kernel of phi
-  execute "ideal ker=preimage(@r,phi,null)"; 
+  execute "ideal ker=preimage(@r,phi,null)";
   // defines the map psi : r1 ---> @r defined by y(i) ---> id[i]
   setring @r;
@@ -437 +437 @@
         }
      }
-    
+
   }
   setring @r;
@@ -443 +443 @@
   return(l);
 }
-example 
+example
 { "EXAMPLE:"; echo = 2;
    ring r=0,(x,y,z,u),dp;
@@ -461 +461 @@
 proc invariantRing(matrix m, poly p, poly q,list #)
 "USAGE:   invariantRing(m,p,q); m matrix, p,q poly
-RETURN:  ideal= the invariants of the vectorfield m=Sum m[i,1]*d/dx(i) 
+RETURN:  ideal= the invariants of the vectorfield m=Sum m[i,1]*d/dx(i)
                 p,q variables with m(p)=q invariant
 NOTE:
@@ -474 +474 @@
      bou=#[1];
   }
-  int z;  
+  int z;
   ideal karl;
   ideal k1=1;
@@ -496 +496 @@
   while (size(k1)!=0)
  {
-    // test if the new invariants are already in the ring generated 
+    // test if the new invariants are already in the ring generated
     // by the invariants we constructed already
     it++;
@@ -512 +512 @@
     karl=k2[2];
     k1=sortier(k1);
-    z=size(k1);    
+    z=size(k1);
     for (i=1;i<=z;i++)
     {
@@ -541 +541 @@
   return(karl);
 }
-example 
+example
 { "EXAMPLE:"; echo = 2;
 
   //Winkelmann: free action but Spec k[x(1),...,x(5)]---> Spec In-
   //variantring is not surjective
-  
+
   ring rw=0,(x(1..5)),dp;
   matrix m[5][1];
@@ -554 +554 @@
   ideal in=invariantRing(m,x(3),x(1),0);
   in;
-  
+
   //Deveney/Finston: The ring of invariants is not finitely generated
-  
+
   ring rf=0,(x(1..7)),dp;
   matrix m[7][1];
@@ -565 +565 @@
   ideal in=invariantRing(m,x(4),x(1),6);
   in;
-  
-  
+
+
   //Deveney/Finston:Proper Ga-action which is not locally trivial
   //r[x(1),...,x(5)] is not flat over the ring of invariants
-  
+
   ring rd=0,(x(1..5)),dp;
   matrix m[5][1];
@@ -577 +577 @@
   ideal in=invariantRing(m,x(3),x(1));
   in;
-  
+
   actionIsProper(m);
-  
+
   //computes the relations between the invariants
   int z=size(in);
@@ -586 +586 @@
   setring rd;
   map phi=r1,in;
-  setring r1;  
-  ideal ker=preimage(rd,phi,null); 
+  setring r1;
+  ideal ker=preimage(rd,phi,null);
   ker;
-  
+
   //the discriminant
-  
+
   ring r=0,(x(1..2),y(1..2),z,t),dp;
   poly p=z+(1+x(1)*y(2)^2)*t+x(1)*y(1)*y(2)*t^2+(1/3)*x(1)*y(1)^2*t^3;
-  
+
   matrix m[5][5];
   m[1,1]=z;
@@ -621 +621 @@
   m[5,4]=2*x(1)*y(1)*y(2);
   m[5,5]=x(1)*y(1)^2;
-  
+
   poly disc=9*det(m)/(x(1)^2*y(1)^4);
-  
+
   LIB "invar.lib";
   matrix n[6][1];
@@ -629 +629 @@
   n[4,1]=y(1);
   n[5,1]=1+x(1)*y(2)^2;
-  
+
   der(n,disc);
-  
+
   //x(1)^3*y(2)^6-6*x(1)^2*y(1)*y(2)^3*z+6*x(1)^2*y(2)^4+9*x(1)*y(1)^2*z^2-18*x(1)*y(1)*y(2)*z+9*x(1)*y(2)^2+4
-  
-  
+
+
   //constructive approach to Weizenbcks theorem
-  
+
   int n=5;
-  
+
   ring w=0,(x(1..n)),wp(1..n);
-  
+
   // definition of the vectorfield m=sum m[i]*d/dx(i)
   matrix m[n][1];
@@ -650 +650 @@
   ideal in=invariantRing(m,x(2),x(1),0);
   in;
-  
-  
-  
-}
+
+
+
+}

Singular/LIB/makedbm.lib

@@ -1 @@
-// $Id: makedbm.lib,v 1.7 1998-05-05 11:55:31 krueger Exp $
+// $Id: makedbm.lib,v 1.8 1998-05-14 18:45:09 Singular Exp $
 //=========================================================================
 //
@@ -6 +6 @@
 //=============================================================================
 
-version="$Id: makedbm.lib,v 1.7 1998-05-05 11:55:31 krueger Exp $";
+version="$Id: makedbm.lib,v 1.8 1998-05-14 18:45:09 Singular Exp $";
 info="
 LIBRARY:  makedbm.lib     some usefull tools needed by the Arnold-Classifier.
@@ -38 +38 @@
   string s="";
   s=read(l);
-  while( s != "" ) 
+  while( s != "" )
   {
     s,"=",read(l,s);
@@ -237 +237 @@
 
 proc read_sing_dbm
-{ 
+{
   link l="DBM: NFlist";
   "A[k]     = "+read(l, "A[k]");

Singular/LIB/matrix.lib

@@ -1 @@
-// $Id: matrix.lib,v 1.6 1998-05-05 11:55:31 krueger Exp $
+// $Id: matrix.lib,v 1.7 1998-05-14 18:45:10 Singular Exp $
 // (GMG/BM, last modified 22.06.96)
 ///////////////////////////////////////////////////////////////////////////////
 
-version="$Id: matrix.lib,v 1.6 1998-05-05 11:55:31 krueger Exp $";
+version="$Id: matrix.lib,v 1.7 1998-05-14 18:45:10 Singular Exp $";
 info="
 LIBRARY:  matrix.lib    PROCEDURES FOR MATRIX OPERATIONS
@@ -298 +298 @@
 //---------------------------- trivial cases ----------------------------------
    int ii;
-   if( n <= 0 ) 
-   {
-      if( typeof(A)=="matrix" ) 
-      { 
-         return (unitmat(nrows(A))); 
+   if( n <= 0 )
+   {
+      if( typeof(A)=="matrix" )
+      {
+         return (unitmat(nrows(A)));
       }
-      if( typeof(A)=="intmat" ) 
-      { 
+      if( typeof(A)=="intmat" )
+      {
          intmat B[nrows(A)][nrows(A)];
          for( ii=1; ii<=nrows(A); ii++ )
@@ -311 +311 @@
             B[ii,ii] = 1;
          }
-         return (B); 
+         return (B);
       }
    }

Singular/LIB/normal.lib

@@ -6 +6 @@
 ///////////////////////////////////////////////////////////////////////////////
 
-version="$Id: normal.lib,v 1.5 1998-05-05 11:55:32 krueger Exp $";
+version="$Id: normal.lib,v 1.6 1998-05-14 18:45:10 Singular Exp $";
 info="
 LIBRARY: normal.lib: PROCEDURE FOR NORMALIZATION (I)
 
   normal(ideal I)
-  // computes a set of rings such that their product is the 
-  // normalization of the reduced basering/I 
+  // computes a set of rings such that their product is the
+  // normalization of the reduced basering/I
 ";
 
-LIB "sing.lib"; 
+LIB "sing.lib";
 LIB "primdec.lib";
 LIB "elim.lib";
@@ -29 +29 @@
          p    = nonzero divisor of R
 RETURN:  1 if R = R:J, 0 if not
-EXAMPLE: example isR_HomJR;  shows an example   
+EXAMPLE: example isR_HomJR;  shows an example
 "
 {
@@ -46 +46 @@
    n=1;
    for (ii=1; ii<=size(f); ii++ )
-   { 
-      if ( reduce(f[ii],lp) != 0) 
+   {
+      if ( reduce(f[ii],lp) != 0)
       { n = 0; break; }
    }
@@ -76 +76 @@
 NOTE:    This is useful when enlarging P but keeping the weights of the old
          variables
-EXAMPLE: example extraweight;  shows an example   
+EXAMPLE: example extraweight;  shows an example
 "
 {
@@ -92 +92 @@
       os = osP[fi+1,find(osP,")",fi)-fi-1];
       if( find(os,",") )
-      { 
+      {
          execute "nw = "+os+";";
          if( size(nw) > ii )
@@ -105 +105 @@
       {
          execute "q = "+os+";";
-         if( q > ii ) 
-         { 
+         if( q > ii )
+         {
             nw = 0; nw[q-ii] = 0;
             nw = nw + 1;          //creates an intvec 1,...,1 of length q-ii
@@ -118 +118 @@
    }
 //-------------- adjust weight vector to length = nvars(P)  -------------------
-   if( fo > 1 ) 
+   if( fo > 1 )
    {                                            // case when weights were found
-      rw = rw[2..size(rw)]; 
-      if( size(rw) > nvars(P) )  
-      { 
-         rw = rw[1..nvars(P)]; 
-      }
-      if( size(rw) < nvars(P) ) 
-      { 
-         nw=0; nw[nvars(P)-size(rw)]=0; nw=nw+1; rw=rw,nw; 
-      }
-   }
-   else 
+      rw = rw[2..size(rw)];
+      if( size(rw) > nvars(P) )
+      {
+         rw = rw[1..nvars(P)];
+      }
+      if( size(rw) < nvars(P) )
+      {
+         nw=0; nw[nvars(P)-size(rw)]=0; nw=nw+1; rw=rw,nw;
+      }
+   }
+   else
    {                                         // case when no weights were found
-      rw[nvars(P)]= 0; rw=rw+1; 
+      rw[nvars(P)]= 0; rw=rw+1;
    }
    return(rw);
@@ -162 +162 @@
          R is the quotient ring of P modulo the standard basis SBid
 RETURN:  a list of two objects
-         _[1]: a polynomial ring, containing two ideals, 'endid' and 'endphi' 
+         _[1]: a polynomial ring, containing two ideals, 'endid' and 'endphi'
                s.t. _[1]/endid = Hom_R(J,J) and
                endphi describes the canonical map R -> Hom_R(J,J)
          _[2]: an integer which is 1 if phi is an isomorphism, 0 if not
-EXAMPLE: example HomJJ;  shows an example   
+EXAMPLE: example HomJJ;  shows an example
 "
 {
@@ -185 +185 @@
 
 //---- set attributes for special cases where algorithm can be simplified -----
-   if( homo==1 )  
-   { 
+   if( homo==1 )
+   {
       rw = extraweight(P);
    }
@@ -218 +218 @@
 
 //---------- computation of p*Hom(J,J) as R-ideal -----------------------------
-   f  = quotient(p*J,J); 
-   if(y==1)      
-   {               
+   f  = quotient(p*J,J);
+   if(y==1)
+   {
       "the module Hom(rad(J),rad(J)) presented by the values on";
       "the non-zerodivisor";
@@ -243 +243 @@
    rf = interred(reduce(f,f2));       // represents p*Hom(J,J)/p*R = Hom(J,J)/R
    if ( size(rf) == 0 )
-   { 
+   {
       if ( homog(f) && find(ordstr(basering),"s")==0 )
       {
-         ring newR1 = char(P),(X(1..nvars(P))),(a(rw),dp);  
+         ring newR1 = char(P),(X(1..nvars(P))),(a(rw),dp);
       }
       else
       {
-         ring newR1 = char(P),(X(1..nvars(P))),dp;  
+         ring newR1 = char(P),(X(1..nvars(P))),dp;
       }
       ideal endphi = maxideal(1);
-      ideal endid = fetch(P,id); 
+      ideal endid = fetch(P,id);
       attrib(endid,"isCohenMacaulay",isCo);
       attrib(endid,"isPrim",isPr);
@@ -306 +306 @@
    q = size(f);
    syzf = syz(f);
-       
+
    if ( homo==1 )
    {
@@ -312 +312 @@
       for ( ii=2; ii<=q; ii++ )
       {
-         rw  = rw, deg(f[ii])-deg(f[1]);       
-         rw1 = rw1, deg(f[ii])-deg(f[1]);       
-      }
-      ring newR1 = char(R),(X(1..nvars(R)),T(1..q)),(a(rw1),dp);  
+         rw  = rw, deg(f[ii])-deg(f[1]);
+         rw1 = rw1, deg(f[ii])-deg(f[1]);
+      }
+      ring newR1 = char(R),(X(1..nvars(R)),T(1..q)),(a(rw1),dp);
    }
    else
    {
-      ring newR1 = char(R),(X(1..nvars(R)),T(1..q)),dp;  
+      ring newR1 = char(R),(X(1..nvars(R)),T(1..q)),dp;
    }
 
@@ -325 +325 @@
    ideal SBid = psi1(SBid);
    attrib(SBid,"isSB",1);
-   
+
  qring newR = std(SBid);
    map psi = R,ideal(X(1..nvars(R)));
@@ -336 +336 @@
 
 //---------- computation of Hom(J,J) as ring ----------------------------------
-// determine kernel of: R[T1,...,Tq] -> J:J >-> R[1/p]=R[t]/(t*p-1), 
+// determine kernel of: R[T1,...,Tq] -> J:J >-> R[1/p]=R[t]/(t*p-1),
 // Ti -> fi/p -> t*fi (p=f1=f[1]), to get ring structure. This is of course
 // the same as the kernel of R[T1,...,Tq] -> pJ:J >-> R, Ti -> fi.
@@ -344 +344 @@
    pf = f[1]*f;
    T = matrix(ideal(T(1..q)),1,q);
-   Lin = ideal(T*syzf); 
+   Lin = ideal(T*syzf);
    if(y==1)
    {
@@ -379 +379 @@
    else
    {
-      ring newRing = char(R),(X(1..nvars(R)),T(2..q)),dp;  
+      ring newRing = char(R),(X(1..nvars(R)),T(2..q)),dp;
    }
 
@@ -386 +386 @@
 
    map phi = basering,maxideal(1);
-   list Le = elimpart(endid);  
+   list Le = elimpart(endid);
            //this proc and the next loop try to
    q = size(Le[2]);                 //substitute as many variables as possible
-   rw1 = 0;                      
+   rw1 = 0;
    rw1[nvars(basering)] = 0;
    rw1 = rw1+1;
@@ -400 +400 @@
       kill ps;
 
-      for( ii=1; ii<=size(rw1); ii++ ) 
-      { 
-         if( Le[4][ii]==0 ) 
-         {  
+      for( ii=1; ii<=size(rw1); ii++ )
+      {
+         if( Le[4][ii]==0 )
+         {
             rw1[ii]=0;                             //look for substituted vars
          }
@@ -409 +409 @@
       Le=elimpart(endid);
       q = q + size(Le[2]);
-   }     
+   }
    endphi = phi(endphi);
 
@@ -417 +417 @@
 
    if (homo==1 && nvars(newRing)-q >1 && size(endid) >0 )
-   {                           
+   {
       jj=1;
       for( ii=2; ii<size(rw1); ii++)
-      {  
+      {
          jj++;
-         if( rw1[ii]==0 )  
-         { 
+         if( rw1[ii]==0 )
+         {
             rw=rw[1..jj-1],rw[jj+1..size(rw)];
-            jj=jj-1; 
+            jj=jj-1;
          }
       }
@@ -435 +435 @@
    else
    {
-      ring lastRing = char(R),(T(1..nvars(newRing)-q)),dp;  
-   }
-
-   ideal lastmap; 
+      ring lastRing = char(R),(T(1..nvars(newRing)-q)),dp;
+   }
+
+   ideal lastmap;
    q = 1;
    for(ii=1; ii<=size(rw1); ii++ )
@@ -444 +444 @@
       if ( rw1[ii]==1 ) { lastmap[ii] = T(q); q=q+1; }
       if ( rw1[ii]==0 ) { lastmap[ii] = 0; }
-   }      
+   }
    map phi = newRing,lastmap;
    ideal endid  = phi(endid);
@@ -495 +495 @@
   list L   = HomJJ(Li);
   def end = L[1];      // defines ring L[1], containing ideals endid and endphi
-  setring end;         // makes end the basering 
+  setring end;         // makes end the basering
   end;
   endid;               // end/endid is isomorphic to End(r/id) as ring
@@ -501 +501 @@
   psi;
 
-  ring r   = 32003,(x,y,z),dp;  
+  ring r   = 32003,(x,y,z),dp;
   ideal id = x2-xy-xz+yz;
   ideal J =y-z,x-z;
@@ -508 +508 @@
   list L   = HomJJ(Li,0);
   def end = L[1];      // defines ring L[1], containing ideals endid and endphi
-  setring end;         // makes end the basering 
+  setring end;         // makes end the basering
   end;
   endid;               // end/endid is isomorphic to End(r/id) as ring
@@ -534 +534 @@
       if( typeof(attrib(id,"isEquidimensional"))=="int" )
       {
-        if(attrib(id,"isEquidimensional")==1)  
+        if(attrib(id,"isEquidimensional")==1)
         {
-           attrib(prim[1],"isEquidimensional",1); 
+           attrib(prim[1],"isEquidimensional",1);
         }
       }
@@ -545 +545 @@
       if( typeof(attrib(id,"isCompleteIntersection"))=="int" )
       {
-        if(attrib(id,"isCompleteIntersection")==1)  
+        if(attrib(id,"isCompleteIntersection")==1)
         {
-           attrib(prim[1],"isCompleteIntersection",1); 
+           attrib(prim[1],"isCompleteIntersection",1);
         }
       }
@@ -554 +554 @@
          attrib(prim[1],"isCompleteIntersection",0);
       }
-      
+
       if( typeof(attrib(id,"isPrim"))=="int" )
       {
@@ -565 +565 @@
       if( typeof(attrib(id,"isIsolatedSingularity"))=="int" )
       {
-         if(attrib(id,"isIsolatedSingularity")==1) 
+         if(attrib(id,"isIsolatedSingularity")==1)
              {attrib(prim[1],"isIsolatedSingularity",1); }
       }
       else
       {
-         attrib(prim[1],"isIsolatedSingularity",0);        
+         attrib(prim[1],"isIsolatedSingularity",0);
       }
       if( typeof(attrib(id,"isCohenMacaulay"))=="int" )
       {
-         if(attrib(id,"isCohenMacaulay")==1) 
+         if(attrib(id,"isCohenMacaulay")==1)
            { attrib(prim[1],"isCohenMacaulay",1); }
       }
       else
       {
-         attrib(prim[1],"isCohenMacaulay",0);       
+         attrib(prim[1],"isCohenMacaulay",0);
       }
       if( typeof(attrib(id,"isRegInCodim2"))=="int" )
@@ -588 +588 @@
       else
       {
-          attrib(prim[1],"isRegInCodim2",0);       
+          attrib(prim[1],"isRegInCodim2",0);
       }
       return(normalizationPrimes(prim[1],maxideal(1)));
@@ -622 +622 @@
          if( typeof(attrib(id,"isEquidimensional"))=="int" )
          {
-           if(attrib(id,"isEquidimensional")==1)  
+           if(attrib(id,"isEquidimensional")==1)
            {
-              attrib(prim[i],"isEquidimensional",1); 
+              attrib(prim[i],"isEquidimensional",1);
            }
          }
@@ -630 +630 @@
          {
             attrib(prim[i],"isEquidimensional",0);
-         }      
+         }
          if( typeof(attrib(id,"isIsolatedSingularity"))=="int" )
          {
-            if(attrib(id,"isIsolatedSingularity")==1) 
+            if(attrib(id,"isIsolatedSingularity")==1)
              {attrib(prim[i],"isIsolatedSingularity",1); }
          }
          else
          {
-            attrib(prim[i],"isIsolatedSingularity",0);        
+            attrib(prim[i],"isIsolatedSingularity",0);
          }
-   
+
          keepresult=normalizationPrimes(prim[i],maxideal(1));
          for(j=1;j<=size(keepresult);j++)
@@ -695 +695 @@
          ideal PP=fetch(BAS,ihp);
          export PP;
-         export KK;     
+         export KK;
          result=newR7;
          setring BAS;
@@ -866 +866 @@
   //    if((dim(SM[1]))==depth)
   //    {
-  //    attrib(SM[2],"isCohenMacaulay",1);    
+  //    attrib(SM[2],"isCohenMacaulay",1);
   //    "it is CohenMacaulay";
-  //    }  
+  //    }
   // }
-   
+
    //compute the singular locus+lower dimensional components
    if(((attrib(SM[2],"isIsolatedSingularity")==0)||(homog(SM[2])==0))
@@ -953 +953 @@
             "                                  ";
             maxideal(1);
-            "                                  "; 
+            "                                  ";
             "                                  ";
          }
@@ -970 +970 @@
   //          export SB,MB;
   //          result=BAS;
-  //          return(result); 
+  //          return(result);
   //       }
   //       timer-ti;
@@ -979 +979 @@
          if(RR[2]==0)
          {
-            def newR=RR[1];     
+            def newR=RR[1];
             setring newR;
             map psi=BAS,endphi;
@@ -987 +987 @@
         //    timer-ti;
             setring BAS;
-            return(tluser); 
+            return(tluser);
          }
          MB=SM[2];
@@ -999 +999 @@
          setring BAS;
          return(result);
- 
+
        }
        else
-       {        
+       {
           ideal id=qAnn+SM[2];
 
@@ -1033 +1033 @@
        }
    }
-   
+
    //test for non-normality
    //Hom(I,I)<>R
@@ -1059 +1059 @@
  //        export SB,MB;
  //        result=BAS;
- //        return(result); 
+ //        return(result);
  //     }
  //     timer-ti;
@@ -1065 +1065 @@
  //     list  RR=SM[1],SM[2],JM[2],SL[1];
  //     ti=timer;
-      list RS;   
+      list RS;
  //   list RS=HomJJ(RR);
  //   timer-ti;
@@ -1075 +1075 @@
  //        list tluser=normalizationPrimes(SM);
  //        setring BAS;
- //        return(tluser); 
+ //        return(tluser);
  //     }
 
@@ -1084 +1084 @@
       }
 //      ti=timer;
-      
+
 
       if((attrib(JM[2],"isRad")==0)&&(attrib(SM[2],"isEquidimensional")==0))
@@ -1090 +1090 @@
            //J=radical(JM[2]);
           J=radical(SM[2]+ideal(SL[1]));
-         
+
           // evtl. test auf J=SM[2]+ideal(SL[1]) dann schon normal
       }
@@ -1110 +1110 @@
 //    timer-ti;
 
-      JM=J,J;        
+      JM=J,J;
 
       //evtl. fuer SL[1] anderen Nichtnullteiler aus J waehlen
@@ -1124 +1124 @@
         //    keepresult1=insert(keepresult1,keepresult2[lauf]);
         // }
-        // return(keepresult1);    
+        // return(keepresult1);
       // }
       RR=SM[1],SM[2],JM[2],SL[1];
@@ -1147 +1147 @@
          export KK;
          setring BAS;
-        // return(RS[1]); 
+        // return(RS[1]);
          return(lastR);
       }
@@ -1160 +1160 @@
             // normalizationPrimes(endid);
       setring BAS;
-      return(tluser);  
+      return(tluser);
    }
    else
@@ -1169 +1169 @@
                       +ordstr(basering)+");";
       if(y==1)
-      {      
+      {
          "zero-divisor found";
       }
@@ -1187 +1187 @@
       }
       attrib(vid,"isCompleteIntersection",0);
-    
+
       keepresult1=normalizationPrimes(vid,ihp);
 
@@ -1196 +1196 @@
       execute "ring newR2="+charstr(basering)+",("+varstr(basering)+"),("
                       +ordstr(basering)+");";
-  
+
       ideal vid=fetch(BAS,new2);
       ideal ihp=fetch(BAS,ihp);
@@ -1220 +1220 @@
          keepresult1=insert(keepresult1,keepresult2[lauf]);
       }
-      return(keepresult1);    
-   }   
+      return(keepresult1);
+   }
 }
 example
@@ -1278 +1278 @@
 ideal i=zy2-zx3-x6;
 
-//Theo2 
+//Theo2
 ring r=32003,(x,y,z),wp(3,4,12);
 ideal i=z*(y3-x4)+x8;
@@ -1348 +1348 @@
 
 //dauert laenger
-//Horrocks: 
+//Horrocks:
 ring r=32003,(a,b,c,d,e,f),dp;
 ideal i=
@@ -1385 +1385 @@
 a4d-8000a3be+8001a3cf-2ae2f2;
 
- 
+
 ring r=32003,(b,s,t,u,v,w,x,y,z),dp;
 

Singular/LIB/poly.lib

@@ -1 @@
-// $Id: poly.lib,v 1.12 1998-05-05 11:55:33 krueger Exp $
+// $Id: poly.lib,v 1.13 1998-05-14 18:45:11 Singular Exp $
 //system("random",787422842);
 //(GMG, last modified 22.06.96)
@@ -5 +5 @@
 ///////////////////////////////////////////////////////////////////////////////
 
-version="$Id: poly.lib,v 1.12 1998-05-05 11:55:33 krueger Exp $";
+version="$Id: poly.lib,v 1.13 1998-05-14 18:45:11 Singular Exp $";
 info="
 LIBRARY:  poly.lib      PROCEDURES FOR MANIPULATING POLYS, IDEALS, MODULES
 
  cyclic(int);           ideal of cyclic n-roots
- katsura([i]);          katsura [i] ideal
+ katsura([i]);          katsura [i] ideal
  freerank(poly/...)     rank of coker(input) if coker is free else -1
  is_homog(poly/...);    int, =1 resp. =0 if input is homogeneous resp. not
@@ -59 +59 @@
 
 proc katsura
-"USAGE: katsura([n]); n integer
+"USAGE: katsura([n]); n integer
 RETURN: katsura(n) : n-th katsura ideal of newly created and set ring
                      (32003, x(0..n), dp)
-        katsura()  : katsura ideal of basering 
+        katsura()  : katsura ideal of basering
 EXAMPLE: example katsura; shows examples
 "
@@ -75 +75 @@
   int n = nvars(basering) -1;
   poly p;
-  
+
   p = -1;
   for (i = -n; i <= n; i++)
@@ -82 +82 @@
   }
   s[1] = p;
-  
+
   for (i = 0; i < n; i++)
   {
@@ -596 +596 @@
 "USAGE:   lcm(i); i ideal
 RETURN:  poly = lcm(i[1],...,i[size(i)])
-NOTE:    
+NOTE:
 EXAMPLE: example lcm; shows an example
 "
@@ -656 +656 @@
 {
   return(leadcoef(f)/leadcoef(cleardenom(f)));
-}  
+}
 example
 { "EXAMPLE:"; echo = 2;

Singular/LIB/presolve.lib

@@ -1 @@
-// $Id: presolve.lib,v 1.4 1998-05-05 11:55:34 krueger Exp $
+// $Id: presolve.lib,v 1.5 1998-05-14 18:45:12 Singular Exp $
 //system("random",787422842);
 //(GMG), last modified 97/10/07 by GMG
 ///////////////////////////////////////////////////////////////////////////////
 
-version="$Id: presolve.lib,v 1.4 1998-05-05 11:55:34 krueger Exp $";
+version="$Id: presolve.lib,v 1.5 1998-05-14 18:45:12 Singular Exp $";
 info="
 LIBRARY:  presolve.lib     PROCEDURES FOR PRE-SOLVING POLYNOMIAL EQUATIONS
@@ -20 +20 @@
  sortandmap(id,s1,s2);  map to new basering with vars sorted w.r.t. complexity
  sortvars(id[n1,p1..]); sort vars w.r.t. complexity in id [different blocks]
- valvars(id[..]);       valuation of vars w.r.t. to their complexity in id 
+ valvars(id[..]);       valuation of vars w.r.t. to their complexity in id
            (parameters in square brackets [] are optional)
 ";
@@ -43 +43 @@
    {
       for ( ii=1; ii<=s; ii=ii+1 )
-      { 
-         dpart[ii] = (jet(id[ii],d1-1)==0)*(id[ii]==jet(id[ii],d2))*id[ii]; 
+      {
+         dpart[ii] = (jet(id[ii],d1-1)==0)*(id[ii]==jet(id[ii],d2))*id[ii];
       }
    }
    else
-   {  
+   {
       for ( ii=1; ii<=s; ii=ii+1 )
-      { 
+      {
          dpart[ii]=(jet(id[ii],d1-1,#[1])==0)*(id[ii]==jet(id[ii],d2,#[1]))*id[ii];
       }
@@ -56 +56 @@
    return(simplify(dpart,2));
 }
-example 
+example
 { "EXAMPLE:"; echo = 2;
    ring r=0,(x,y,z),dp;
@@ -71 +71 @@
 RETURN:  list of of 5 objects:
          [1]: (interreduced) ideal obtained from i by eliminating (sbstituting)
-              from the first n variables those which appear in a linear part 
+              from the first n variables those which appear in a linear part
               of i, by putting this part into triangular form
               (default: n = nvars(basering))
@@ -77 +77 @@
          [3]: ideal, j-th element defines substitution of j-th var in [2]
          [4]: ideal of variables of basering, eliminated ones are set to 0
-         [5]: ideal, describing the map from the basering to itself such that 
+         [5]: ideal, describing the map from the basering to itself such that
               [1] is the image of i
-NOTE:    the procedure does always interreduces the ideal i internally w.r.t. 
+NOTE:    the procedure does always interreduces the ideal i internally w.r.t.
          ordering dp
          // bei ** spaeter eventuell verbessern
@@ -93 +93 @@
 //--------------- replace ordering by dp-ordering if necessary ----------------
    o = "dp("+string(n)+")";
-   fi = find(ordstr(P),o); 
+   fi = find(ordstr(P),o);
    if( fi == 0 or find(ordstr(P),"a") != 0 )
    {
@@ -102 +102 @@
    ideal max,rest = maxideal(1),0;
    if ( n < nvars(P) ) { rest = max[n+1..nvars(P)]; }
-   attrib(rest,"isSB",1);   
+   attrib(rest,"isSB",1);
 //-------------------- interreduce and find linear part  ----------------------
 // interred does the only real work. Because of ordering dp the linear part is
@@ -110 +110 @@
 // which do not contain elements not to be eliminated
 
-   ideal id = interred(i);           
-   for ( ii=1; ii<=size(id); ii++ )  
-   { 
+   ideal id = interred(i);
+   for ( ii=1; ii<=size(id); ii++ )
+   {
       if( deg(id[ii]) > 1) { break; }
       k=ii;
    }
-   if( k == 0 )       { ideal lin; } 
+   if( k == 0 )       { ideal lin; }
    else               { ideal lin = id[1..k];}
    if( k < size(id) ) { id = id[k+1..size(id)]; }
@@ -123 +123 @@
    if ( n < nvars(P) )
    {
-      for ( ii=1; ii<=size(lin); ii++ ) 
-      {
-         if ( reduce(lead(lin[ii]),rest) == 0 ) 
-         { 
+      for ( ii=1; ii<=size(lin); ii++ )
+      {
+         if ( reduce(lead(lin[ii]),rest) == 0 )
+         {
             id=lin[ii],id;
-            lin[ii] = 0; 
+            lin[ii] = 0;
          }
       }
    }
    lin = simplify(lin,2);
-   attrib(lin,"isSB",1);   
+   attrib(lin,"isSB",1);
    ideal eva = lead(lin);
-   attrib(eva,"isSB",1);   
+   attrib(eva,"isSB",1);
    ideal neva = reduce(maxideal(1),eva);
 //------------------ go back to original ring end return  ----------------------
@@ -153 +153 @@
    {
       if( neva[ii] == 0 )
-      {      
+      {
          phi[ii] = eva[k]-lin[k];
          k=k+1;
@@ -162 +162 @@
    return(L);
 }
-example 
+example
 { "EXAMPLE:"; echo = 2;
    ring s=0,(x,y,z,t,u,v,w,a,b,c,d,f,e),ds;
@@ -173 +173 @@
 
 proc elimpart (ideal i,list #)
-"USAGE:   elimpart(i[,n,e]);  i=ideal, n,e=integers 
-         consider 1-st n vars for elimination (better: substitution), 
-         e =0: substitute from linear part of i (same as elimlinearpart) 
-         e!=0: eliminate also by direct substitution 
+"USAGE:   elimpart(i[,n,e]);  i=ideal, n,e=integers
+         consider 1-st n vars for elimination (better: substitution),
+         e =0: substitute from linear part of i (same as elimlinearpart)
+         e!=0: eliminate also by direct substitution
          (default: n = nvars(basering), e = 1)
 RETURN:  list of of 5 objects:
          [1]: ideal obtained by substituting from the first n variables those
-              from i which appear in the linear part of i [or, if e!=0, which 
+              from i which appear in the linear part of i [or, if e!=0, which
               can be expressed directly in the remaining vars]
          [2]: ideal, variables which have been substituted
@@ -188 +188 @@
               itself onto k[..variables fom [4]..] and [1] is the image of i
          The ideal i is generated by [1] and [3] in k[x(1..m)], the map [5]
-         maps [3] to 0, hence induceds an isomorhism 
-                   k[x(1..m)]/i -> k[..variables fom [4]..]/[1] 
+         maps [3] to 0, hence induceds an isomorhism
+                   k[x(1..m)]/i -> k[..variables fom [4]..]/[1]
 NOTE:    If the basering has ordering (c,dp), this is faster for big ideals,
-         since it avoids internal ring change and mapping 
+         since it avoids internal ring change and mapping
 EXAMPLE: example elimpart; shows an example
 "
@@ -210 +210 @@
 // first find terms lin1 of pure degree 1 in each poly of lin
 // k1 = pure degree 1 part, k1+k2 = those polys of lin which contained a pure
-// degree 1 part. 
+// degree 1 part.
 // Then go to ring newP with ordering c,dp(n) and create a matrix with size(k1)
 // colums and 2 rows, such that if [f1,f2] is a column of M then f1+f2 is one of
 // the polys of lin containing a pure degree 1 part and f1 is this part
-// interreduce this matrix (i.e. Gauss elimination on linear part, with rest 
+// interreduce this matrix (i.e. Gauss elimination on linear part, with rest
 // transformed accordingly).
- 
+
    if ( e!=0 )
    {
-      int ii,kk; 
+      int ii,kk;
       ideal k1,k2;
       int l = size(lin);
@@ -260 +260 @@
          poly p; map phi; ideal max;
          for ( ii=1; ii<=n; ii++  )
-         {  
+         {
             for (kk=1; kk<=l; kk++ )
             {
-               p = kin[kk]/var(ii); 
-               if ( deg(p) == 0 ) 
+               p = kin[kk]/var(ii);
+               if ( deg(p) == 0 )
                {
                   eva = eva+var(ii);
@@ -287 +287 @@
       lin[ii] = cleardenom(lin[ii]);
    }
-   if( defined(newP) ) 
+   if( defined(newP) )
    {
       setring P;
@@ -306 +306 @@
   return(L);
 }
-example 
+example
 { "EXAMPLE:"; echo = 2;
    ring s=0,(x,y,z,t,u,v,w,a,b,c,d,f,e),(c,ds);
@@ -318 +318 @@
 
 proc elimpartanyr (ideal i, list #)
-"USAGE:   elimpartanyr(i[,p,e]);  i=ideal, p=product of vars to be eliminated, 
+"USAGE:   elimpartanyr(i[,p,e]);  i=ideal, p=product of vars to be eliminated,
          e=int (default: p=product of all vars, e=1)
 RETURN:  list of of 6 objects:
-         [1]: (interreduced) ideal obtained by substituting from i those vars 
+         [1]: (interreduced) ideal obtained by substituting from i those vars
               appearing in p which occur in the linear part of i [or which can
               be expressed directly in the remaining variables, if e!=0]
@@ -332 +332 @@
 
          The ideal i is generated by [1] and [3] in k[x(1..m)], the map [5]
-         maps [3] to 0, hence induceds an isomorhism 
-                   k[x(1..m)]/i -> k[..variables fom [4]..]/[1] 
-NOTE:    the proc uses 'execute' to create a ring with ordering dp and vars 
+         maps [3] to 0, hence induceds an isomorhism
+                   k[x(1..m)]/i -> k[..variables fom [4]..]/[1]
+NOTE:    the proc uses 'execute' to create a ring with ordering dp and vars
          placed correctly and then applies 'elimpart';
 EXAMPLE: example elimpartanyr; shows an example
@@ -340 +340 @@
 {
    def P = basering;
-   int j,n,e = 0,0,1; 
+   int j,n,e = 0,0,1;
    poly p = product(maxideal(1));
    if ( size(#)==1 ) { p=#[1]; }
    if ( size(#)==2 ) { p=#[1]; e=#[2]; }
    string a,b;
-   for ( j=1; j<=nvars(P); j++ ) 
-   { 
+   for ( j=1; j<=nvars(P); j++ )
+   {
       if (deg(p/var(j))>=0) { a = a+varstr(j)+","; n = n+1; }
       else { b = b+varstr(j)+","; }
@@ -354 +354 @@
    execute "ring gnir ="+charstr(P)+",("+a+b+"),dp;";
    ideal i = imap(P,i);
-   list L = elimpart(i,n,e)+list(n); 
+   list L = elimpart(i,n,e)+list(n);
    setring P;
    list L = imap(gnir,L);
    return(L);
 }
-example 
+example
 { "EXAMPLE:"; echo = 2;
    ring s=0,(e,f,x,y,z,t,u,v,w,a,b,c,d),dp;
@@ -369 +369 @@
 }
 ///////////////////////////////////////////////////////////////////////////////
- 
+
 proc fastelim (ideal i, poly p, list #)
-"USAGE:   fastelim(i,p[h,o,a,b,e,m]); i=ideal, p=product of variables to be 
-         eliminated; h,o,a,b,e integers 
+"USAGE:   fastelim(i,p[h,o,a,b,e,m]); i=ideal, p=product of variables to be
+         eliminated; h,o,a,b,e integers
          (options for Hilbert-std, 'valvars', elimpart, minimizing)
          - h !=0: use Hilbert-series driven std-basis computation
@@ -381 +381 @@
          - m !=0: compute a minimal system of generators
          replacing '!=' by '=' has the opposite meaning
-         default: h,o,a,b,e,m = 0,1,0,0,0,0 
+         default: h,o,a,b,e,m = 0,1,0,0,0,0
 RETURN:  ideal obtained from i by eliminating those variables which occur in p
 EXAMPLE: example fastelim; shows an example.
@@ -394 +394 @@
    if ( size(#) == 5 ) { h=#[1]; o=#[2]; a=#[3]; b=#[4]; e=#[5]; }
    if ( size(#) == 6 ) { h=#[1]; o=#[2]; a=#[3]; b=#[4]; e=#[5]; m=#[6]; }
-   list L = elimpartanyr(i,p,e);  
+   list L = elimpartanyr(i,p,e);
    poly q = product(L[2]);     //product of vars which are already eliminated
    if ( q==0 ) { q=1; }
@@ -401 +401 @@
    if ( p==1 )                 //ready if no vars are left
    {                           //compute minbase if 3-rd argument !=0
-      if ( m != 0 ) { L[1]=minbase(L[1]); } 
+      if ( m != 0 ) { L[1]=minbase(L[1]); }
       return(L);
    }
@@ -424 +424 @@
    }
 //----------------- h==0: eliminate remaining vars directly -------------------
-   if ( h == 0 )              
+   if ( h == 0 )
    {
       L[1] = eliminate(L[1],L[2]);
       def r2 = r1;
-   } 
-   else 
+   }
+   else
 //------- h!=0: homogenize and compute Hilbert-series using hilbvec ----------
-   {                       
+   {
       intvec hi = hilbvec(L[1]);         // Hilbert-series of i
       execute "ring r2=("+charstr(P)+"),("+varstr(basering)+",@homo),dp;";
@@ -439 +439 @@
       L[1] = eliminate(L[1],L[2],hi);
       L[1]=subst(L[1],@homo,1);          // dehomogenize by setting @homo=1
-   }        
+   }
    if ( m != 0 )                         // compute minbase
-   {  
-      if ( #[1] != 0 ) { L[1] = minbase(L[1]); } 
+   {
+      if ( #[1] != 0 ) { L[1] = minbase(L[1]); }
    }
    def id = L[1];
@@ -448 +448 @@
    return(imap(r2,id));
 }
-example 
+example
 { "EXAMPLE:"; echo = 2;
    ring s=31991,(e,f,x,y,z,t,u,v,w,a,b,c,d),dp;
    ideal i = w2+f2-1, x2+t2+a2-1,  y2+u2+b2-1, z2+v2+c2-1,
-            d2+e2-1, f4+2u, wa+tf, xy+tu+ab; 
+            d2+e2-1, f4+2u, wa+tf, xy+tu+ab;
    fastelim(i,xytua);           //with valvars only
    fastelim(i,xytua,1,1);       //with hilb,valvars,minbase
@@ -460 +460 @@
 
 proc faststd (@id,string @s1,string @s2, list #)
-"USAGE:   faststd(id,s1,s2[,\"hilb\",\"sort\",\"dec\",o,\"blocks\"]); 
+"USAGE:   faststd(id,s1,s2[,\"hilb\",\"sort\",\"dec\",o,\"blocks\"]);
          id=ideal/module, s1,s2=strings (names for new ring and maped id)
          o = string (allowed ordstring:\"lp\",\"dp\",\"Dp\",\"ls\",\"ds\",\"Ds\")
          \"hilb\",\"sort\",\"dec\",\"block\" options for Hilbert-std, sortandmap
-COMPUTE: create a new ring (with \"best\" ordering of vars) and compute a 
+COMPUTE: create a new ring (with \"best\" ordering of vars) and compute a
          std-basis of id (hopefully faster)
          - If say, s1=\"R\" and s2=\"j\", the new basering has name R and the
-           std-basis of the image of id in R has name j 
+           std-basis of the image of id in R has name j
          - \"hilb\"  : use Hilbert-series driven std-basis computation
          - \"sort\"  : use 'sortandmap' for a best ordering of vars
@@ -480 +480 @@
 NOTE:    This proc is only useful for hard problems where other methods fail.
          \"hilb\" is useful for hard orderings (as \"lp\") or for characteristic 0,
-         it is correct for \"lp\",\"dp\",\"Dp\" (and for blockorderings combining 
+         it is correct for \"lp\",\"dp\",\"Dp\" (and for blockorderings combining
          these) but not for s-orderings or if the vars have different weights.
          There seem to be only few cases in which \"dec\" is fast
@@ -490 +490 @@
    string @o,@va,@c = ordstr(basering),"","";
 //-------------------- prepare ordering and set options -----------------------
-   if ( @o[1]=="c" or @o[1]=="C") 
+   if ( @o[1]=="c" or @o[1]=="C")
       {  @o = @o[3,2]; }
-   else 
+   else
       { @o = @o[1,2]; }
-   if( @o[1]!="d" and @o[1]!="D" and @o[1]!="l") 
+   if( @o[1]!="d" and @o[1]!="D" and @o[1]!="l")
       { @o="dp"; }
 
-   if (size(#) == 0 ) 
+   if (size(#) == 0 )
       { @s = 1; }
    for ( @ii=1; @ii<=size(#); @ii++ )
    {
-      if ( typeof(#[@ii]) != "string" ) 
-      { 
-         "// wrong syntax! type: help faststd"; 
+      if ( typeof(#[@ii]) != "string" )
+      {
+         "// wrong syntax! type: help faststd";
          return();
       }
@@ -516 +516 @@
       }
    }
-   if( voice==2 ) { "// choosen options, hilb sort dec block:",@h,@s,@n,@m; } 
+   if( voice==2 ) { "// choosen options, hilb sort dec block:",@h,@s,@n,@m; }
 
 //-------------------- nosort: create ring with new name ----------------------
-   if ( @s==0 ) 
-   { 
+   if ( @s==0 )
+   {
       execute "ring "+@s1+"=("+charstr(@P)+"),("+varstr(@P)+"),("+@o+");";
       def @id = imap(@P,@id);
@@ -554 +554 @@
 //------- hilb: homogenize and compute Hilbert-series using hilbvec -----------
 // this uses another standardbasis computation
-   if ( @h != 0 )              
-   { 
+   if ( @h != 0 )
+   {
       execute "ring @Q=("+charstr(@P)+"),("+varstr(@P)+",@homo),("+@o+");";
       def @id = imap(@P,@id);
       kill @P;
       @id = homog(@id,@homo);               // @homo = homogenizing var
-      if ( @s != 0 ) 
+      if ( @s != 0 )
       {
          bestorder(@id,@s1,@s2,@n,@o,@m,nvars(@Q)-1);
@@ -569 +569 @@
          verbose(redefine);
       }
-      intvec @hi;                     // encoding of Hilbert-series of i 
-      @hi = hilbvec(@id);                
+      intvec @hi;                     // encoding of Hilbert-series of i
+      @hi = hilbvec(@id);
       //if ( @s!=0 ) { @hi = hilbvec(@id,"32003",ordstr(@Q)); }
-      //else { @hi = hilbvec(@id); }           
+      //else { @hi = hilbvec(@id); }
 //-------------------------- use Hilbert-driven std --------------------------
       @id = std(@id,@hi);
@@ -585 +585 @@
       execute "ring @P=("+charstr(@Q)+"),("+@va+"),("+@o+");";
       def @id = imap(@Q,@id);
-   }        
+   }
    def `@s1` = @P;
    def `@s2` = @id;
@@ -592 +592 @@
    kill @P;
    keepring(basering);
-   if( voice==2 ) { "// basering is now "+@s1+", std-basis has name "+@s2; } 
+   if( voice==2 ) { "// basering is now "+@s1+", std-basis has name "+@s2; }
    return();
 }
-example 
+example
 { "EXAMPLE:"; echo = 2;
    ring s = 0,(e,f,x,y,z,t,u,v,w,a,b,c,d),(c,lp);
@@ -601 +601 @@
             d2+e2-1, f4+2u, wa+tf, xy+tu+ab;
   option(prot); timer=1;
-   int time = timer; 
-   ideal j=std(i);            
+   int time = timer;
+   ideal j=std(i);
    timer-time;
    show(R);dim(j),mult(j);
-   int time = timer; 
+   int time = timer;
    faststd(i,"R","i");                      // use "best" ordering of vars
    timer-time;
@@ -633 +633 @@
 RETURN:  ideal of variables occuring in id, if no second argument is present
          list of 4 objects, if a second argument is given (of any type)
-         -[1]: ideal of variables occuring in id 
-         -[2]: intvec of variables occuring in id 
-         -[3]: ideal of variables not occuring in id 
-         -[4]: intvec of variables not occuring in id 
+         -[1]: ideal of variables occuring in id
+         -[2]: intvec of variables occuring in id
+         -[3]: ideal of variables not occuring in id
+         -[4]: intvec of variables not occuring in id
 EXAMPLE: example findvars; shows an example
 "
@@ -663 +663 @@
    }
    if ( size(f)>1 ) { f = f[2..size(f)]; }      //intvec of found vars
-   if ( size(nf)>1 ) { nf = nf[2..size(nf)]; }  //intvec of vars not found 
+   if ( size(nf)>1 ) { nf = nf[2..size(nf)]; }  //intvec of vars not found
    if( size(#)==0 )  { return(found); }
    if( size(#)!=0 )  { list L = found,f,notfound,nf; return(L); }
 }
-example 
+example
 { "EXAMPLE:"; echo = 2;
    ring s  = 0,(e,f,x,y,t,u,v,w,a,d),dp;
-   ideal i = w2+f2-1, x2+t2+a2-1; 
+   ideal i = w2+f2-1, x2+t2+a2-1;
    findvars(i);
-   findvars(i,1); 
+   findvars(i,1);
 }
 ///////////////////////////////////////////////////////////////////////////////
@@ -687 +687 @@
    def @P = basering;
    string @c,@o = "32003", "dp";
-   if ( size(#) == 1 ) {  @c = #[1]; } 
+   if ( size(#) == 1 ) {  @c = #[1]; }
    if ( size(#) == 2 ) {  @c = #[1]; @o = #[2]; }
    string @si = typeof(@id)+" @i = "+string(@id)+";";  //** weg
@@ -694 +694 @@
    execute @si;                   //** weg
    //show(basering);
-   @i = std(@i);      
+   @i = std(@i);
    intvec @hi = hilb(@i,1);         // intvec of 1-st Hilbert-series of id
    return(@hi);
 }
-example 
+example
 { "EXAMPLE:"; echo = 2;
    ring s   = 0,(e,f,x,y,z,t,u,v,w,a,b,c,d,H),dp;
    ideal id = w2+f2-1, x2+t2+a2-1,  y2+u2+b2-1, z2+v2+c2-1,
-              d2+e2-1, f4+2u, wa+tf, xy+tu+ab; 
+              d2+e2-1, f4+2u, wa+tf, xy+tu+ab;
    id = homog(id,H);
    hilbvec(id);
@@ -716 +716 @@
    return(degreepart(id,0,1));
 }
-example 
+example
 { "EXAMPLE:"; echo = 2;
    ring r=0,(x,y,z),dp;
@@ -727 +727 @@
 
 proc tolessvars (id ,list #)
-"USAGE:   tolessvars(id,[s1,s2]); id poly/ideal/vector/module/matrix, 
+"USAGE:   tolessvars(id,[s1,s2]); id poly/ideal/vector/module/matrix,
          s1,s2=strings (names of: new ring, new ordering)
 CREATE:  nothing, if id contains all vars of the basering. Else, create
@@ -735 +735 @@
          The name of the new ring is by default R(n), where n is the number of
          variables in the new ring. If, say, s1 = \"newR\" then the new ring has
-         name newR. In s2 a different ordering for the new ring may be given 
+         name newR. In s2 a different ordering for the new ring may be given
          as an allowed ordstring (default is \"dp\" resp. \"ds\", depending whether
          the first block of the old ordering is a p- resp. an s-ordering).
@@ -741 +741 @@
          the old ring (default)
 RETURN:  the original ideal id
-NOTE:    You must not type, say, 'ideal id=tolessvars(id);' since the ring 
+NOTE:    You must not type, say, 'ideal id=tolessvars(id);' since the ring
          to which 'id' would belong will only be defined by the r.h.s.. But you
-         may type 'def id=tolessvars(id);' or 'list id=tolessvars(id);' 
+         may type 'def id=tolessvars(id);' or 'list id=tolessvars(id);'
          since then 'id' does not a priory belong to a ring, its type will
          be defined by the right hand side. Moreover, do not use a name which
@@ -760 +760 @@
    newvar = string(L[1]);    // string of new variables
    n = size(L[1]);           // number of new variables
-   if( n == 0 ) 
+   if( n == 0 )
    {
       dbprint( pr,"","// no variable occured in "+typeof(id)+", no change of ring!");
       return(id);
    }
-   if( n == nvars(P) ) 
-   { 
+   if( n == nvars(P) )
+   {
       dbprint( pr,"","// all variables occured in "+typeof(id)+", no change of ring!");
-      return(id); 
+      return(id);
    }
 //----------------- prepare new ring, map to it and return --------------------
    s1 = "R("+string(n)+")";
-   if ( size(#) == 0 ) 
-   { 
+   if ( size(#) == 0 )
+   {
        fp = find(s2,"p");
        fs = find(s2,"s");
        if( fs==0 or (fs>=fp && fp!=0) ) { s2="dp"; }
-       else {  s2="ds"; } 
+       else {  s2="ds"; }
    }
    if ( size(#) ==1 ) { s1=#[1]; }
@@ -791 +791 @@
    return(id);
 }
-example 
+example
 { "EXAMPLE:"; echo = 2;
    ring r  = 0,(x,y,z),dp;
    ideal i = y2-x3,x-3,y-2x;
-   def j   = tolessvars(i); 
+   def j   = tolessvars(i);
    show(basering);
    j;
@@ -810 +810 @@
          form  (default) or if n=0 [non-reduced triangular form if n!=0]
 ASSUME:  monomial ordering is a global ordering (p-ordering)
-NOTE:    may be used to solve a system of linear equations 
+NOTE:    may be used to solve a system of linear equations
          see proc 'gauss_row' from 'matrix.lib' for a different method
-WARNING: the result is very likely to be false for 'real' coefficients, use 
+WARNING: the result is very likely to be false for 'real' coefficients, use
          char 0 instead!
 EXAMPLE: example solvelinearpart; shows an example
@@ -819 +819 @@
    intvec getoption = option(get);
    option(redSB);
-   if ( size(#)!=0 ) 
-   { 
+   if ( size(#)!=0 )
+   {
       if(#[1]!=0) { option(noredSB); }
    }
    def lin = interred(degreepart(id,0,1));
-   if ( size(#)!=0 ) 
-   { 
-      if(#[1]!=0) 
-      { 
+   if ( size(#)!=0 )
+   {
+      if(#[1]!=0)
+      {
          return(lin);
       }
@@ -834 +834 @@
    return(simplify(lin,1));
 }
-example 
+example
 { "EXAMPLE:"; echo = 2;
    // Solve the system of linear equations:
@@ -848 +848 @@
    ideal j= 2,1,0,3;
    j = i-j;                        // difference of 1x4 matrices
-                                   // compute reduced triangular form, setting 
+                                   // compute reduced triangular form, setting
    solvelinearpart(j);             // the RHS equal 0 gives the solutions!
    solvelinearpart(j,1); "";       // triangular form, not reduced
@@ -861 +861 @@
             14x + 10y + 6z - 7u - c,
              7x +  4y + 3z - 3u - d;
-   solvelinearpart(i);             
+   solvelinearpart(i);
 }
 ///////////////////////////////////////////////////////////////////////////////
 
 proc sortandmap (@id,string @s1,string @s2, list #)
-"USAGE:   sortandmap(id,s1,s2[,n1,p1,n2,p2...,o1,m1,o2,m2...]); 
+"USAGE:   sortandmap(id,s1,s2[,n1,p1,n2,p2...,o1,m1,o2,m2...]);
          id=poly/ideal/vector/module
          s1,s2=strings (names for new ring and maped id)
          p1,p2,...= product of vars, n1,n2,...=integers
-         o1,o2,...= allowed ordstrings, m1,m2,...=integers 
+         o1,o2,...= allowed ordstrings, m1,m2,...=integers
          (default: p1=product of all vars, n1=0, o1=\"dp\",m1=0)
          the last pi (containing the remaining vars) may be omitted
 CREATE:  a new ring and map id into it, the new ring has same char as basering
-         but with new ordering and vars sorted in the following manner: 
+         but with new ordering and vars sorted in the following manner:
          - each block of vars occuring in pi is sorted w.r.t its complexity in
-           id, ni controls the sorting in i-th block (= vars occuring in pi): 
+           id, ni controls the sorting in i-th block (= vars occuring in pi):
            ni=0 (resp.!=0) means that less (resp. more) complex vars come first
          - If say, s1=\"R\" and s2=\"j\", the new basering has name R and the image
-           of id in R has name j 
+           of id in R has name j
          - oi and mi define the monomial ordering of the i-th block:
            if mi =0, oi=ordstr(i-th block)
            if mi!=0, the ordering of the i-th block itself is a blockordering,
-           each subblock having ordstr=oi, such that vars of same complexity 
+           each subblock having ordstr=oi, such that vars of same complexity
            are in one block
            default: oi=\"dp\", mi=0
@@ -889 +889 @@
 RETURN:  nothing
 NOTE:    We define a variable x to be more complex than y (with respect to id)
-         if val(x) > val(y) lexicographically, where val(x) denotes the 
+         if val(x) > val(y) lexicographically, where val(x) denotes the
          valuation vector of x: consider id as list of polynomials in x with
-         coefficients in the remaining variables. Then val(x) = 
+         coefficients in the remaining variables. Then val(x) =
          (maximal occuring power of x, # of monomials in leading coefficient,
           # of monomials in coefficient of next smaller power of x,...)
@@ -903 +903 @@
 //----------------- find o in # and split # into 2 lists ---------------------
    # = # +list("dp",0);
-   for ( @ii=1; @ii<=size(#); @ii++) 
-   { 
-      if ( typeof(#[@ii])=="string" )  break; 
+   for ( @ii=1; @ii<=size(#); @ii++)
+   {
+      if ( typeof(#[@ii])=="string" )  break;
    }
    if ( @ii==1 ) { list @L1 = list(); }
@@ -922 +922 @@
          for ( @jj=1; @jj<=size(@v); @jj++ )
          {
-           @o = @o+@L2[@ii/2 -1]+"("+string(@v[@jj])+"),"; 
+           @o = @o+@L2[@ii/2 -1]+"("+string(@v[@jj])+"),";
          }
       }
-      else 
-      { 
-         @o = @o+@L2[@ii/2 -1]+"("+string(size(@l[@ii/2]))+"),"; 
-      } 
+      else
+      {
+         @o = @o+@L2[@ii/2 -1]+"("+string(size(@l[@ii/2]))+"),";
+      }
    }
    @o=@o[1..size(@o)-1];
@@ -935 +935 @@
    def @id = imap(@P,@id);
    execute "def "+ @s2+"=@id;";
-   execute("export("+@s1+");"); 
-   execute("export("+@s2+");"); 
+   execute("export("+@s1+");");
+   execute("export("+@s2+");");
    keepring(basering);
    return();
 }
-example 
+example
 { "EXAMPLE:"; echo = 2;
    ring s = 32003,(e,f,x,y,z,t,u,v,w,a,b,c,d),dp;
@@ -951 +951 @@
    kill R_r; setring s;
    sortandmap(i,"R_r","i",1,"lp",0);
-   show(R_r);  
+   show(R_r);
    kill R_r; setring s;
    sortandmap(i,"R_r","i",1,abc,0,xyztuvw,0,"lp",0,"Dp",1);
-   show(R_r);  
+   show(R_r);
    kill R_r;
 }
@@ -960 +960 @@
 
 proc sortvars (id, list #)
-"USAGE:   sortvars(id[,n1,p1,n2,p2,...]); id=poly/ideal/vector/module, 
+"USAGE:   sortvars(id[,n1,p1,n2,p2,...]); id=poly/ideal/vector/module,
          p1,p2,...= product of vars, n1,n2,...=integers
          (default: p1=product of all vars, n1=0)
@@ -967 +967 @@
 RETURN:  list of two elements, an ideal and a list:
          [1]: ideal, variables of basering sorted w.r.t their complexity in id
-            ni controls the ordering in i-th block (= vars occuring in pi): 
+            ni controls the ordering in i-th block (= vars occuring in pi):
             ni=0 (resp.!=0) means that less (resp. more) complex vars come
-            first 
+            first
          [2]: a list with 4 elements for each pi:
-            ideal ai : vars of pi in correct order, 
-            intvec vi: permutation vector describing the ordering in ai, 
-            intmat Mi: valuation matrix of ai, the columns of Mi being the 
+            ideal ai : vars of pi in correct order,
+            intvec vi: permutation vector describing the ordering in ai,
+            intmat Mi: valuation matrix of ai, the columns of Mi being the
                        valuation vectors of the vars in ai
-            intvec wi: 1-st,2-nd,...entry = size of 1-st,2-nd,... block of 
+            intvec wi: 1-st,2-nd,...entry = size of 1-st,2-nd,... block of
                        identically columns of Mi (vars with same valuation)
 NOTE:    We define a variable x to be more complex than y (w.r.t. id)
-         if val(x) > val(y) lexicographically, where val(x) denotes the 
+         if val(x) > val(y) lexicographically, where val(x) denotes the
          valuation vector of x: consider id as list of polynomials in x with
-         coefficients in the remaining variables. Then val(x) = 
+         coefficients in the remaining variables. Then val(x) =
          (maximal occuring power of x, # of monomials in leading coefficient,
           # of monomials in coefficient of next smaller power of x,...)
@@ -988 +988 @@
    int ii,jj,n,s;
    list L = valvars(id,#);
-   list L2, L3 = L[2], L[3]; 
+   list L2, L3 = L[2], L[3];
    list K; intmat M; intvec v1,v2,w;
    ideal i = sort(maxideal(1),L[1])[1];
@@ -995 +995 @@
       M = transpose(L3[2*ii]);
       M = M[L2[ii],1..nrows(L3[2*ii])];
-      w = 0; s = 0; 
+      w = 0; s = 0;
       for ( jj=1; jj<=nrows(M)-1; jj++ )
       {
@@ -1005 +1005 @@
       K = K+sort(L3[2*ii-1],L2[ii])+list(transpose(M))+list(w);
    }
-   L = i,K; 
+   L = i,K;
    return(L);
 }
-example 
+example
 { "EXAMPLE:"; echo = 2;
    ring r=0,(a,b,c,x,y,z),lp;
@@ -1022 +1022 @@
 
 proc valvars (id, list #)
-"USAGE:   valvars(id[,n1,p1,n2,p2,...]); id=poly/ideal/vector/module, 
+"USAGE:   valvars(id[,n1,p1,n2,p2,...]); id=poly/ideal/vector/module,
          p1,p2,...= product of vars, n1,n2,...=integers
-         ni controls the ordering of vars occuring in pi: 
+         ni controls the ordering of vars occuring in pi:
          ni=0 (resp.!=0) means that less (resp. more) complex vars come first
          (default: p1=product of all vars, n1=0)
@@ -1032 +1032 @@
          [1]: intvec, say v, describing the permutation such that the permuted
             ringvariables are ordered with respect to their complexity in id
-         [2]: list of intvecs, i-th intvec, say v(i) describing prmutation 
+         [2]: list of intvecs, i-th intvec, say v(i) describing prmutation
               of vars in a(i) such that v=v(1),v(2),...
-         [3]: list of ideals and intmat's, say a(i) and M(i), where ideal a(i) 
+         [3]: list of ideals and intmat's, say a(i) and M(i), where ideal a(i)
             = factors of pi, M(i) = valuation matrix of a(i), such that the
-            j-th column of M(i) is the valuation vector of j-th generator of a(i) 
-NOTE:    Use proc 'sortvars' for the actual sorting of vars! 
+            j-th column of M(i) is the valuation vector of j-th generator of a(i)
+NOTE:    Use proc 'sortvars' for the actual sorting of vars!
          We define a variable x to be more complex than y (with respect to id)
-         if val(x) > val(y) lexicographically, where val(x) denotes the 
+         if val(x) > val(y) lexicographically, where val(x) denotes the
          valuation vector of x: consider id as list of polynomials in x with
-         coefficients in the remaining variables. Then val(x) = 
+         coefficients in the remaining variables. Then val(x) =
          (maximal occuring power of x, # of monomials in leading coefficient,
           # of monomials in coefficient of next smaller power of x,...)
@@ -1060 +1060 @@
 
 //---- for each pii in # create ideal a(ii) intvec v(ii) and list L(ii) -------
-// a(ii) = ideal of vars in product, v(ii)[j]=k <=> a(ii)[j]=var(k) 
+// a(ii) = ideal of vars in product, v(ii)[j]=k <=> a(ii)[j]=var(k)
 
    v = 1..nvars(basering);
@@ -1074 +1074 @@
          for ( jj=1; jj<=nvars(basering); jj++ )
          {
-            if ( #[ii]/var(jj) != 0) 
-            { 
-               a(ii) = a(ii) + var(jj); 
+            if ( #[ii]/var(jj) != 0)
+            {
+               a(ii) = a(ii) + var(jj);
                v(ii)=v(ii),jj;
                m[jj]=0;
@@ -1083 +1083 @@
          }
          v(ii)=v(ii)[2..size(v(ii))];
-      } 
-      if ( size(m)!=0 ) 
-      { 
-         l = 2*(l/2)+2; 
-         ideal a(l) = simplify(m,2); 
+      }
+      if ( size(m)!=0 )
+      {
+         l = 2*(l/2)+2;
+         ideal a(l) = simplify(m,2);
          intvec v(l) = compress(v);
          int n(l);
@@ -1093 +1093 @@
       }
    }
-   else 
-   { 
-      l = 2; 
-      ideal a(2) = maxideal(1); 
-      intvec v(2) = v; 
-      int n(2); 
+   else
+   {
+      l = 2;
+      ideal a(2) = maxideal(1);
+      intvec v(2) = v;
+      int n(2);
       if ( size(#)==1 ) { n(2) = #[1]; }
    }
@@ -1111 +1111 @@
       {
          C = coeffs(i,a(kk)[ii]);
-         w = nrows(C);                   
-         for ( jj=w[1]; jj>1; jj-- ) 
+         w = nrows(C);
+         for ( jj=w[1]; jj>1; jj-- )
          {
             s = size(C[jj,1..ncols(C)]);
-            w[w[1]-jj+2] = sum(s); 
+            w[w[1]-jj+2] = sum(s);
          }
          L[ii]=w;
@@ -1121 +1121 @@
       }
       intmat M(kk)[size(a(kk))][n];
-      for ( ii=1; ii<=size(a(kk)); ii++ ) 
-      { 
-         if ( n==1 ) { w = L[ii]; M(kk)[ii,1] = w[1]; } 
-         else  { M(kk)[ii,1..n] = L[ii]; } 
+      for ( ii=1; ii<=size(a(kk)); ii++ )
+      {
+         if ( n==1 ) { w = L[ii]; M(kk)[ii,1] = w[1]; }
+         else  { M(kk)[ii,1..n] = L[ii]; }
       }
       LM[kk-1] = a(kk);
@@ -1133 +1133 @@
       blockvec[kk/2] = vec;
       vec = sort(v(kk),vec)[1];
-      varvec = varvec,vec; 
+      varvec = varvec,vec;
    }
    varvec = varvec[2..size(varvec)];
@@ -1139 +1139 @@
    return(result);
 }
-example 
+example
 { "EXAMPLE:"; echo = 2;
    ring r=0,(a,b,c,x,y,z),lp;
@@ -1164 +1164 @@
 y,u,b,c,a,z,t,x,v,d,w,e,f,h
 v0;
-14,9,12,11,10,8,7,6,5,4,3,2,1,13 
+14,9,12,11,10,8,7,6,5,4,3,2,1,13
 print(matrix(sort(maxideal(1),v0)));
 h,v,e,w,d,x,t,z,a,c,b,u,y,f
 v1;v2;
-9,12,11,10,8,7,6,5,4,3,2,1,13,14 
-13,12,11,10,8,7,6,5,4,3,2,1,9,14 
+9,12,11,10,8,7,6,5,4,3,2,1,13,14
+13,12,11,10,8,7,6,5,4,3,2,1,9,14
 
 Ev. Gute Ordnung fuer i:
@@ -1178 +1178 @@
 d=deg_x(i) := max{deg_x(i[k]) | k=1..size(i)}
 size_x(i,deg_x(i)..0) := size(ad),...,size(a0)
-x>y  <== 
-  1. deg_x(i)>deg_y(i) 
+x>y  <==
+  1. deg_x(i)>deg_y(i)
   2. "=" in 1. und size_x lexikographisch
 

Singular/LIB/primdec.lib

@@ -1 @@
-// $Id: primdec.lib,v 1.17 1998-05-13 15:02:35 obachman Exp $
+// $Id: primdec.lib,v 1.18 1998-05-14 18:45:13 Singular Exp $
 ///////////////////////////////////////////////////////
 // primdec.lib
@@ -11 +11 @@
 //////////////////////////////////////////////////////
 
-version="$Id: primdec.lib,v 1.17 1998-05-13 15:02:35 obachman Exp $";
+version="$Id: primdec.lib,v 1.18 1998-05-14 18:45:13 Singular Exp $";
 info="
 LIBRARY: primdec.lib: PROCEDURE FOR PRIMARY DECOMPOSITION (I)
@@ -213 +213 @@
    ideal fac=tsil[2];
    poly f=tsil[3];
-   
+
    ideal star=quotient(laedi,f);
    action=1;
@@ -228 +228 @@
         g=1;
         verg=laedi;
-        
+
          for(j=1;j<=size(fac);j++)
          {
@@ -237 +237 @@
          }
          verg=quotient(laedi,g);
-         
+
          if(specialIdealsEqual(verg,star)==1)
          {
@@ -251 +251 @@
       }
    }
-   l=star,fac,f;   
+   l=star,fac,f;
    return(l);
 }
@@ -259 +259 @@
 {
   poly keep=p;
-  
+
    int i;
    poly q=act[1][1]^act[2][1];
@@ -272 +272 @@
       "ERROR IN FACTOR";
       basering;
-      
+
       act;
       keep;
       pause;
-      
+
       p;
       q;
@@ -565 +565 @@
          m=m-1;
       }
-      //check whether i[m] =(c*var(n)+h)^e modulo prm for some 
+      //check whether i[m] =(c*var(n)+h)^e modulo prm for some
       //h in K[var(n+1),...,var(nvars(basering))], c in K
       //if not (0) is returned, else var(n)+h is added to prm
@@ -788 +788 @@
    {
      attrib(l[2*i-1],"isSB",1);
-     
+
      if((size(ser)>0)&&(size(reduce(ser,l[2*i-1],1))==0)&&(deg(l[2*i-1][1])>0))
      {
        "Achtung in split";
-       
+
          l[2*i-1]=ideal(1);
          l[2*i]=ideal(1);
@@ -857 +857 @@
      return(primary);
   }
-  
-  j=interred(j);  
+
+  j=interred(j);
   attrib(j,"isSB",1);
   if(vdim(j)==deg(j[1]))
-  {    
+  {
      act=factor(j[1]);
      for(@k=1;@k<=size(act[1]);@k++)
@@ -879 +879 @@
        primary[2*@k]=interred(@qh);
        attrib( primary[2*@k-1],"isSB",1);
-       
+
        if((size(ser)>0)&&(size(reduce(ser,primary[2*@k-1],1))==0))
        {
           primary[2*@k-1]=ideal(1);
-          primary[2*@k]=ideal(1);          
+          primary[2*@k]=ideal(1);
        }
      }
@@ -957 +957 @@
   }
   else
-  {  
+  {
      primary[1]=j;
      if((size(#)>0)&&(act[2][1]>1))
@@ -976 +976 @@
   if(size(#)==0)
   {
-    
+
      primary=splitPrimary(primary,ser,@wr,act);
-     
+
   }
 
@@ -1001 +1001 @@
     }
   }
-    
+
   @k=0;
   ideal keep;
@@ -1027 +1027 @@
                     jmap2[zz]=primary[2*@k-1][@n];
                     @qht[@n]=var(zz);
-                     
+
                 }
              }
@@ -1039 +1039 @@
        phi1=@P,jmap1;
        phi=@P,jmap;
- 
+
        for(@n=1;@n<=nva;@n++)
        {
@@ -1048 +1048 @@
 
        @qh=phi(@qht);
-       
+
        if(npars(@P)>0)
        {
@@ -1076 +1076 @@
        kill @Phelp1;
        @qh=clearSB(@qh);
-       attrib(@qh,"isSB",1);       
+       attrib(@qh,"isSB",1);
        ser1=phi1(ser);
        @lh=zero_decomp (@qh,phi(ser1),@wr);
 //       @lh=zero_decomp (@qh,psi(ser),@wr);
-       
-       
+
+
        kill lres0;
        list lres0;
@@ -1681 +1681 @@
    map phi=@P,qr[2];
    i=qr[1];
-   
+
    execute "ring gnir = ("+charstr(basering)+"),("+varstr(basering)+"),("
              +ordstr(basering)+");";
@@ -1929 +1929 @@
       }
   }
-  
+
   homo=homog(i);
-  
+
   if(homo==1)
   {
@@ -1978 +1978 @@
   option(redSB);
 
-  ideal ser=fetch(@P,ser);  
+  ideal ser=fetch(@P,ser);
 
   if(homo==1)
@@ -2032 +2032 @@
     }
   }
- 
+
   //----------------------------------------------------------------
   //j is the ring
@@ -2070 +2070 @@
      return(primary);
   }
-  
+
  //------------------------------------------------------------------
  //the zero-dimensional case
@@ -2124 +2124 @@
       indep=maxIndependSet(@j);
    }
-  
+
   ideal jkeep=@j;
 
@@ -2148 +2148 @@
       ideal jwork=std(imap(gnir,@j),@hilb);
     }
-    
+
   }
   else
@@ -2159 +2159 @@
   di=dim(jwork);
   keepdi=di;
-  
+
   setring gnir;
   for(@m=1;@m<=size(indep);@m++)
@@ -2175 +2175 @@
         attrib(@j,"isSB",1);
         ideal ser=fetch(gnir,ser);
-        
+
      }
      else
@@ -2192 +2192 @@
         }
         ideal ser=phi(ser);
-        
-     }
-     option(noredSB);     
+
+     }
+     option(noredSB);
      if((deg(@j[1])==0)||(dim(@j)<jdim))
      {
@@ -2250 +2250 @@
         }
         //the primary decomposition of j*K(var(nnp+1),..,var(nva))[..the rest..]
-        option(redSB);        
+        option(redSB);
         list uprimary= zero_decomp(@j,ser,@wr);
         option(noredSB);
@@ -2312 +2312 @@
      //mentioned above is really computed
      for(@n=@n3/2+1;@n<=@n2/2;@n++)
-     {       
+     {
         if(specialIdealsEqual(quprimary[2*@n-1],quprimary[2*@n]))
         {
@@ -2327 +2327 @@
         }
      }
-    
+
      if(size(@h)>0)
      {
@@ -2337 +2337 @@
         if(@wr!=1)
         {
-          @q=minSat(jwork,@h)[2];   
+          @q=minSat(jwork,@h)[2];
         }
         else
@@ -2357 +2357 @@
         }
         jwork=std(jwork,@q);
-        keepdi=dim(jwork);        
+        keepdi=dim(jwork);
         if(keepdi<di)
         {
@@ -2382 +2382 @@
   {
     keepdi=di-1;
-  }  
+  }
   //---------------------------------------------------------------
   //notice that j=sat(j,gh) intersected with (j,gh^n)
@@ -2413 +2413 @@
 
         if(size(ser)>0)
-        { 
-           ser=intersect(htest,ser); 
+        {
+           ser=intersect(htest,ser);
         }
         else
         {
           ser=htest;
-        } 
+        }
         setring gnir;
         ser=imap(@Phelp,ser);
      }
      if(size(reduce(ser,peek,1))!=0)
-     {       
+     {
         for(@m=1;@m<=size(restindep);@m++)
         {
          // if(restindep[@m][3]>=keepdi)
-         // { 
+         // {
            isat=0;
            @n2=0;
            option(redSB);
-           
+
            if(restindep[@m][1]==varstr(basering))
            //this is the good case, nothing to do, just to have the same notations
@@ -2459 +2459 @@
            }
            option(noredSB);
-           
+
            for (lauf=1;lauf<=size(@j);lauf++)
            {
@@ -2508 +2508 @@
            }
            //the primary decomposition of j*K(var(nnp+1),..,var(nva))[..the rest..]
-           
+
            option(redSB);
            list uprimary= zero_decomp(@j,ser,@wr);
            option(noredSB);
-           
-            
+
+
            //we need the intersection of the ideals in the list quprimary with the
            //polynomialring, i.e. let q=(f1,...,fr) in the quotientring such an ideal
@@ -2548 +2548 @@
            @n2=size(quprimary);
            @n3=@n2;
-           
+
            for(@n1=1;@n1<=size(collectprimary)/2;@n1++)
            {
@@ -2561 +2561 @@
               }
            }
-           
-           
+
+
            //here the intersection with the polynomialring
            //mentioned above is really computed
@@ -2601 +2601 @@
               ser=imap(@Phelp,ser);
            }
-           
+
          // }
-        }             
+        }
         if(size(reduce(ser,peek,1))!=0)
         {
@@ -2623 +2623 @@
         }
      }
-     
+
    }
   //------------------------------------------------------------
@@ -2629 +2629 @@
   //the final result: primary
   //------------------------------------------------------------
-  
+
   setring @P;
   primary=imap(gnir,quprimary);
@@ -2666 +2666 @@
    if(size(#)>0)
    {
-     il=#[1]; 
+     il=#[1];
    }
    ideal re=1;
@@ -2673 +2673 @@
    map phi=@P,qr[2];
    i=qr[1];
-   
+
    list pr=facstd(i);
 
@@ -2710 +2710 @@
      int odim=dim(pr[1]);
      int count=1;
-   
+
      for(j=2;j<=s;j++)
      {
@@ -2751 +2751 @@
    return(phi(j));
 }
- 
+
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -2773 +2773 @@
       return(ideal(0));
    }
-   
+
    def  @P = basering;
    list indep,allindep,restindep,fett,@mu;
@@ -2833 +2833 @@
 
       return(ideal(@p));
-   }   
+   }
    //------------------------------------------------------------------
    //the case of a complete intersection
@@ -2849 +2849 @@
    if (jdim==0)
    {
-      @j1=finduni(@j); 
+      @j1=finduni(@j);
       for(@k=1;@k<=size(@j1);@k++)
       {
@@ -2864 +2864 @@
       return(@j);
    }
-  
+
    //------------------------------------------------------------------
    //search for a maximal independent set indep,i.e.
@@ -2873 +2873 @@
 
    indep=maxIndependSet(@j);
-  
+
    di=dim(@j);
 
@@ -3002 +3002 @@
       {
          fac=ideal(0);
-         for(lauf=1;lauf<=ncols(@h);lauf++)   
+         for(lauf=1;lauf<=ncols(@h);lauf++)
          {
             if(deg(@h[lauf])>0)
@@ -3016 +3016 @@
          }
 
-       
+
          @mu=mstd(quotient(@j+ideal(@q),rad));
          @j=@mu[1];
          attrib(@j,"isSB",1);
-       
+
       }
       if((deg(rad[1])>0)&&(deg(collectrad[1])>0))
@@ -3035 +3035 @@
 
       te=simplify(reduce(te*rad,@j),2);
- 
+
       if((dim(@j)<di)||(size(te)==0))
       {
@@ -3049 +3049 @@
    {
       return(rad);
-   }   
+   }
   // rad=intersect(rad,radicalKL(@mu,rad,@wr));
    rad=intersect(rad,radicalKL(@mu,ideal(1),@wr));
@@ -3072 +3072 @@
       il=#[1];
    }
-   
+
    option(redSB);
    list m=mstd(i);
@@ -3089 +3089 @@
         return(quotient(I,J));
       }
-   
+
       for(l=1;l<=cod;l++)
       {
@@ -3107 +3107 @@
          if(il==1)
          {
-      
+
             return(radI1);
          }
@@ -3117 +3117 @@
             return(radI1);
          }
-         return(intersect(radI1,radicalEHV(I2,re,il)));       
+         return(intersect(radI1,radicalEHV(I2,re,il)));
       }
    }
@@ -3145 +3145 @@
   }
   return(ann);
-} 
- 
+}
+
 //computes all equidimensional parts of the ideal i
 proc prepareAss(ideal i)
@@ -3163 +3163 @@
   {
      list re=mres(i,0);             //fehler in sres
-  }  
+  }
   for(e=cod;e<=nvars(basering);e++)
   {
@@ -3174 +3174 @@
   }
   return(er);
-}  
+}
 
 //computes the annihilator of Ext^n(R/i,R) with given resolution re
@@ -3192 +3192 @@
      ideal ann=Ann(transpose(re[n]));
   }
-  return(ann);            
+  return(ann);
 }
 
@@ -3204 +3204 @@
       re=intersect1(re,quotient(a,module(b[i])));
    }
-   return(re);   
+   return(re);
 }
 
@@ -3210 +3210 @@
 
 proc analyze(list pr)
-{ 
+{
    int ii,jj;
    for(ii=1;ii<=size(pr)/2;ii++)
@@ -3230 +3230 @@
          }
       }
-   }   
+   }
 }
 
@@ -3237 +3237 @@
 {
   def r=basering;
-  
+
   int j,k;
   map phi;
   poly p;
-  
+
   ideal iwork=i;
   ideal imap1=maxideal(1);
   ideal imap2=maxideal(1);
-  
+
 
   for(j=1;j<=nvars(basering);j++)
@@ -3260 +3260 @@
         iwork[k]=var(j);
         imap1=maxideal(1);
-        imap2[j]=-p;        
+        imap2[j]=-p;
         break;
       }
@@ -3268 +3268 @@
 }
 
-        
+
 ///////////////////////////////////////////////////////
 // ini_mod
@@ -3866 +3866 @@
             }
         }
-        dimSP=dim(SP);
+        dimSP=dim(SP);
         for(j=size(m);j>=1; j--)
         {
@@ -4063 +4063 @@
       {
         f=polys[k];
-        degf=deg(f);
+        degf=deg(f);
       }
     }
@@ -4273 +4273 @@
    return(0);
 }
-        
-        
+
+
  proc quotient2(module a,module b)
 {
@@ -4291 +4291 @@
   setring @newP;
  ideal re=imap(@newr,re);
- return(re);   
-}
-//Im homogenen Fall system("LaScala",i) verwenden 
+ return(re);
+}
+//Im homogenen Fall system("LaScala",i) verwenden

Singular/LIB/primitiv.lib

@@ -1 @@
-// $Id: primitiv.lib,v 1.5 1998-05-05 11:55:35 krueger Exp $
+// $Id: primitiv.lib,v 1.6 1998-05-14 18:45:14 Singular Exp $
 // author:  Martin Lamm,  email: lamm@mathematik.uni-kl.de
 // last change:           11.3.98
 ///////////////////////////////////////////////////////////////////////////////
-version="$Id: primitiv.lib,v 1.5 1998-05-05 11:55:35 krueger Exp $";
+version="$Id: primitiv.lib,v 1.6 1998-05-14 18:45:14 Singular Exp $";
 info="
 LIBRARY:    primitiv.lib    PROCEDURES FOR FINDING A PRIMITIVE ELEMENT
@@ -172 +172 @@
   else { if (find(varnames,"b")==0) { algname="b";}
          else { if (find(varnames,"c")==0)
-                                    { algname="c";}
+                                    { algname="c";}
          else { if (find(varnames,"o")==0)
-                                    { algname="o";}
+                                    { algname="o";}
          else {
            "** Sorry -- could not find a free name for the primitive element.";
            "** Try e.g. a ring without 'a' or 'b' as variable.";
-           return();
+           return();
          }}
        }
@@ -245 +245 @@
     ideal convid=maxideal(1);
     convid[1]=nach_splt3_1(primit)[2];
-    map convert=splt3,convid; 
+    map convert=splt3,convid;
     zwi=convert(zwi);
     setring neuring;