Changeset 6fe3a0 in git for Singular/LIB/deform.lib

Timestamp:

Apr 25, 2005, 12:13:07 PM (19 years ago)

Author:

Hans Schönemann <hannes@…>

Branches:

(u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')

Children:

3329dd9bcf2662f9666579abea56c33dfcb530ac

Parents:

8604751c5a5f572004bf8d35d4307e485b728435

Message:

*hannes/lossen: new libs, new tests


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

File:

• Singular/LIB/deform.lib (modified) (17 diffs)

Singular/LIB/deform.lib

@@ -1 @@
-// $Id: deform.lib,v 1.30 2004-04-20 15:55:22 Singular Exp $
+// $Id: deform.lib,v 1.31 2005-04-25 10:13:05 Singular Exp $
 // author: Bernd Martin email: martin@math.tu-cottbus.de
 //(bm, last modified 4/98)
 ///////////////////////////////////////////////////////////////////////////////
-version="$Id: deform.lib,v 1.30 2004-04-20 15:55:22 Singular Exp $";
+version="$Id: deform.lib,v 1.31 2005-04-25 10:13:05 Singular Exp $";
 category="Singularities";
 info="
@@ -14 +14 @@
  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
 ";
 
@@ -27 +26 @@
 "USAGE:   versal(Fo[,d,any]); Fo=ideal, d=int, any=list
 COMPUTE: 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,..\" (deformation parameters), returns as basering; the
-           new variables precede the old ones, the ordering is the
-           product between \"ls\" and \"ord(Po)\"
-         @*'my'Qx = Px/Fo extending Qo=Po/Fo,
-         @*'my'So = the embedding-ring of the versal base space,
-         @*'my'Ox = Px/Js extending So/Js.   (default my=\"\")
-
-      Matrices (in Px, exported):
+RETURN: list L of 4 rings:
+         L[1] extending the basering Po by new variables given by
+          \"A,B,..\" (deformation parameters); the new variables precede 
+         the old ones, the ordering is the product of \"ls\" and \"ord(Po)\" @*
+         L[2] = L[1]/Fo extending Qo=Po/Fo, @*
+         L[3] = the embedding ring of the versal base space, @*
+         L[4] = L[1]/Js extending L[3]/Js. @*
+      In the ring L[1] the following matrices are stored:
          @*Js  = giving the versal base space (obstructions),
          @*Fs  = giving the versal family of Fo,
@@ -43 +40 @@
       If d is defined (!=0), it computes up to degree d.
       @*If 'any' is defined and any[1] is no string, interactive version.
-      @*Otherwise 'any' 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\"
-      ordering string for ring extension), \"out\" name of output-file).
-NOTE:   printlevel < 0        no output at all,
+      @*Otherwise 'any' is interpreted as a list of predefined strings: 
+      \"my\",\"param\",\"order\",\"out\": @*
+      (\"my\" internal prefix, \"param\" is a letter (e.g. \"A\") for the 
+      name of the first parameter or (e.g. \"A(\") for index parameter 
+      variables, \"order\" ordering string for ring extension), \"out\" name 
+      of output file). 
+NOTE:   printlevel < 0        no additional output,
         printlevel >=0,1,2,.. informs you, what is going on;
         this proc uses 'execute'.
@@ -104 +103 @@
   kill Ls;
   t1' = @t1;
-  if( @t1==0) { dbprint(p,"// rigid!"); return();}
+  if( @t1==0) { dbprint(p,"// rigid!"); return(list());}
   if( @t2==0) { @smooth=1; dbprint(p,"// smooth base space");}
   dbprint(p,"// ready: T_1 and T_2");
@@ -123 +122 @@
   }
  //---- create new rings and objects ------------------------------------------
-  get_rings(Fo,t1',1,@my,@order,@param);
- setring `myPx`;
+  list list_of_rings=get_rings(Fo,t1',1,@order,@param);
+  def `myPx`= list_of_rings[1];
+  def `myQx`= list_of_rings[2];
+  def `myOx`= list_of_rings[3];
+  def `mySo`= list_of_rings[4];
+  kill list_of_rings;
+  setring `myPx`;
   @jv=0; @jv[t1']=0; @jv=@jv+1; @jv[nvars(basering)]=0;
                                                //weight-vector for calculating
@@ -206 +210 @@
       degBound = 0;
 //--------------- obtain new base-ring ----------------------------------------
-        if(system("with","Namespaces")==1) { kill Top::`myOx`; }
         if(defined(`myOx`)) {kill `myOx`;}
   qring `myOx` = J;
@@ -268 +271 @@
    "// ___ Equations of miniversal base space ___",Js,
    "// ___ Equations of miniversal total space ___",Fs);
-   dbprint(p,"","// Result belongs to ring "+myPx+".",
-   "// Equations of total space of miniversal deformation are ",
-   "// given by Fs, equations of miniversal base space by Js.",
-   "// Make "+myPx+" the basering and list objects defined in "
-   +myPx+" by typing:",
-   "   setring "+myPx+"; show("+myPx+");","   listvar(matrix);",
-   "// NOTE: rings "+myQx+", "+myPx+", "+mySo+" are alive!",
-   "// (use 'kill_rings(\""+@my+"\");' to remove)");
-   return();
+   dbprint(p,"","
+// 'versal' returned a list, say L, of four rings. In L[1] are stored:
+//   as matrix Fs: Equations of total space of the miniversal deformation,
+//   as matrix Js: Equations of miniversal base space,
+//   as matrix Rs: syzygies of Fs mod Js.
+// To access these data, type
+     def Px=L[1]; setring Px; print(Fs); print(Js); print(Rs);
+");
+   return(list(`myPx`,`myQx`,`mySo`,`myOx`));
 }
 example
@@ -286 +289 @@
    ideal Fo       = minor(m,2);
                     // cone over rational normal curve of degree 4
-   versal(Fo);
+   list L=versal(Fo);
+   L;
+   def Px=L[1]; 
    setring Px;
    // ___ Equations of miniversal base space ___:
@@ -298 +303 @@
 "USAGE:   mod_versal(Mo,I[,d,any]); I=ideal, M=module, d=int, any =list
 COMPUTE: miniversal deformation of coker(Mo) over Qo=Po/Io, Po=basering;
-CREATE:  Ringsr (exported):
-         'my'Px  = extending the basering by new variables (deformation
-                   parameters), the new variables precede the old ones,
-                   the ordering is the product between \"my_ord\"
-                   and \"ord(Po)\"
-         @*'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'=\"\")
-
-      Matrices (in Qx, exported):
+RETURN:  list L of 4 rings:
+         L[1] extending the basering Po by new variables given by
+          \"A,B,..\" (deformation parameters); the new variables precede 
+         the old ones, the ordering is the product of \"ls\" and \"ord(Po)\" @*
+         L[2] = L[1]/Io extending Qo, @*
+         L[3] = the embedding ring of the versal base space, @*
+         L[4] = L[1]/(Io+Js) ring of the versal deformation of coker(Ms). @*
+      In the ring L[1] the following matrices are stored:
          @*Js  = giving the versal base space (obstructions),
-         @*Ms  = giving the versal family of Mo,
-         @*Ls  = giving the lifting of syzygies Lo=syz(Mo),
-
+         @*Fs  = giving the versal family of Mo,
+         @*Rs  = giving the lifting of syzygies Lo=syz(Mo).   
       If d is defined (!=0), it computes up to degree d.
       @*If 'any' is defined and any[1] is no string, interactive version.
-      @*Otherwise 'any' 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\"
-      ordering string for ring extension), \"out\" name of output-file).
-NOTE:   printlevel < 0        no output at all,
+      @*Otherwise 'any' is interpreted as a list of predefined strings: 
+      \"my\",\"param\",\"order\",\"out\": @*
+      (\"my\" internal prefix, \"param\" is a letter (e.g. \"A\") for the 
+      name of the first parameter or (e.g. \"A(\") for index parameter 
+      variables, \"order\" ordering string for ring extension), \"out\" name 
+      of output file). 
+NOTE:   printlevel < 0        no additional output,
         printlevel >=0,1,2,.. informs you, what is going on,
         this proc uses 'execute'.
@@ -381 +385 @@
 //-------- get new rings and objects ------------------------------------------
  setring Po;
-  get_rings(I,e1',0,@my,@order,@param);
+  list list_of_rings=get_rings(I,e1',0,@order,@param);
+  def `myPx`= list_of_rings[1];
+  def `myQx`= list_of_rings[2];
+  def `myOx`= list_of_rings[3];
+  def `mySo`= list_of_rings[4];
+  kill list_of_rings;
  setring `myPx`;
   ideal  J,m_J;
@@ -454 +463 @@
       I_J = Io,J;                attrib(I_J,"isSB",1);
 //-------- obtain new base ring -----------------------------------------------
-      if(system("with","Namespaces")) {
-         if(defined(Top::`myOx`)) { kill Top::`myOx`; }
-      }
       if (defined(`myOx`)) {kill `myOx`;}
  qring `myOx` = I_J;
@@ -517 +523 @@
     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",
-  simplify(ideal(Js),10),
-  "// Matrix of the deformed module is Ms and lifted syzygies are Ls.",
-  "// Make "+myQx+" the basering and list objects defined in "+myQx+
-  " by typing:",
-  "   listvar(ring);setring "+myQx+"; show("+myQx+");listvar(ideal);"+
-  "listvar(matrix);",
-  "// NOTE: rings "+myQx+", "+myOx+", "+mySo+" are still alive!",
-  "// (use: 'kill_rings("+@my+");' to remove them)");
+  dbprint(p,"
+// 'mod_versal' returned a list, say L, of four rings. In L[2] are stored:
+//   as matrix Ms: presentation matrix of the deformed module,
+//   as matrix Ls: lifted syzygies,
+//   as matrix Js:  Equations of total space of miniversal deformation
+// To access these data, type
+     def Qx=L[2]; setring Qx; print(Ms); print(Ls); print(Js);
+");
   option(set,save_opt);
-  return();
+  return(list(`myPx`,`myQx`,`mySo`,`myOx`));
 }
 example
@@ -537 +541 @@
   ideal Io = x4+y3;
   matrix Mo[2][2] = x2,y,-y2,x2;
-  mod_versal(Mo,Io);
+  list L = mod_versal(Mo,Io);
+  def Qx=L[2]; setring Qx;
+  print(Ms);
+  print(Ls);
+  print(Js);
   printlevel = p;
-  if(system("with","Namespaces")) {
-        kill Top::Px,Top::Qx,Top::So;
-  }
   if (defined(Px)) {kill Px,Qx,So;}
 }
@@ -549 +554 @@
 RETURN: nothing, but kills exported rings generated by procedures
         'versal' and 'mod_versal' with optional prefix 'string'
+NOTE: obsolete
 "
 {
@@ -640 +646 @@
 }
 ///////////////////////////////////////////////////////////////////////////////
-proc get_rings(ideal Io,int e1,int switch, list #)
-"
-Sub-procedure: creating ring-extensions
+static proc get_rings(ideal Io,int e1,int switch, list #)
+"
+Sub-procedure: creating ring-extensions, returned as a list of 4 rings
 "
 {
@@ -649 +655 @@
    string my_ord = "ds";
    string my_var = "A";
-   if (size(#)>2)
+   if (size(#)>1)
    {
-     my     = #[1];
-     my_ord = #[2];
-     my_var = #[3];
-   }
-   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);
-   my ="qring "+my_Qx+" = Io;       export("+my_Qx+");";
-   execute(my);
+     my_ord = #[1];
+     my_var = #[2];
+   }
+   def my_Px=extendring(e1,my_var,my_ord);
+   setring my_Px;
+   ideal Io  = imap(Po,Io);         
+   attrib(Io,"isSB",1);
+   qring my_Qx = Io;
    if (switch)
    {
-     setring `my_Px`;
-     my = "qring "+my_Ox+" = std(ideal(0));export("+my_Ox+");";
+     setring my_Px;
+     qring my_Ox = std(ideal(0));
    }
    else
    {
-     my = "def "+my_Ox+" = "+my_Qx+";export("+my_Ox+");";
-   }
-  execute(my);
-  defring(my_So,charstr(Po),e1,my_var,my_ord);
-  return();
+     def my_Ox = my_Qx;
+   }
+   def my_So=defring(charstr(Po),e1,my_var,my_ord);
+   setring my_So;
+   list erg=list(my_Px,my_Qx,my_Ox,my_So);
+   return(erg);
 }
 ///////////////////////////////////////////////////////////////////////////////