Changeset 67803e in git

Timestamp:

May 4, 2011, 7:27:32 PM (12 years ago)

Author:

Hans Schoenemann <hannes@…>

Branches:

(u'jengelh-datetime', 'ceac47cbc86fe4a15902392bdbb9bd2ae0ea02c6')(u'spielwiese', '0604212ebb110535022efecad887940825b97c3f')

Children:

62c2b035a539149974daf79c638bf771a66e7ada

Parents:

ed7a55cee630718a52f781951594ce050f910d0b

Message:

normaliz 2.7

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

File:

• Singular/LIB/normaliz.lib (modified) (50 diffs)

Singular/LIB/normaliz.lib

@@ -4 +4 @@
 category="Commutative algebra"
 info="
-LIBRARY: normaliz.lib  Provides an interface for the use of Normaliz 2.2
+LIBRARY: normaliz.lib  Provides an interface for the use of Normaliz 2.7
          within SINGULAR.
 AUTHORS:  Winfried Bruns, Winfried.Bruns@Uni-Osnabrueck.de
@@ -10 +10 @@
 
 OVERVIEW:
-@texinfo
-The library normaliz.lib provides an interface for the use of Normaliz 2.2
-within SINGULAR. The exchange of data is via files, the only possibility
-offered by Normaliz in its present version. In addition to the top level
+The library normaliz.lib provides an interface for the use of Normaliz 2.7
+within SINGULAR. The exchange of data is via files.
+In addition to the top level
 functions that aim at objects of type ideal or ring, several other auxiliary
 functions allow the user to apply Normaliz to data of type intmat. Therefore
 SINGULAR can be used as a comfortable environment for the work with Normaliz.
-@* Please see the @code{Normaliz2.2Documentation.pdf} and @code{nmz_sing.pdf}
-(both are included in the Normaliz distribution) for a more extensive
-documentation of Normaliz.
-@*
+@* Please see the @code{Normaliz2.7Documentation.pdf} (included in the Normaliz
+distribution) for a more extensive documentation of Normaliz.
+@code{nmz_sing.pdf} describes this library version 2.2, but most points are
+still valid.
+
 @*Singular and Normaliz exchange data via files. These files are automatically
 created and erased behind the scenes. As long as one wants to use only the
 ring-theoretic functions there is no need for file management.
-@*
+
 @*Note that the numerical invariants computed by Normaliz can be
 accessed in this \"automatic file mode\".
-@*
+
 @*However, if Singular is used as a frontend for Normaliz or the user
 wants to inspect data not automatically returned to Singular, then
@@ -33 +33 @@
 data. Moreover, the library provides functions for access to these files.
 Deletion of the files is left to the user.
-@*
+
 @* Use of this library requires the program Normaliz to be installed.
 You can download it from
@@ -39 +39 @@
 that the executables are in the search path or use setNmzExecPath
 (@ref{setNmzExecPath}).
-@end texinfo
-NOTE:    These library functions use @code{sed} to transfer the Normaliz
-output into a SINGULAR compliant format.
-
 
 KEYWORDS: integral closure; normalization
@@ -53 +49 @@
                               generated by the leading monomials of the
                               elements of I
+ normalToricRingFromBinomials(ideal I)  computes the normalization of the
+                              polynomial ring modulo the unique minimal prime
+                              ideal of the binomial ideal I
  ehrhartRing(ideal I)         computes the monomials representing the lattice
                               points of the polytop generated leading monomials
@@ -61 +60 @@
 
  torusInvariants(intmat T)    computes the ring of invariants of a torus action
- valRing(intmat V)            computes the intersection of the polynomial ring
-                              with the valuation rings of monomial valuations
- valRingIdeal(intmat V)       computes ideals of monomial valuations
+ finiteDiagInvariants(intmat C)  computes the ring of invariants of a finite
+                                 abelian group acting diagonally on a polynomial
+                                 ring
+ diagInvariants(intmat C)     computes the ring of invariants of a
+                              diagonalizable group
+ intersectionValRings(intmat V)   computes the intersection of the polynomial
+                                  ring with the valuation rings of monomial
+                                  valuations
+ intersectionValRingIdeals(intmat V)       computes ideals of monomial valuations
 
  showNuminvs()                prints the numerical invariants
@@ -72 +77 @@
 
  normaliz(intmat sgr,int nmz_mode) applies Normaliz
- setNmzVersion(string nmz_version_name) sets the version of the Normaliz
-                                        executable
  setNmzExecPath(string nmz_exec_path_name) sets the path to the Normaliz
                                            executable
@@ -94 +97 @@
                                which have the rows of expo_vecs as
                                exponent vector
+ binomials2intmat(ideal I)    returns the intmat whose rows represent the
+                              exponents of the elements of the binomial ideal I
 ";
 
@@ -174 +179 @@
 NOTE:     It is not necessary to use this function if the Normaliz executable
           is in the search path of the system.
-SEE ALSO: setNmzVersion
+SEE ALSO: setNmzOption
 EXAMPLE:  example setNmzExecPath; shows an example"
 {
@@ -184 +189 @@
   setNmzExecPath("../Normaliz/");
 }
