Changeset 29984b in git

Timestamp:

Nov 13, 2008, 11:50:17 AM (15 years ago)

Author:

Hans Schönemann <hannes@…>

Branches:

(u'spielwiese', '0d6b7fcd9813a1ca1ed4220cfa2b104b97a0a003')

Children:

8d7d31344f54dfddec02ace97e4ac1e437701713

Parents:

5bc1975ec489442590dc59f82d1fd24d952eb3c8

Message:

*hannes: interred/redSB


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

Location:

Singular/LIB

Files:

• elim.lib (modified) (5 diffs)
• finvar.lib (modified) (2 diffs)

Singular/LIB/elim.lib

@@ -1 @@
-// $Id: elim.lib,v 1.24 2008-10-31 15:33:07 Singular Exp $
-///////////////////////////////////////////////////////////////////////////////
-version="$Id: elim.lib,v 1.24 2008-10-31 15:33:07 Singular Exp $";
+// $Id: elim.lib,v 1.25 2008-11-13 10:50:17 Singular Exp $
+///////////////////////////////////////////////////////////////////////////////
+version="$Id: elim.lib,v 1.25 2008-11-13 10:50:17 Singular Exp $";
 category="Commutative Algebra";
 info="
@@ -8 +8 @@
 PROCEDURES:
  blowup0(j[,s1,s2]);   create presentation of blownup ring of ideal j
+ elimRing(p);          create ring with block ordering for elimating vars in p
  elim(id,..);          variables .. eliminated from id (ideal/module)
  elim1(id,p);          p=product of vars to be eliminated from id
+ elim2(id,..);         variables .. eliminated from id (ideal/module)
  nselect(id,v);        select generators not containing variables given by v
  sat(id,j);            saturated quotient of ideal/module id by ideal j
@@ -183 +185 @@
  }
 ///////////////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////////////
