Changeset faed79 in git for Singular/LIB/algebra.lib

Timestamp:

Feb 20, 2009, 10:26:50 AM (15 years ago)

Author:

Hans Schönemann <hannes@…>

Branches:

(u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')

Children:

67555dbff0c54631269c2ede478103e9cd2cc3cf

Parents:

9b4893753f061124557a6f764b1588a09516031e

Message:

*gmg: new versions for normal.lib


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

File:

• Singular/LIB/algebra.lib (modified) (10 diffs)

Singular/LIB/algebra.lib

@@ +1 @@
+//syntax of nselect adopted (intvec instead of two integers),
+//help for finitenessTest and mapIsFinite edited
+//new proc  nonZeroEntry(id), used to fix a bug in proc finitenessTest
 ///////////////////////////////////////////////////////////////////////////////
-version="$Id: algebra.lib,v 1.18 2008-10-24 12:16:59 Singular Exp $";
+version="$Id: algebra.lib,v 1.19 2009-02-20 09:26:50 Singular Exp $";
 category="Commutative Algebra";
 info="
@@ -19 +22 @@
  noetherNormal(id);     noether normalization of ideal id
  mapIsFinite(R,phi,I);  query for finiteness of map phi:R --> basering/I
+
+AUXILIARY PROCEDURES:
  finitenessTest(i,z);   find variables which occur as pure power in lead(i)
+ nonZeroEntry(id);      list describing non-zero entries of an identifier
 ";
 
@@ -778 +784 @@
 @format
          a list l of two ideals, say I,J:
-         - I defines a map (coordinate change in the basering), such that:
-           if we define  map phi=basering,I;
+         - I is generated by a subset of the variables with size(I) = dim(id)
+         - J defines a map (coordinate change in the basering), such that:
+           if we define  map phi=basering,J;
            then k[var(1),...,var(n)]/phi(id) is finite over k[I].
-         - J is generated by a subset of the variables with size(J) = dim(id)
          If p is given, 0<=p<=100, a sparse coordinate change with p percent
          of the matrix entries being 0 (default: p=0 i.e. dense)
@@ -891 +897 @@
 ///////////////////////////////////////////////////////////////////////////////
 
-proc finitenessTest(ideal i,list #)
+proc finitenessTest(ideal i, list #)
 "USAGE:   finitenessTest(J[,v]); J ideal, v intvec (say v1,...,vr with vi>0)
 RETURN:
@@ -906 +912 @@
 THEORY:  If J is a standard basis of an ideal generated by x_1 - f_1(y),...,
          x_n - f_n with y_j ordered lexicographically and y_j >> x_i, then,
-         if y_i appears as pure power in the leading term of J[k]. J[k] defines
+         if y_i appears as pure power in the leading term of J[k], J[k] defines
          an integral relation for y_i over the y_(i+1),... and the f's.
          Moreover, in this situation, if l[2] = y_1,...,y_r, then K[y_1,...y_r]
          is finite over K[f_1..f_n]. If J contains furthermore polynomials
          h_j(y), then K[y_1,...y_z]/<h_j> is finite over K[f_1..f_n].
+         For a proof cf. Prop. 3.1.5, p. 214. in [G.-M. Greuel, G. Pfister:
+         A SINGULAR Introduction to Commutative Algebra, 2nd Edition,
+         Springer Verlag (2007)]
 EXAMPLE: example finitenessTest; shows an example
 "
@@ -916 +925 @@
    intvec v,w;
    int j,z,ii;
+   v[n]=0;                             //v should have size n
    intvec V = 1..n;
+   list nze;                           //the non-zero entries of a leadexp
    if (size(#) != 0 )
    {
@@ -929 +940 @@
    ideal relation,zero,nonzero;
    // ---------------------- check leading exponents -------------------------
+
    for(j=1;j<=ncols(i);j++)
    {
-      w=leadexp(i[j]);
-      if(size(ideal(w))==1)           //the leading term of i[j] is a
+      w = leadexp(i[j]);
+      nze = nonZeroEntry(w);
+      if( nze[1] == 1 )               //the leading term of i[j] is a
       {                               //pure power of some variable
         if( W*w != 0 )                //case: variable has index appearing in V
@@ -944 +957 @@
    //the nonzero entries of v correspond to variables which occur as
    //pure power in the leading term of some polynomial in i
+
    for(j=1; j<=size(v); j++)
    {
@@ -973 +987 @@
 
 proc mapIsFinite(map phi, R, list #)
-"USAGE:   mapIsFinite(phi,R[,J]); R a ring, phi: R ---> basering a map
+"USAGE:   mapIsFinite(phi,R[,J]); R the preimage ring of the map
+         phi: R ---> basering
          J an ideal in the basering, J = 0 if not given
 RETURN:  1 if R ---> basering/J is finite and 0 else
+NOTE:    R may be a quotient ring (this will be ignored since a map R/I-->S/J
+         is finite iff the induced map R-->S/J is finite).
+SEE ALSO: finitenessTest
 EXAMPLE: example mapIsFinite; shows an example
 "
@@ -1023 +1041 @@
 //////////////////////////////////////////////////////////////////////////////
 
+proc nonZeroEntry(id)
+"USAGE:  nonZeroEntry(id); id=object for which the test 'id[i]!=0', i=1,..,N,
+         N=size(id) (resp. ncols(id) for id of type ideal or module)
+         is defined (e.g. ideal, vector, list of polynomials, intvec,...)
+RETURN:  @format
+         a list, say l, with l[1] an integer, l[2], l[3] integer vectors:
+         - l[1] number of non-zero entries of id
+         - l[2] intvec of size l[1] with l[2][i]=i if id[i] != 0
+           in case l[1]!=0 (and l[2]=0 if l[1]=0)
+         - l[3] intvec with l[3][i]=1 if id[i]!=0 and l[3][i]=0 else
+@end format
+NOTE:
+EXAMPLE: example nonZeroEntry; shows an example
+"
+{
+   int ii,jj,N,n;
+   intvec v,V;
+
+   if ( typeof(id) == "ideal" || typeof(id) == "module" )
+   {
+      N = ncols(id);
+   }
+   else
+   {
+     N = size(id);
+   }
+   for ( ii=1; ii<=N; ii++ )
+   {
+      V[ii] = 0;
+      if ( id[ii] != 0 )
+      {
+         n++;
+         v=v,ii;      //the first entry of v is always 0
+         V[ii] = 1;
+      }
+   }
+   if ( size(v) > 1 ) //if id[ii] != 0 for at least one ii delete the first 0
+   {
+      v = v[2..size(v)];
+   }
+
+   list l = n,v,V;
+   return(l);
+}
+example
+{ "EXAMPLE:"; echo = 2;
+   ring r = 0,(a,b,c),dp;
+   poly f = a3c+b3+c2+a;
+   intvec v = leadexp(f);
+   nonZeroEntry(v);
+
+   intvec w;
+   list L = 37,0,f,v,w;
+   nonZeroEntry(L);
+}
+//////////////////////////////////////////////////////////////////////////////
+