-
-proc setNmzVersion(string nmz_version_name)
-"USAGE:   setNmzVersion(string s);  @code{s} version of the Normaliz executable
-CREATE:   @code{Normaliz::nmz_version} to save the given version @code{s}
-NOTE:     The version coincides with the filename of the Normaliz executable.
-          Possible arguments are:
-          @* @code{norm32} for 32bit integer precision
-          @* @code{norm64} for 64bit integer precision (default)
-          @* @code{normbig} for arbitrary precision
-SEE ALSO: setNmzExecPath
-EXAMPLE:  example setNmzVersion; shows an example
-"
-{
-    desString("nmz_version",nmz_version_name);
-}
-example
-{ "EXAMPLE:";echo = 2;
-  setNmzVersion("normbig");
-}
-
 
 proc setNmzFilename(string nmz_filename_name)
@@ -385 +370 @@
 static proc setNmzExec()
 {
-    if(queryString("nmz_exec")=="")
-    {
-        return(queryString("nmz_exec_path")+"norm64");
-    }
-    return(queryString("nmz_exec_path")+queryString("nmz_exec"));
+    return(queryString("nmz_exec_path")+"normaliz");
 }
 
@@ -406 +387 @@
     }
 
-    list suffixes="in","gen","out","sup","typ","egn","esp","inv","tri","ht1",
+    list suffixes="in","gen","out","cst","typ","egn","esp","inv","tri","ht1",
                   "ext";
     int i,dummy;
@@ -414 +395 @@
     {
         f=getNmzFile()+"."+suffixes[i];
-        dummy=system("sh","rm "+f+ "&> /dev/null");
+        if (fileExists(f)) { dummy=system("sh","rm "+f+ "&> /dev/null"); }
     }
 }
@@ -474 +455 @@
 static proc getInt(string s, int p)
 {
-
     string nst;
     int i,j,en,sn;
@@ -507 +487 @@
 }
 
+
 static proc getRational(string s, int p)
 {
-
     string nst;
     int i,j,en,sn;
@@ -556 +536 @@
 }
 
+
 static proc findWord(string s, string t, int p)
 {
@@ -571 +552 @@
 }
 
+
 static proc skipEqualsign(string s,int p)
 {
@@ -586 +568 @@
 // input and output to/from normaliz
 
-static proc doWriteNmzData(intmat sgr, int num_cols, n_mode)
+//list must have pairs of intmat, nmz_mode
+static proc doWriteNmzData(list #)
 {
     string s;
-    int j;
+    int i,j;
     link outf=":w "+ getNmzFile() +".in";  // also sets the filename
-    write(outf,nrows(sgr));
-    write(outf,num_cols);
-
-    for(int i=1;i<=nrows(sgr);i++)
-    {
+
+    intmat sgr;
+    int num_rows, num_cols, n_mode;
+
+    for (int k=1; k+1<=size(#); k=k+2) {
+    //get data from the parameter list
+      sgr   = #[k];
+      num_rows = nrows(sgr);
+      num_cols = ncols(sgr);
+                n_mode   = #[k+1];
+
+      write(outf,num_rows);
+      write(outf,num_cols);
+
+      for(i=1;i<=nrows(sgr);i++)
+      {
         s="";
         for(j=1;j<=num_cols;j++)
         {
-             s=s+string(sgr[i,j])+" ";
+           s=s+string(sgr[i,j])+" ";
         }
         write(outf,s);
-    }
-    write(outf,n_mode);
+      }
+      write(outf,n_mode);
+      write(outf,"");
+    }
     close(outf);
 }
 
-proc writeNmzData(intmat sgr, int n_mode)
+
+proc writeNmzData(intmat sgr, int n_mode, list #)
 "USAGE:   writeNmzData(intmat M, int mode);
+          writeNmzData(intmat M, int mode, intmat M2, int mode2, ...);
 CREATE:   Creates an input file for Normaliz from the matrix M. The second
           parameter sets the mode. How the matrix is interpreted depends on the
           mode. See the Normaliz documentation for more information.
+
+                         It is also possible to give more than one pair of matrix and mode. In
+                         this case all matrices and modes are written. This can be used to
+                         combine modes 4,5,6.
 NOTE:     Needs an explicit filename set. The filename is created from the
-          current filename and the suffix given to the function.
+          current filename.
    @*     Note that all functions in normaliz.lib write and read their data
           automatically to and from the hard disk so that writeNmzData will
@@ -624 +626 @@
         ERROR("writeNmzData: no filename specified");
     }
-    doWriteNmzData(sgr, ncols(sgr), n_mode);
+    doWriteNmzData(list(sgr, n_mode) + #);
 }
 example
@@ -632 +634 @@
   writeNmzData(sgr,1);
   int dummy=system("sh","cat VeryInteresting.in");
+
+  intmat Hyperplanes[2][3] = 2,-1,0, // 2x-y >= 0
+                             1, 1,0; //  x+y >= 0
+  intmat Equation[1][3] = 0,1,-1;    // y = z
+  intmat Congruence[1][4] = 1,0,0,3;  // x = 0 (3)
+  writeNmzData(Hyperplanes,4,Equation,5,Congruence,6);
+  dummy=system("sh","cat VeryInteresting.in");
 }
 
@@ -644 +653 @@
    @*    Note that all functions in normaliz.lib write and read their data
          automatically so that readNmzData will usually not be used explicitly.
-   @*    This function uses the command @code{sed} to transfer the normaliz
-         output into a singular conform format.
+   @*    This function reads only the first matrix in a file!
 SEE ALSO: writeNmzData, rmNmzFiles, setNmzFilename, setNmzDataPath
 EXAMPLE:  example readNmzData; shows an example"
@@ -656 +664 @@
     string s;
     int n_rows,n_cols;            //number of rows/columns
-    int p, q;                     //positions
+    int p;                     //position
+    int i,j;
     int returnvalue;
 
     string filename = getNmzFile() + "."+ nmz_suffix;
-    string tmpfilename = filename+".tmp";
-//"// ** readNmzData: initialisiert";    //TODO debugoutput wieder rausnehmen
-    returnvalue = system("sh","sed 's/ /,/g' < "+filename+" > "+tmpfilename);
-//"// ** readNmzData: sed ausgefuehrt";
-    link in_f=":r "+ tmpfilename;
-
+    link in_f=":r "+ filename;
     s=read(in_f);
     close(in_f);
-    returnvalue = system("sh","rm "+tmpfilename);
-//"// ** readNmzData: datei eingelesen";
-    p=1; q=size(s);
+
+    p=1;
     (n_rows,p)=getInt(s,p);
     (n_cols,p)=getInt(s,p);
-    //intmat nmz_gen[n_rows][n_cols];
-    while(s[q]!=",")
-    {
-      q--;
-    }
-    //string c = "nmz_gen=" + s[p,q-p] + ";";
-    string c = "intmat nmz_gen["+ string(n_rows) +"]["+ string(n_cols) +"]="
-             + s[p,q-p] + ";";
-//"// ** readNmzData: string gebastelt";
-    execute(c);
-//"// ** readNmzData: string ausgefuehrt";
+    if (n_rows <= 0 || n_cols <= 0) {
+             intmat empty;
+             return(empty);
+    }
+         intmat nmz_gen[n_rows][n_cols];
+    for(i=1;i<=n_rows;i++)
+    {
+        for(j=1;j<=n_cols;j++)
+        {
+            (nmz_gen[i,j],p) = getInt(s,p);
+        }
+    }
     return(nmz_gen);
 }
@@ -691 +695 @@
   intmat sgr[3][3]=1,2,3,4,5,6,7,8,10;
   intmat sgrnormal=normaliz(sgr,0);
-  readNmzData("sup");
+  readNmzData("cst");
   readNmzData("typ");
 }