-
-proc elim (id, intvec va)
-"USAGE:   elim(id,v);  id ideal/module, v intvec
+proc elimRing ( poly vars, list #)
+"USAGE:   elimRing(vars [,w]); vars = product of variables to be eliminated 
+         (type poly), w = intvec (specifying weights for all variables)
+RETURN:  a ring, say R, s.t. the monomial ordering of R has 2 blocks. 
+         The first block corresponds to the (given) variables to be eliminated
+         and has ordering dp if these variables have weight all 1; if w is 
+         given or if not all variables in vars have weight 1 the ordering is 
+         wp(w1) where w1 is the intvec of weights of the variables to be 
+         eliminated. 
+         The second block corresponds to variables not to be eliminated. 
+@*       If the first variable not to be eliminated is global (i.e. > 1), 
+         resp. local (i.e. < 1), the second block has ordering dp, resp. ds, 
+         (or wp(w2), resp. ws(w2), where w2 is the intvec of weights of the 
+         variables not to be eliminated).
+@*       If the basering is a quotient ring P/Q, then R a quotient ring 
+         with Q replaced by a standard basis of Q w.r.t. the new ordering
+         (parameters are not touched). 
+NOTE:    The ordering in R is an elimination ordering for the variables
+         appearing in vars.
+PURPOSE: Prepare a ring for eliminating vars from an ideal/moduel by 
+         computing a standard basis in R with a fast monomial ordering. 
+         This procedure is used by the procedure elim.
+EXAMPLE: example elimRing; shows an example
+"
+{
+  def BR = basering;
+  int nvarBR = nvars(BR);
+  list BRlist = ringlist(BR);
+  intvec @w;                   //to store weights of all variables
+  @w[nvarBR] = 0;
+  @w = @w + 1;                 //initialize @w as 1..1
+  if (size(#) == 1)
+  {
+    if ( typeof(#[1]) == "intvec" )
+    {  
+       @w = #[1];              //take the given weights
+    }
+  }
+  else
+  {
+     @w = ringweights(BR);     //compute the ring weights (proc from ring.lib)
+  }
+
+  //--- get variables to be eliminated and ringweights:
+  intvec w1,w2;  //for ringweights of first (w1) and second (w2) block
+  list v1,v2;    //for variables of first (to be liminated) and second block
+
+  int ii;
+  for( ii=1; ii<=nvarBR; ii++ )
+  {
+     if( vars/var(ii)==0 )    //treat variables not to be eliminated
+     { 
+        w2 = w2,@w[ii];
+        v2 = v2+list(string(var(ii)));
+        if ( defined(local) == 0 )
+        {
+           int local = (var(ii) < 1);
+         }
+     }
+     else 
+     {
+        w1 = w1,@w[ii];
+        v1 = v1+list(string(var(ii)));
+     }
+  }
+
+  int l1, l2 = size(w1), size(w2);
+  if ( l1 <= 1 )
+  {
+    ERROR("no elimination ?");
+    //return(BR);
+  }
+  if ( l2 <= 1 )
+  {
+    ERROR("## elimination of all variables is not possible");
+  }
+
+  w1 = w1[2..size(w1)];
+  w2 = w2[2..size(w2)]; 
+
+  //--- put variables to be eliminated in front:
+  BRlist[2] = v1 + v2;  
+             
+  //--- create a block ordering with two blocks and weights:
+  int nblock = size(BRlist[3]);      //number of blocks
+  list BR3 =  BRlist[3];             //save ordering
+  BRlist[3] = list();
+  list B3;
+
+  if( w1==1 )
+  {
+     B3[1] = list("dp", w1);
+  }
+  else
+  {
+     B3[1] = list("wp", w1);
+  }
+
+  if( w2==1 )
+  {
+     if ( local==1 )
+     {
+        B3[2] = list("ds", w2);
+     }
+     else
+     {
+        B3[2] = list("dp", w2);
+     }
+  }
+  else
+  {
+     if ( local==1 )
+     {
+        B3[2] = list("ws", w2);
+     }
+     else
+     {
+        B3[2] = list("wp", w2);
+     }
+  }
+
+  BRlist[3] = B3;
+
+  //Module ordering stays in front resp. at the end:
+  if( BR3[nblock][1] =="c" || BR3[nblock][1] =="C" )
+  {
+    BRlist[3] = insert(BRlist[3],BR3[nblock],size(B3));
+  }
+  else
+  {
+    BRlist[3] = insert(BRlist[3],BR3[1]);
+  }
+
+  def eRing = ring(quotientList(BRlist)); 
+  return (eRing);
+}
+example
+{ "EXAMPLE:"; echo = 2;
+   ring R = 0,(x,y,z,u,v),(c,lp);
+   def P = elimRing(yu);  P;
+   intvec w = 1,1,3,4,5;
+   elimRing(yu,w);
+ 
+   ring S =  (0,a),(x,y,z,u,v),ws(1,2,3,4,5);
+   minpoly = a2+1;
+   qring T = std(ideal(x+y2+v3,(x+v)^2));
+   def Q = elimRing(yv);  
+   setring Q; Q;
+}
+///////////////////////////////////////////////////////////////////////////////
+
+proc elim (id, list #)
+"USAGE:   elim(id,arg[,\"withWeights\"]);  id ideal/module, arg can be either 
+        an intvec vor a product p of variables (type poly) 
+RETURN: ideal/module obtained from id by eliminating either the variables 
+        with indices appearing in v or the variables appearing in p. 
+        Works also in a qring.
+METHOD: elim uses elimRing to create a ring with block ordering with two
+        blocks where the first block contains the variables to be eliminated 
+        and then uses groebner. If the variables in the basering have weights
+        these weights are used in elimRing.
+@*      If a string \"withWeigts\" as second, optional argument is given, 
+        Singular computes weights for the variables to make the input as 
+        homogeneous as possible.
+@*      The method is different from that used by eliminate and elim1;
+        in some examples elim can be significantly faster.
+NOTE:   No special monomial ordering is required, i.e. the ordering can be 
+        local or mixed. The result is a SB with respect to the ordering of 
+        the second block used by elimRing. E.g. if the first var not to be 
+        eliminated is global, resp. local, this ordering is dp, resp. ds 
+        (or wp, resp. ws, with the given weights for these variables). 
+        If printlevel > 0 the ring for which the output is a SB is shown. 
+SEE ALSO: eliminate, elim1
+EXAMPLE: example elim; shows an example
+"
+{  
+  if (size(#) == 0)
+  {
+    ERROR("## specify variables to be eliminated");
+  }
+  int pr = printlevel - voice + 2;   //for ring display if printlevel > 0
+  def BR = basering;
+//-------------------------------- check input -------------------------------
+  poly vars;
+  int ii; 
+  if (size(#) > 0)
+  {
+    if ( typeof(#[1]) == "poly" )
+    {  
+      vars = #[1];
+    }
+    if ( typeof(#[1]) == "intvec")
+    {  
+      vars=1;
+      for( ii=1; ii<=size(#[1]); ii++ ) 
+      {  
+        vars=vars*var(#[1][ii]); 
+      }
+    }
+  }
+  if (size(#) == 2)
+  {
+    if ( typeof(#[2]) == "string" )
+    {  
+       if ( #[2] == "withWeights" )
+       { 
+         intvec @w = weight(id);
+       }
+    }
+  }
+
+//-------------- create new ring and map objects to new ring ------------------
+  if ( defined(@w) )
+  {
+     def ER = elimRing(vars,@w);
+  }
+  else
+  {
+     def ER = elimRing(vars);
+  }
+  setring ER;
+  def id = imap(BR,id);
+  poly vars = imap(BR,vars);
+//---------- now eliminate in new ring and map back to old ring ---------------
+  id = groebner(id);
+  id = nselect(id,1..size(ringlist(ER)[3][1][2]));
+  if ( pr > 0 ) 
+  { 
+     "// result is a SB in the following ring:";
+     ER;
+  }
+  setring BR;
+  return(imap(ER,id));
+}
+example
+{ "EXAMPLE:"; echo = 2;
+   ring r=0,(x,y,u,v,w),dp;
+   ideal i=x-u,y-u2,w-u3,v-x+y3;
+   elim(i,3..4);
+   elim(i,uv); 
+   int p = printlevel;
+   printlevel = 2;
+   elim(i,uv,"withWeights");
+   printlevel = p;
+
+   ring S =  (0,a),(x,y,z,u,v),ws(1,2,3,4,5);
+   minpoly = a2+1;
+   qring T = std(ideal(ax+y2+v3,(x+v)^2));
+   ideal i=x-u,y-u2,az-u3,v-x+ay3;
+   module m=i*gen(1)+i*gen(2);
+   m=elim(m,xy);
+   show(m);
+}
+///////////////////////////////////////////////////////////////////////////////
+
+proc elim2 (id, intvec va)
+"USAGE:   elim2(id,v);  id ideal/module, v intvec
 RETURNS: ideal/module obtained from id by eliminating variables in v
 NOTE:    no special monomial ordering is required, result is a SB with
@@ -194 +447 @@
          eliminated belongs to a -p (resp. -s) blockordering
          This proc uses 'execute' or calls a procedure using 'execute'.
-SEE ALSO: elim1, eliminate
-EXAMPLE: example elim; shows examples
+SEE ALSO: elim1, eliminate, elim
+EXAMPLE: example elim2; shows examples
 "
 {
@@ -220 +473 @@
    ring r=0,(x,y,u,v,w),dp;
    ideal i=x-u,y-u2,w-u3,v-x+y3;
-   elim(i,3..4);
+   elim2(i,3..4);
    module m=i*gen(1)+i*gen(2);
-   m=elim(m,3..4);show(m);
+   m=elim2(m,3..4);show(m);
 }
 ///////////////////////////////////////////////////////////////////////////////

Singular/LIB/finvar.lib

@@ -1 +1 @@
 ///////////////////////////////////////////////////////////////////////////////
-version="$Id: finvar.lib,v 1.78 2008-10-31 15:32:45 Singular Exp $"
+version="$Id: finvar.lib,v 1.79 2008-11-13 10:50:17 Singular Exp $"
 category="Invariant theory";
 info="
@@ -7106 +7106 @@
     }
   }
-  M=elim(module(M),1..n);   // eliminating x(1..n), std-calculation
+  M=elim2(module(M),1..n);   // eliminating x(1..n), std-calculation
                             // is done internally -
   //M=std(module(M));                // we have already an elimination ordering