@@ -709 +713 @@
     {
         list nmz_options=
+        list("supp",0,"-s",0),
+        list("triang",0,"-v",0),
+        list("volume",0,"-V",0),
         list("hvect",0,"-p",0),
-        list("triang",0,"-v",0),
-        list("supp",0,"-s",0),
+        list("hvect_l",0,"-P",0),
+        list("height1",0,"-1",0),
         list("normal",0,"-n",1),
+        list("normal_l",0,"-N",1),
         list("hilb",0,"-h",1),
+        list("hilb_l",0,"-H",1),
         list("dual",0,"-d",1),
         list("control",0,"-c",2),
         list("allf",0,"-a",2),
-        list("ignore",1,"-i",2),
-        list("errorcheck",0,"-e",2);
+        list("errorcheck",0,"-e",2),
+        list("bigint",0,"-B",2),
+        list("threads",0,"-x=",2);
         export(nmz_options);
     }
@@ -730 +740 @@
 @* @code{-s:  supp}
 @* @code{-v:  triang}
+@* @code{-V:  volume}
 @* @code{-p:  hvect}
+@* @code{-P:  hvect_l}
+@* @code{-1:  height1}
 @* @code{-n:  normal}
+@* @code{-N:  normal_l}
 @* @code{-h:  hilb}
+@* @code{-H:  hilb_l}
 @* @code{-d:  dual}
 @* @code{-a:  allf}
 @* @code{-c:  control}
-@* @code{-i:  ignore}
 @* @code{-e:  errorcheck}
+@* @code{-B:  bigint} Use GMP for arbitrary precision integers
+@* @code{-x=N:  threads} In this case the int parameter is used to set the
+                         number of threads N, 0 means no explicit limiting.
+
 SEE ALSO: showNmzOptions
 EXAMPLE:  example setNmzOption; shows an example
@@ -769 +787 @@
         if(nmz_options[i][2])
         {
-            run_options=run_options+nmz_options[i][3]+" ";
+            run_options=run_options+nmz_options[i][3];
+                                if (nmz_options[i][1]=="threads") {
+                                        run_options=run_options+string(nmz_options[i][2]);
+                                }
+                                run_options=run_options+" ";
             if(nmz_options[i][4]!=2)
             {
@@ -796 +818 @@
 
 
-static proc runNormaliz(intmat sgr,int num_cols, nmz_mode)
+static proc runNormaliz(intmat sgr,nmz_mode, list #)
 {
     if(!queryInt("nmz_files_keep_switch"))
@@ -803 +825 @@
     }
 
-    doWriteNmzData(sgr,num_cols,nmz_mode);
+    doWriteNmzData(list(sgr, nmz_mode) + #);
 
     if(queryInt("nmz_files_keep_switch"))
@@ -846 +868 @@
 }
 
-proc normaliz(intmat sgr,int nmz_mode)
+proc normaliz(intmat sgr,int nmz_mode, list #)
 "USAGE:   normaliz(intmat sgr,int nmz_mode);
+          normaliz(intmat sgr, int nmz_mode, intmat sgr2, int nmz_mode2, ...);
 RETURN:   The function applies Normaliz to the parameter sgr in the mode set
           by nmz_mode. The function returns the intmat defined by the file
           with suffix gen.
+
+          It is also possible to give more than one pair of matrix and mode. In
+                         this case all matrices and modes are used. This can be used to
+                         combine modes 4,5,6.
 NOTE:     You will find procedures for many applications of Normaliz in this
           library, so the explicit call of this procedure may not be necessary.
 SEE ALSO: intclToricRing, normalToricRing, ehrhartRing, intclMonIdeal,
-          torusInvariants, valRing, valRingIdeal
+          torusInvariants, diagInvariants, finiteDiagInvariants, intersectionValRings,
+                         intersectionValRingIdeals
 EXAMPLE:  example normaliz; shows an example
 "
 {
-    return(runNormaliz(sgr,ncols(sgr),nmz_mode));
+    return(runNormaliz(sgr,nmz_mode,#));
 }
 example
@@ -867 +895 @@
                  1,3;
   normaliz(M,1);
+
+  intmat Hyperplanes[2][3] = 2,-1,0, // 2x-y >= 0
+                             1, 1,0; //  x+y >= 0
+  intmat Equation[1][3] = 0,1,-1;    // y = z
+  intmat Congruence[1][4] = 1,0,0,3;  // x = 0 (3)
+  normaliz(Hyperplanes,4,Equation,5,Congruence,6);
 }
 
@@ -1023 +1057 @@
     intvec expo_v;
 
-    int last_comp;
     k=0;
     for(i=1;i<=ncols(I);i++)
@@ -1118 +1151 @@
 
 
+proc binomials2intmat(ideal I)
+"USAGE:   binomials2intmat(ideal I);
+RETURN:   Returns the intmat whose rows represent the exponents of the
+          (non-zero) elements of I which have to be binomials.
+                         The length of each row is nvars(basering).
+SEE ALSO: mons2intmat, intmat2mons
+EXAMPLE:  example binomials2intmat; shows an example"
+{
+  int i,j,k;
+  intmat expo_vecs[size(I)][nvars(basering)];
+  intvec expo_v;
+
+  k=0;
+  poly f;
+
+  for(i=1; i<=ncols(I); i++)
+  {
+    if( I[i] != 0 )
+    {
+      k++;
+      f = I[i];
+      if (leadcoef(f) != 1) {f = -f};  //works in all characteristics
+      if (size(f)!=2 || leadcoef(f)!=1 || leadcoef(f[2])!=-1)
+      {
+        ERROR(string("normalToricRing: binomial ideal expected: generator ",i,": ",I[i]));
+      }
+      expo_v = leadexp(f)-leadexp(f[2]);
+      for(j=1;j<=nvars(basering);j++)
+      {
+        expo_vecs[k,j]=expo_v[j];
+      }
+    }
+  }
+  return(expo_vecs);
+}
+example
+{ "EXAMPLE:"; echo=2;
+  ring S = 37,(u,v,w,x,y,z),dp;
+  ideal I = u2v-xyz, ux2-vyz, uvw-y2z;
+  binomials2intmat(I);
+}
+
 
 // integral closure of rings and ideals
@@ -1127 +1202 @@
     string dummy=collectNmzOptions(); // only to set GenGen
 
-/*    if(!GenGen) // return I
-    {
-        runNormaliz(expo_vecs,ncols(expo_vecs),nmz_mode);
-        return(I);
-    }
-*/    return( intmat2mons( runNormaliz(expo_vecs,ncols(expo_vecs),nmz_mode) ) );
+    return( intmat2mons( runNormaliz(expo_vecs,nmz_mode) ) );
 }
 
@@ -1174 +1244 @@
 NOTE:     A mathematical remark: the toric ring depends on the list of
           monomials given, and not only on the ideal they generate!
-SEE ALSO: intclToricRing, ehrhartRing, intclMonIdeal
+SEE ALSO: intclToricRing, ehrhartRing, intclMonIdeal, normalToricRingFromBinomials
 EXAMPLE:  example normalToricRing; shows an example
 "
@@ -1182 +1252 @@
 example
 { "EXAMPLE:"; echo=2;
-  ring R=37,(x,y,t),dp;
-  ideal I=x3,x2y,y3;
+  ring  R = 37,(x,y,t),dp;
+  ideal I = x3,x2y,y3;
   normalToricRing(I);
+}
+
+
+proc normalToricRingFromBinomials(ideal I)
+"USAGE:   normalToricRingFromBinomials(ideal I);
+RETURN:
+@tex
+The ideal $I$ is generated by binomials of type $X^a-X^b$ (multiindex notation)
+in the surrounding polynomial ring $K[X]=K[X_1,...,X_n]$. The binomials
+represent a congruence on the monoid ${Z}^n$ with residue monoid $M$.
+Let $N$ be the image of $M$ in gp($M$)/torsion. Then $N$ is universal in the
+sense that every homomorphism from $M$ to an affine monoid factors through $N$.
+If $I$ is a prime ideal, then $K[N]= K[X]/I$. In general, $K[N]=K[X]/P$ where
+$P$ is the unique minimal prime ideal of $I$ generated by binomials of type
+$X^a-X^b$.
+
+The function computes the normalization of $K[N]$ and returns a newly created
+polynomial ring of the same Krull dimension, whose variables are
+$x(1),...,x(n-r)$, where $r$ is the rank of the matrix with rows $a-b$.
+(In general there is no canonical choice for such an embedding.)
+Inside this polynomial ring there is an ideal $I$ which lists the algebra
+generators of the normalization of $K[N]$.
+@end tex
+@*        The function returns the input ideal I if one of the options
+          @code{supp}, @code{triang}, or @code{hvect} has been activated.
+          However, in this case some numerical invariants are computed, and
+          some other data may be contained in files that you can read into
+          Singular.
+SEE ALSO: intclToricRing, normalToricRing, ehrhartRing, intclMonIdeal
+EXAMPLE:  example normalToricRing; shows an example
+"
+{
+        intmat expo_vecs = binomials2intmat(I);
+        string dummy=collectNmzOptions(); // only to set GenGen
+        intmat result = runNormaliz(expo_vecs,10);
+
+        list baseringlist = ringlist(basering);
+        ring S = (baseringlist[1]),(x(1..ncols(result))),dp;
+        ideal I = intmat2mons(result);
+        export(I);
+        return (S);
+}
+example
+{ "EXAMPLE:"; echo=2;
+  ring R = 37,(u,v,w,x,y,z),dp;
+  ideal I = u2v-xyz, ux2-wyz, uvw-y2z;
+  def S = normalToricRingFromBinomials(I);
+  setring S;
+  I;
 }
 
@@ -1204 +1323 @@
     string dummy=collectNmzOptions(); // only to set GenGen
 
-/*    if(!GenGen) // return I
-    {
-        runNormaliz(expo_vecs,ncols(expo_vecs),nmz_mode);
-        return(list(I));
-    }
-*/
-    intmat nmz_data=runNormaliz(expo_vecs,ncols(expo_vecs)-1+last_comp,
-                                                                  nmz_mode);
+    //adjust size of input matrix
+         if (!last_comp) { // remove last component
+             intmat tmp[nrows(expo_vecs)][ncols(expo_vecs)-1] = expo_vecs[1..nrows(expo_vecs),1..(ncols(expo_vecs)-1)];
+                  expo_vecs = tmp;
+         }
+    intmat nmz_data=runNormaliz(expo_vecs,nmz_mode);
 
     if(last_comp)
@@ -1247 +1364 @@
 @*        The function returns the a list containing the input ideal I if one
           of the options @code{supp}, @code{triang}, or @code{hvect} has been
-          activated.
+                         activated.
           However, in this case some numerical invariants are computed, and
           some other data may be contained in files that you can read into
-          Singular (see @ref{showNuminvs}, @ref{exportNuminvs}).
+          Singular.
 NOTE:      A mathematical remark: the Ehrhart ring depends on the list of
            monomials given, and not only on the ideal they generate!
@@ -1284 +1401 @@
 @*        The function returns the a list containing the input ideal I if one
           of the options @code{supp}, @code{triang}, or @code{hvect} has been
-          activated.
+                         activated.
           However, in this case some numerical invariants are computed, and
           some other data may be contained in files that you can read into
           Singular (see @ref{showNuminvs}, @ref{exportNuminvs}).
-NOTE:     A mathematical remark: the Rees algebra depends on the list of
-          monomials given, and not only on the ideal they generate!
 SEE ALSO: intclToricRing, normalToricRing, ehrhartRing
 EXAMPLE:  example intclMonIdeal; shows an example
@@ -1307 +1422 @@
 // torus invariants and valuation rings and ideals
 
-proc torusInvariants(intmat T)
+proc torusInvariants(intmat E)
 "USAGE:   torusInvariants(intmat A);
-RETURN:   @texinfo
+RETURN:
 Returns an ideal representing the list of monomials generating the ring of
 invariants as an algebra over the coefficient field.
@@ -1315 +1430 @@
 $R^T$.
 @end tex
-@*        The function returns the ideal given by the input matrix T if one of
-          the options @code{supp}, @code{triang}, or @code{hvect} has been
-          activated.
-          However, in this case some numerical invariants are computed, and
-          some other data may be contained in files that you can read into
-          Singular (see @ref{showNuminvs}, @ref{exportNuminvs}).
-@end texinfo
-BACKGROUND: @texinfo
+@*The function returns the ideal given by the input matrix A if one of
+the options @code{supp}, @code{triang}, or @code{hvect} has been
+activated.
+However, in this case some numerical invariants are computed, and
+some other data may be contained in files that you can read into
+Singular.
+BACKGROUND:
 @tex
  Let $T = (K^*)^r$ be the $r$-dimensional torus acting on the polynomial ring
@@ -1333 +1447 @@
 $A=(a_{i,j})$.
 @end tex
-@end texinfo
-NOTE:@texinfo
-@tex
-It is of course possible that $R^T=K$. At present, Normaliz cannot deal with
-the zero cone and will issue the (wrong) error message that the cone is not
-pointed. The function also gives an error message if the matrix $T$ has the
-wrong number of columns.
-@end tex
-@end texinfo
-SEE ALSO: valRing, valRingIdeal
+SEE ALSO: diagInvariants, finiteDiagInvariants, intersectionValRings,
+          intersectionValRingIdeals
 EXAMPLE:  example torusInvariants; shows an example
 "
 {
-    if(nvars(basering)!=ncols(T))
+    if(nvars(basering)!=ncols(E))
     {
         ERROR("torusInvariants: wrong number of columns in matrix");
@@ -1353 +1459 @@
     string dummy=collectNmzOptions();  // only to set GenGen
 
-/*    if(!GenGen) // return T
-    {
-        runNormaliz(T,ncols(T),5);
-        return(T);
-    }
-*/    return( intmat2mons( runNormaliz(T,ncols(T),5) ) );
+    return( intmat2mons( runNormaliz(E,5) ) );
 }
 example
 { "EXAMPLE:"; echo=2;
   ring R=0,(x,y,z,w),dp;
-  intmat V0[2][4]=0,1,2,3, -1,1,2,1;
-  valRing(V0);
-}
-
-proc valRing(intmat V)
-"USAGE:   valRing(intmat V);
+  intmat E[2][4] = -1,-1,2,0, 1,1,-2,-1;
+  torusInvariants(E);
+}
+
+proc finiteDiagInvariants(intmat C)
+"USAGE:   finiteDiagInvariants(intmat U);
+RETURN:
+@tex
+This function computes the ring of invariants of a finite abelian group $G$
+acting diagonally on the surrounding polynomial ring $K[X_1,...,X_n]$. The
+group is the direct product of cyclic groups generated by finitely many
+elements $g_1,...,g_w$. The element $g_i$ acts on the indeterminate $X_j$ by
+$g_i(X_j)=\lambda_i^{u_{ij}}X_j$ where $\lambda_i$ is a primitive root of
+unity of order equal to $ord(g_i)$. The ring of invariants is generated by all
+monomials satisfying the system
+$u_{i1}a_1+\ldots+u_{in} a_n \equiv 0$ mod ord$(g_i)$, $i=1,\ldots,w$.
+The input to the function is the $w\times(n+1)$ matrix $U$ with rows
+$u_{i1}\ldots u_{in}$ ord$(gi)$, $i=1,\ldots,w$. The output is a monomial ideal
+listing the algebra generators of the subalgebra of invariants
+{$R^G=\{f\in R : g_i f = f$ for all $i=1,\ldots,w\}$}.
+@end tex
+@*The function returns the ideal given by the input matrix C if one of
+the options @code{supp}, @code{triang}, or @code{hvect} has been
+activated.
+However, in this case some numerical invariants are computed, and
+some other data may be contained in files that you can read into
+Singular.
+NOTE:
+SEE ALSO: torusInvariants, diagInvariants, intersectionValRings,
+          intersectionValRingIdeals,showNuminvs,exportNuminvs
+EXAMPLE:  example finiteDiagInvariants; shows an example
+"
+{
+    if(nvars(basering)!=ncols(C)-1)
+    {
+        ERROR("finiteDiagInvariants: wrong number of columns in matrix");
+    }
+
+    string dummy=collectNmzOptions();  // only to set GenGen
+
+    return( intmat2mons( runNormaliz(C,6) ) );
+}
+example
+{ "EXAMPLE:"; echo=2;
+  ring R = 0,(x,y,z,w),dp;
+  intmat C[2][5] = 1,1,1,1,5, 1,0,2,0,7;
+  finiteDiagInvariants(C);
+}
+
+proc diagInvariants(intmat E, intmat C)
+"USAGE:   diagInvariants(intmat A, intmat U);
+RETURN:
+@tex
+This function computes the ring of invariants of a diagonalizable group
+$D = T\times G$ where $T$ is a torus and $G$ is a finite abelian group, both
+acting diagonally on the polynomial ring $K[X_1,\ldots,X_n]$. The group
+actions are specified by the input matrices A and U. The first matrix specifies
+the torus action, the second the action of the finite group. See
+torusInvariants and finiteDiagInvariants for more detail. The output is a
+monomial ideal listing the algebra generators of the subalgebra of invariants.
+@end tex
+@*The function returns the ideal given by the input matrix A if one of
+the options @code{supp}, @code{triang}, or @code{hvect} has been
+activated.
+However, in this case some numerical invariants are computed, and
+some other data may be contained in files that you can read into
+Singular.
+SEE ALSO: torusInvariants, finiteDiagInvariants, intersectionValRings, intersectionValRingIdeals,showNuminvs,exportNuminvs
+EXAMPLE:  example diagInvariants; shows an example
+"
+{
+    if(nvars(basering)!=ncols(E) || nvars(basering)!=ncols(C)-1)
+    {
+        ERROR("diagInvariants: wrong number of columns in matrix");
+    }
+
+    string dummy=collectNmzOptions();  // only to set GenGen
+
+    return( intmat2mons( runNormaliz(E,5,C,6) ) );
+}
+example
+{ "EXAMPLE:"; echo=2;
+  ring R=0,(x,y,z,w),dp;
+  intmat E[2][4] = -1,-1,2,0, 1,1,-2,-1;
+  intmat C[2][5] = 1,1,1,1,5, 1,0,2,0,7;
+  diagInvariants(E,C);
+}
+
+proc intersectionValRings(intmat V)
+"USAGE:   intersectionValRings(intmat V);
 RETURN:   The function returns a monomial ideal, to be considered as the list
           of monomials generating @math{S} as an algebra over the coefficient
           field.
-BACKGROUND: @texinfo
+BACKGROUND:
 @tex
 A discrete monomial valuation $v$ on $R = K[X_1 ,\ldots,X_n]$ is determined by
@@ -1380 +1565 @@
 its input.
 @end tex
-@end texinfo
-@*        The function returns the ideal given by the input matrix V if one of
-          the options @code{supp}, @code{triang}, or @code{hvect} has been
-          activated.
-          However, in this case some numerical invariants are computed, and
-          some other data may be contained in files that you can read into
-          Singular (see @ref{showNuminvs}, @ref{exportNuminvs}).
-NOTE:@texinfo
-@tex
-It is of course possible that $S=K$. At present, Normaliz cannot deal with the
-zero cone and will issue the (wrong) error message that the cone is not
-pointed. The function also gives an error message if the matrix $V$ has the
-wrong number of columns.
-@end tex
-@end texinfo
-SEE ALSO: torusInvariants, valRingIdeal
-EXAMPLE:  example valRing; shows an example
+@*The function returns the ideal given by the input matrix V if one of
+the options @code{supp}, @code{triang}, or @code{hvect} has been
+activated.
+However, in this case some numerical invariants are computed, and
+some other data may be contained in files that you can read into
+Singular.
+SEE ALSO: torusInvariants, diagInvariants, finiteDiagInvariants, intersectionValRingIdeals,showNuminvs,exportNuminvs
+EXAMPLE:  example intersectionValRings; shows an example
 "
 {
@@ -1402 +1578 @@
     if(nvars(basering)!=ncols(V))
     {
-        ERROR("valRing: wrong number of columns in matrix");
+        ERROR("intersectionValRings: wrong number of columns in matrix");
     }
 
@@ -1425 +1601 @@
 /*    if(!GenGen) // return V
     {
-        runNormaliz(V1,ncols(V),4);
+        runNormaliz(V1,4);
         return(V);
     }
 */
-    return(intmat2mons(runNormaliz(V1,ncols(V),4)));
+    return(intmat2mons(runNormaliz(V1,4)));
 }
 example
@@ -1435 +1611 @@
   ring R=0,(x,y,z,w),dp;
   intmat V0[2][4]=0,1,2,3, -1,1,2,1;
-  valRing(V0);
-}
-
-proc valRingIdeal(intmat V)
-"USAGE:   valRingIdeal(intmat V);
+  intersectionValRings(V0);
+}
+
+proc intersectionValRingIdeals(intmat V)
+"USAGE:   intersectionValRingIdeals(intmat V);
 RETURN:   The function returns two ideals, both to be considered as lists of
           monomials which generate an algebra over the coefficient field. The
@@ -1450 +1626 @@
           some other data may be contained in files that you can read into
           Singular (see @ref{showNuminvs}, @ref{exportNuminvs}).
-BACKGROUND: @texinfo
+BACKGROUND:
 @tex
 A discrete monomial valuation $v$ on $R = K[X_1 ,\ldots,X_n]$ is determined by
@@ -1463 +1639 @@
 The numbers $w_i$ form the $(n+1)$th column of the input matrix.
 @end tex
-@end texinfo
-NOTE:@texinfo
-@tex
-It is of course possible that $S=K$. At present, Normaliz cannot deal with the
-zero cone and will issue the (wrong) error message that the cone is not
-pointed. The function also gives an error message if the matrix $T$ has the
-wrong number of columns.
-@end tex
-@end texinfo
-SEE ALSO: torusInvariants, valRing
-EXAMPLE:  example valRingIdeal; shows an example
+NOTE:   The function also gives an error message if the matrix V has the
+        wrong number of columns.
+SEE ALSO: torusInvariants, diagInvariants, finiteDiagInvariants, intersectionValRings
+EXAMPLE:  example intersectionValRingIdeals; shows an example
 "
 {
     if(nvars(basering)!=ncols(V)-1)
     {
-        ERROR("valRingIdeal: wrong number of columns in matrix");
+        ERROR("intersectionValRingIdeals: wrong number of columns in matrix");
     }
 
@@ -1502 +1671 @@
     string dummy=collectNmzOptions();  // only to set GenGen
 
-/*    if(!GenGen) // return V
-    {
-        runNormaliz(V1,ncols(V),4);
-        return(V);
-    }
-*/
-    intmat nmz_data=runNormaliz(V1,ncols(V),4);
+    intmat nmz_data=runNormaliz(V1,4);
 
     ideal I1=intmat2monsSel(nmz_data,0);
@@ -1518 +1681 @@
  ring R=0,(x,y,z,w),dp;
  intmat V[2][5]=0,1,2,3,4, -1,1,2,1,3;
- valRingIdeal(V);
-}
-//---------------------------------------------------------------------------
-// a library file is a bad place for examples (it has to be parsed
-// every time and one has to be carefull to make it ALL to a comment),
-// but some authors prefer it that way.....
-// and, the information is in the same file.
-//
-/*
-// This example is taken from Bruns and Gubeladze, Polytopal linear groups,
-// J. Algebra 218 (1999), 715--737.
-// The generators of the monoid are the facet-vertex incidence vectors of
-// the minimal triangulation of the real projective plane.
-// It is our goal to show that the normalization of
-// the corresponding algebra and the algebra itself differ
-// only by a vector space of dimension 1.
-//
-// Computing times extremely small (< 1 sec) on every system.
-//
-LIB "normaliz.lib";
-ring A=2,(a(1..6)),dp;
-intmat M[10][6]=
-1, 1, 1, 0, 0, 0,
-1, 1, 0, 1, 0, 0,
-1, 0, 1, 0, 1, 0,
-1, 0, 0, 1, 0, 1,
-1, 0, 0, 0, 1, 1,
-0, 1, 1, 0, 0, 1,
-0, 1, 0, 1, 1, 0,
-0, 1, 0, 0, 1, 1,
-0, 0, 1, 1, 1, 0,
-0, 0, 1, 1, 0, 1;
-ideal R=intmat2mons(M);
-print(R);
-setNmzOption("hilb",1);
-ideal S=normalToricRing(R); // S is the normalization
-print(S);
-showNuminvs();
-ideal Z=0;
-ring P=2,(x(1..10)),dp;
-ring Q=2,(y(1..10),z),dp;
-setring A;
-map f=P,R;
-map g=Q,S;
-setring P;
-ideal I=preimage(A,f,Z);
-hilb(std(I));
-ring T=0,t,dp;
-poly H1=1+4t+11t2+4t3+t4; // numerator polynomial of Hilbert series of S
-poly H2=1+4t+10t2+10t3-14t4+20t5-15t6+6t7-1t^8; // the same for R itself
-factorize(H1-H2); // this shows the claim about S/R
-setring Q; // now we verify it additionally by the defining ideal of S
-ideal J=preimage(A,g,Z);
-print(J);
-// Computing times extremely small (< 1 sec) on every system.
-
-===========================================================================
-
-// The following example is the first one not covered by the classification
-// of Ohsugi and Hibi of normality of monoids derived from contingency
-// tables. (See H.Ohsugi and T. Hibi, Toric ideals arising from
-// contingency tables. In: Commutative Algebra and Combinatorics.
-// In: Ramanujan Mathematical Society Lecture Note Series 4
-// (2006), 87--111.)
-// The gaps in the classification have meanwhile been closed computationall=
-y.
-// See Bruns, R. Hemmecke, B. Ichim, M. K=F6ppe, and C.
-// S=F6ger, Challenging computations of Hilbert bases of cones
-// associated with algebraic statistics. Experimental Math., to appear.
-//
-// For the currently public version of Normaliz this is a very large exampl=
-e
-// On a SUN Fire X4450 it takes about an hour in version 2.2 and needs
-about 20 GB
-// of RAM. In the next version (already realized experimentally, expected u=
-pload
-// July 2010) it will be a matter of seconds due to algorithmic improvement=
-s for
-// this type of example and parallelization. Also memory usage will be redu=
-ced
-// significantly.
-//
-LIB "normaliz.lib";
-intmat M[48][40]=
-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
-0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
-0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,
-0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0,
-0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
-0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
-0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,
-0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0,
-0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
-0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
-0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,
-0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0,
-0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
-0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,
-0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
-0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,
-0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0,
-0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,
-0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0,
-0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,
-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0,
-0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
-0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,
-0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
-0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0,
-0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
-0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
-0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
-0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0,
-0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
-0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,
-0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
-0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0,
-0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
-0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
-0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
-0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0,
-0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,
-0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,
-0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,
-0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0,
-0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,
-0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
-0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,
-0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0,
-0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0,
-0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,
-0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0,
-0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0,
-0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0,
-0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1,
-0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0,
-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0,
-0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0,
-0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0,
-0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0,
-0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,
-0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,
-0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,
-0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,
-0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0,
-0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0,
-0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0,
-0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0,
-0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
-0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
-0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
-0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,
-0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1;
-setNmzOption("control",1);
-intmat N=normaliz(M,1);
-showNuminvs(); // shows that the monoid generated by the rows of M is norma=
-l
-
-
-*/
-
+ intersectionValRingIdeals(V);
+}