passagemath-singular 10.6.31rc3__cp314-cp314-musllinux_1_2_x86_64.whl

sage_wheels/share/singular/LIB/grwalk.lib

@@ -0,0 +1,507 @@
+///////////////////////////////////////////////////////////////
+version="version grwalk.lib 4.1.2.0 Feb_2019 "; // $Id: 9a55a7af0dba38e8c90979b6bd157a778dcc0a89 $
+category="Commutative Algebra";
+
+info="
+LIBRARY: grwalk.lib   Groebner Walk Conversion Algorithms
+AUTHOR: I Made Sulandra
+
+PROCEDURES:
+ fwalk(ideal[,intvec]);   standard basis of ideal via fractalwalk alg
+ twalk(ideal[,intvec]);   standard basis of ideal via Tran's alg
+ awalk1(ideal[,intvec]);   standard basis of ideal via the first alt. alg
+ awalk2(ideal[,intvec]);   standard basis of ideal via the second alt. alg
+ pwalk(ideal[,intvec]);   standard basis of ideal via perturbation walk alg
+ gwalk(ideal[,intvec]);   standard basis of ideal via groebnerwalk alg
+
+KEYWORDS: walk, groebner;Groebnerwalk
+ZSEE ALSO: rwalk_lib; swalk_lib
+";
+
+LIB "ring.lib";
+
+//////////////////////////////////////////////////////////////////////////////
+
+static proc OrderStringalp_NP(string Wpal,list #)
+{
+  int n= nvars(basering);
+  string order_str = "dp";
+
+  int nP = 1;// in pwalk, call LastGB to compute the wanted GB
+
+  //Default:
+  // if size(#)=0, the Groebnerwalk algorithm and its developments compute
+  // a Groebner basis from "dp" to "lp"
+
+  intvec curr_weight = system("Mivdp",n); //define (1,1,...,1)
+  intvec target_weight = system("Mivlp",n); //define (1,0,...,0)
+
+  // check if the target ring has a weighted lp ordering
+  list rl = ringlist(basering);
+  if (rl[3][1][1] == "a" and rl[3][2][1] == "lp") {
+    target_weight = rl[3][1][2];
+  }
+
+  if(size(#) != 0)
+  {
+    if(size(#) == 1)
+    {
+      if(typeof(#[1]) == "intvec") {
+        curr_weight = #[1];
+
+        if(Wpal == "al"){
+          order_str = "(a("+string(#[1])+"),lp("+string(n) + "),C)";
+        }
+        else {
+          order_str = "(Wp("+string(#[1])+"),C)";
+        }
+      }
+      else {
+        if(typeof(#[1]) == "int"){
+          nP = #[1];
+        }
+        else {
+          if(typeof(#[1]) == "string")
+          {
+            if(#[1] == "Dp") {
+              order_str = "Dp";
+             }
+             else {
+                order_str = "dp";
+             }
+          }
+          else {
+            print("// ** the input must be \"(ideal, intvec)\" or ");
+            print("// **                   \"(ideal, string)\" or ");
+            print("// **                   \"(ideal, string,intvec)\" or ");
+            print("// **                   \"(ideal, intvec,intvec)\".");
+            print("// ** a lex. GB will be computed from \"dp\" to \"lp\".");
+          }
+        }
+      }
+    }
+    else {
+      if(size(#) == 2) {
+        if(typeof(#[1]) == "intvec" and typeof(#[2]) == "int") {
+          curr_weight = #[1];
+          order_str = "(Wp("+string(#[1])+"),C)";
+          if(Wpal == "al") {
+            order_str = "(a("+string(#[1])+"),lp("+string(n) + "),C)";
+          }
+          if(Wpal == "M") {
+            order_str = "(M("+string(#[1])+"),C)";
+          }
+        }
+        else {
+          if(typeof(#[1]) == "intvec" and typeof(#[2]) == "intvec") {
+            curr_weight = #[1];
+            target_weight = #[2];
+            order_str = "(Wp("+string(#[1])+"),C)";
+            if(Wpal == "al") {
+              order_str = "(a("+string(#[1])+"),lp("+string(n) + "),C)";
+            }
+            if(Wpal == "M"){
+              order_str = "(M("+string(#[1])+"),C)";
+            }
+          }
+          else {
+            if(typeof(#[1]) == "string" and typeof(#[2]) == "intvec") {
+              target_weight = #[2];
+              if(#[1] == "Dp") {
+                order_str = "Dp";
+               }
+               else {
+                 order_str = "dp";
+               }
+            }
+            else {
+              print("// ** the input must be \"(ideal, intvec)\" or ");
+              print("// **                   \"(ideal, string)\" or ");
+              print("// **                   \"(ideal, string,intvec)\" or ");
+              print("// **                   \"(ideal, intvec,intvec)\".");
+              print("// ** a lex. GB will be computed from \"dp\" to \"lp\".");
+            }
+          }
+        }
+      }
+      else {
+        if(size(#) == 3) {
+          if(typeof(#[1]) == "intvec" and typeof(#[2]) == "intvec" and
+            typeof(#[3]) == "int") {
+            curr_weight = #[1];
+            target_weight = #[2];
+            nP = #[3];
+            order_str = "(Wp("+string(#[1])+"),C)";
+            if(Wpal == "al") {
+              order_str = "(a("+string(#[1])+"),lp("+string(n) + "),C)";
+            }
+            if(Wpal == "M") {
+              order_str = "(M("+string(#[1])+"),C)";
+            }
+          }
+          else {
+            if(typeof(#[1]) == "string" and typeof(#[2]) == "intvec" and
+            typeof(#[3]) == "int") {
+              target_weight = #[2];
+              nP = #[3];
+              if(#[1] == "Dp") {
+                order_str = "Dp";
+              }
+              else {
+                order_str = "dp";
+              }
+            }
+            else {
+              print("// ** the input must be \"(ideal,intvec,intvec,int)\"");
+              print("// ** and a lex. GB will be computed from \"dp\" to \"lp\"");
+            }
+          }
+        }
+        else {
+          print("// ** The given input is wrong");
+          print("// ** and a lex. GB will be computed from \"dp\" to \"lp\"");
+        }
+      }
+    }
+  }
+
+  list result;
+  result[1] = nP;
+  result[2] = order_str;
+  result[3] = curr_weight;
+  result[4] = target_weight;
+  return(result);
+}
+
+
+
+
+/* 16 Mai 2003 */
+proc awalk1(ideal G, list #)
+"SYNTAX: awalk1(ideal i);
+         awalk1(ideal i, int n);
+         awalk1(ideal i, int n, intvec v, intvec w);
+         awalk1(ideal i, intvec v, intvec w);
+TYPE:    ideal
+PURPOSE: compute the standard basis of the ideal, calculated via
+          the first alternative algorithm from an ordering
+         \"(a(v),lp)\", \"dp\" or \"Dp\" to the ordering
+         \"(a(w),lp)\" or \"(a(1,0,...,0),lp)\"
+         with a perturbation degree n for the weight vector w.
+SEE ALSO: std, stdfglm, groebner, gwalk, pwalk, fwalk, twalk, awalk2
+KEYWORDS: the first alternative algorithm
+EXAMPLE: example awalk1; shows an example"
+{
+  if (size(#) == 0)
+  {
+    return (awalk1_tmp(G, nvars(basering)-1));
+  }
+  else {
+    if(typeof(#[1]) == "int")
+    {
+      return (awalk1_tmp(G, #[1]));
+    }
+    else  {
+      return (awalk1_tmp(G, nvars(basering)-1, #));
+    }
+  }
+}
+example
+{
+    "EXAMPLE:"; echo = 2;
+    ring r = 32003,(z,y,x), lp;
+    ideal I = y3+xyz+y2z+xz3, 3+xy+x2y+y2z;
+    awalk1(I,3);
+}
+
+proc gwalk(ideal Go, list #)
+"SYNTAX: gwalk(ideal i);
+         gwalk(ideal i, intvec v, intvec w);
+TYPE:    ideal
+PURPOSE: compute the standard basis of the ideal, calculated via
+         the improved Groebner walk algorithm  from the ordering
+         \"(a(v),lp)\", \"dp\" or \"Dp\"
+         to the ordering  \"(a(w),lp)\" or \"(a(1,0,...,0),lp)\".
+SEE ALSO: std, stdfglm, groebner, pwalk, fwalk, twalk, awalk1, awalk2
+KEYWORDS: Groebner walk
+EXAMPLE: example gwalk; shows an example"
+{
+
+   /* we use ring with ordering (a(...),lp,C) */
+   list OSCTW    = OrderStringalp_NP("al", #);
+
+   string ord_str =   OSCTW[2];
+   intvec curr_weight   =   OSCTW[3]; /* original weight vector */
+   intvec target_weight =   OSCTW[4]; /* target weight vector */
+   kill OSCTW;
+   option(redSB);
+   def xR = basering;
+
+   ring ostR = create_ring(ring_list(xR)[1],"("+varstr(xR)+")",ord_str,"no_minpoly");
+   def old_ring = basering;
+
+   //print("//** help ring = " + string(basering));
+   ideal G = fetch(xR, Go);
+   int reduction=1;
+   int printout=0;
+   G = system("Mwalk", G, curr_weight, target_weight,basering,reduction,printout);
+
+   setring xR;
+   //kill Go;
+
+   keepring basering;
+   ideal result = fetch(old_ring, G);
+   attrib(result,"isSB",1);
+   return (result);
+}
+example
+{
+  "EXAMPLE:"; echo = 2;
+  //** compute a Groebner basis of I w.r.t. lp.
+  ring r = 32003,(z,y,x), lp;
+  ideal I = zy2+yx2+yx+3,
+            z3x+y3+zyx-yx2-yx-3,
+            z2yx3-y5+z2yx2+y3x2+y2x3+y3x+y2x2+3z2x+3y2+3yx,
+            zyx5+y6-y4x2-y3x3+2zyx4-y4x-y3x2+zyx3-3z2yx+3zx3-3y3-3y2x+3zx2,
+            yx7-y7+y5x2+y4x3+3yx6+y5x+y4x2+3yx5-6zyx3+yx4+3x5+3y4+3y3x-6zyx2+6x4+3x3-9zx;
+  gwalk(I);
+}
+
+
+proc awalk1_tmp(ideal Go, int n2, list #)
+//proc awalk1(ideal Go, int n1, int n2, list #)
+{
+   int nV = nvars(basering);
+   int n1 = 1;
+
+   //assume(n1 >= 1 && n1 <= nV && n2 >= 1 && n2 <= nV);
+   if(n1 < 1 || n1 > nV || n2 < 1 || n2 > nV)
+   {
+     print("//Error: The perturbed degree is wrong!!");
+     print("//       It must be between 1 and " + string(nV));
+     return();
+   }
+
+   /* we use ring with ordering (a(...),lp,C) */
+   list OSCTW = OrderStringalp_NP("al", #);
+
+   string ord_str = OSCTW[2];
+   intvec curr_weight = OSCTW[3]; /* original weight vector */
+   intvec target_weight = OSCTW[4]; /* terget weight vector */
+   kill OSCTW;
+   option(redSB);
+
+   def xR = basering;
+
+   ring ostR = create_ring(ring_list(xR)[1],"("+varstr(xR)+")",ord_str,"no_minpoly");
+   def old_ring = basering;
+   //print("//** help ring = " + string(basering));
+
+   ideal G = fetch(xR, Go);
+   G = system("MAltwalk1", G, n1, n2, curr_weight, target_weight);
+
+   setring xR;
+   //kill Go;
+
+   keepring basering;
+   ideal result = fetch(old_ring, G);
+   attrib(result,"isSB",1);
+   return (result);
+}
+
+proc fwalk(ideal Go, list #)
+"SYNTAX: fwalk(ideal i);
+         fwalk(ideal i, intvec v, intvec w);
+TYPE:    ideal
+PURPOSE: compute the standard basis of the ideal w.r.t. the
+        lexicographical ordering or a weighted-lex ordering,
+        calculated via  the fractal walk algorithm.
+SEE ALSO: std, stdfglm, groebner, gwalk, pwalk, twalk, awalk1, awalk2
+KEYWORDS: The fractal walk algorithm
+EXAMPLE: example fwalk; shows an example"
+{
+   /* we use ring with ordering (a(...),lp,C) */
+   list OSCTW    = OrderStringalp_NP("al", #);
+
+   string ord_str =   OSCTW[2];
+   intvec curr_weight   =   OSCTW[3]; /* original weight vector */
+   intvec target_weight =   OSCTW[4]; /* target weight vector */
+   kill OSCTW;
+   option(redSB);
+   def xR = basering;
+   ring ostR = create_ring(ring_list(xR)[1],"("+varstr(xR)+")",ord_str,"no_minpoly");
+   def old_ring = basering;
+   //print("//** help ring = " + string(basering));
+
+   ideal G = fetch(xR, Go);
+   int reduction=1;
+   int printout=0;
+   G = system("Mfwalk", G, curr_weight, target_weight, reduction, printout);
+
+   setring xR;
+   //kill Go;
+
+   keepring basering;
+   ideal result = fetch(old_ring, G);
+   attrib(result,"isSB",1);
+   return (result);
+}
+example
+{
+    "EXAMPLE:"; echo = 2;
+    ring r = 32003,(z,y,x), lp;
+    ideal I = y3+xyz+y2z+xz3, 3+xy+x2y+y2z;
+    fwalk(I);
+}
+
+
+
+proc awalk2(ideal Go, list #)
+"SYNTAX: awalk2(ideal i);
+         awalk2(ideal i, intvec v, intvec w);
+TYPE:    ideal
+PURPOSE: compute the standard basis of the ideal, calculated via
+         the second alternative algorithm from the ordering
+         \"(a(v),lp)\", \"dp\" or \"Dp\"
+         to the ordering  \"(a(w),lp)\" or \"(a(1,0,...,0),lp)\".
+SEE ALSO: std, stdfglm, groebner, gwalk, pwalk, fwalk, twalk, awalk1
+KEYWORDS: Groebner walk
+EXAMPLE: example awalk2; shows an example"
+{
+   /* we use ring with ordering (a(...),lp,C) */
+   list OSCTW    = OrderStringalp_NP("al", #);//"dp"
+
+   string ord_str =   OSCTW[2];
+   intvec curr_weight   =   OSCTW[3]; /* original weight vector */
+   intvec target_weight =   OSCTW[4]; /* terget weight vector */
+   kill OSCTW;
+   option(redSB);   def xR = basering;
+
+   ring ostR = create_ring(ring_list(xR)[1],"("+varstr(xR)+")",ord_str,"no_minpoly");
+   def old_ring = basering;
+
+   //print("//** help ring = " + string(basering));
+   ideal G = fetch(xR, Go);
+   G = system("MAltwalk2", G, curr_weight, target_weight);
+
+   setring xR;
+   //kill Go;
+
+   keepring basering;
+   ideal result = fetch(old_ring, G);
+   attrib(result,"isSB",1);
+   return (result);
+}
+example
+{
+    "EXAMPLE:"; echo = 2;
+    ring r = 32003,(z,y,x), lp;
+    ideal I = y3+xyz+y2z+xz3, 3+xy+x2y+y2z;
+    awalk2(I);
+}
+
+proc pwalk(ideal Go, int n1, int n2, list #)
+"SYNTAX: pwalk(int d, ideal i, int n1, int n2);
+         pwalk(int d, ideal i, int n1, int n2, intvec v, intvec w);
+TYPE:    ideal
+PURPOSE: compute the standard basis of the ideal, calculated via
+         the perturbation walk algorithm  from the ordering
+         \"(a(v),lp)\", \"dp\" or \"Dp\"
+         to the ordering  \"(a(w),lp)\" or \"(a(1,0,...,0),lp)\"
+         with a perturbation degree n, m for v and w, resp.
+SEE ALSO: std, stdfglm, groebner, gwalk, fwalk, twalk, awalk1, awalk2
+KEYWORDS: Perturbation walk
+EXAMPLE: example pwalk; shows an example"
+{
+  int nV = nvars(basering);
+  //assume(n1 >= 1 && n1 <= nV && n2 >= 1 && n2 <= nV);
+  if(n1 < 1 || n1 > nV || n2 < 1 || n2 > nV)
+  {
+    print("//Error: The perturbed degree is wrong!!");
+    print("//       It must be between 1 and " + string(nV));
+    return();
+  }
+
+  /* we use ring with ordering (a(...),lp,C) */
+  list OSCTW    = OrderStringalp_NP("al", #);
+
+  int nP = OSCTW[1];
+
+  string ord_str =   OSCTW[2];
+  intvec curr_weight   =   OSCTW[3]; /* original weight vector */
+  intvec target_weight =   OSCTW[4]; /* terget weight vector */
+  kill OSCTW;
+  option(redSB);
+
+  def xR = basering;
+
+  ring ostR = create_ring(ring_list(xR)[1],"("+varstr(xR)+")",ord_str,"no_minpoly");
+  def old_ring = basering;
+
+  ideal G = fetch(xR, Go);
+  int reduction=1;
+  int printout=0;
+  G = system("Mpwalk",G,n1,n2,curr_weight,target_weight,nP,reduction,printout);
+
+  setring xR;
+  //kill Go; //unused
+
+  keepring basering;
+  ideal result = fetch(old_ring, G);
+  attrib(result,"isSB",1);
+  return (result);
+}
+example
+{
+    "EXAMPLE:"; echo = 2;
+    ring r = 32003,(z,y,x), lp;
+    ideal I = y3+xyz+y2z+xz3, 3+xy+x2y+y2z;
+    pwalk(I,2,2);
+}
+
+
+proc twalk(ideal Go, list #)
+"SYNTAX: twalk(ideal i);
+         twalk(ideal i, intvec v, intvec w);
+TYPE:    ideal
+PURPOSE: compute the standard basis of the ideal w.r.t.
+         the ordering  \"(a(w),lp)\" or \"(a(1,0,...,0),lp)\",
+         calculated via the Tran algorithm.
+SEE ALSO: std, stdfglm, groebner, gwalk, pwalk, fwalk, awalk1, awalk2
+KEYWORDS: The Tran algorithm
+EXAMPLE: example twalk; shows an example"
+{
+  list L = OrderStringalp_NP("al", #);
+  int nP = L[1];
+
+  /* we use ring with ordering (a(...),lp,C) */
+  string ord_str =   L[2];
+  intvec curr_weight   = L[3];
+  intvec target_weight =  L[4];
+  kill L;
+
+  option(redSB);
+  def xR = basering;
+
+  ring ostR = create_ring(ring_list(xR)[1],"("+varstr(xR)+")",ord_str,"no_minpoly");
+  def old_ring = basering;
+
+  //print("//** help ring = " + string(basering));
+  ideal G = fetch(xR, Go);
+  G = system("TranMImprovwalk", G, curr_weight, target_weight, nP);
+
+  setring xR;
+   //kill Go;
+
+  keepring basering;
+  ideal result = fetch(old_ring, G);
+  attrib(result,"isSB",1);
+  return (result);
+}
+example
+{
+    "EXAMPLE:"; echo = 2;
+    ring r = 32003,(z,y,x), lp;
+    ideal I = y3+xyz+y2z+xz3, 3+xy+x2y+y2z;
+    twalk(I);
+}

sage_wheels/share/singular/LIB/hdepth.lib

@@ -0,0 +1,194 @@
+//////////////////////////////////////////////////////////////////////////////
+version="version hdepth.lib 4.4.0.0 Nov_2023 "; // $Id: bdacc3b059d53e9e7c075bda329b469348bc3ab2 $
+category="Commutative Algebra";
+info="
+LIBRARY: hdepth.lib     Procedures for computing hdepth_1
+AUTHORS: Popescu, A.,     popescu@mathematik.uni-kl.de
+
+SEE ALSO: 'An algorithm to compute the Hilbert depth', Adrian Popescu, arxiv/AC/1307.6084
+
+KEYWORDS: hdepth; depth, Hilbert; Hilbert depth
+
+
+PROCEDURES:
+  hdepth(M [,debug]);        hdepth_1 computation of a module M (wrt Z-grading)
+  hdepth_p(g, d, debug) the minimum number t <= d s.t. 1/g^t is positive
+";
+
+///////////////////////////////////////////////////////////////////////////////////
+static proc myinverse(poly p, int bound)
+"USAGE:   myinverse(p,bound), p polynomial in one variable with p(0) nonzero, bound a nonnegative integer
+RETURN:  poly, the inverse of the poly p in the power series ring till order bound
+"
+{
+    if(bound<=1)
+    {
+      ERROR("My inverse : negative bound in the inverse");
+    }
+    if(p == 0)
+    {
+      ERROR("My inverse : p is 0");
+    }
+    poly original;
+    original = p;
+    if(leadcoef(p) == 0)
+    {
+      ERROR("My inverse : the power series is not a unit.");
+    }
+    poly q = 1/p[1];
+    poly res = q;
+    p = q * (p[1] - jet(p,bound));
+    poly s = p;
+    while(p != 0)
+    {
+      res = res + q * p;
+      p = jet(p*s,bound);
+    }
+    //TEST
+    if(jet(original*res,bound) != poly(1))
+    {
+      ERROR("Myinverse does not work properly.");
+    }
+    return(res);
+}
+
+///////////////////////////////////////////////////////////////////////////////////
+static proc hilbconstruct(bigintvec v)
+"USAGE:   hilbconstruct(v), v is the result of hilb(M,2)
+RETURN:  poly, the Hilbert Series of M
+AASUME: the ring when called is R = 0,t,ds;
+"
+{
+  poly f;
+  int i;
+  for(i=0;i<size(v)-1;i++)
+  {
+    f=f+v[i+1]*t^i;
+  }
+  return(f);
+}
+///////////////////////////////////////////////////////////////////////////////////
+static proc positiv(poly f)
+"USAGE:   positiv(f), f is a polynomial
+RETURN:  int, 1 if all the coefficients of f are positive, 0 else
+"
+{
+  int pos=1;
+  while( (f!=0) && (pos==1) )
+  {
+    if(leadcoef(f)<0)
+    {
+      pos=0;
+    }
+    f=f-lead(f);
+  }
+  return(pos);
+}
+///////////////////////////////////////////////////////////////////////////////////
+static proc sumcoef(poly f)
+"USAGE:   sumcoef(f), f is a polynomial
+RETURN:  number, the sum of the coefficients
+"
+{
+  number c;
+  while(f!=0)
+  {
+    c = c+leadcoef(f);
+    f=f-lead(f);
+  }
+  return(int(c));
+}
+///////////////////////////////////////////////////////////////////////////////////
+proc hdepth_p(poly g, int d, int debug)
+"USAGE:   hdepth_p(g,d,debug), g is the Hilbert Series of a module M and d is the dimension of M, for debug = 0 the steps will be printed.
+RETURN:  int, the minimum number t <= d s.t. 1/g^t is positive
+"
+{
+  int dd = d;
+  if(debug == 0)
+  {"G(t)=",g;}
+  if(positiv(g)==1)
+  {
+    if(debug == 0)
+    {return("hdepth =",dd);}
+    else
+    {return(dd);}
+  }
+  poly f=g;
+  number ag;
+  int c1;
+  int bound;
+  bound = deg(g);
+  while(dd >= 0)
+  {
+    dd = dd-1;
+    f = jet( g*myinverse( (1-t)^(d-dd),2*bound ) , bound );
+    if(positiv(f) == 1)
+    {
+      if(debug == 0)
+      {
+        "G(t)/(1-t)^",d-dd,"=",f,"+...";
+        return("hdepth =",dd);
+      }
+      else
+      {return(d);}
+    }
+    c1=sumcoef(f);
+    if(c1<0)
+    {
+      while(c1<0)
+      {
+        bound=bound+1;
+        f=jet( g*myinverse( (1-t)^(d-dd),2*bound ) , bound );
+        c1=sumcoef(f);
+      }
+    }
+    if(debug == 0)
+    {"G(t)/(1-t)^",d-dd,"=",f,"+...";}
+  }
+  ERROR("g was not a Hilbert Series since the coefficient sum is not > 0");
+}
+example
+{
+  "EXAMPLE:";echo=2;
+  ring R = 0,t,ds;
+  poly f = 2-3t-2t2+2t3+4t4;
+  hdepth_p(f,5,0);
+  hdepth_p(f,5,1);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+proc hdepth(module M, list #)
+"USAGE:   hdepth(M [,debug]);   M is a module, if one want to print the steps debug = 0
+RETURN:  int
+PURPOSE: compute the hdepth_1 of a module M
+EXAMPLE: example hdepth; shows examples
+"
+{
+  int debug;
+  if(size(#)>0)
+  {
+    if(typeof(#[1])=="int")
+    {debug = #[1];}
+  }
+  else
+  {debug = 1;}
+  M = std(M);
+  int d=nvars(basering)-dim(M);
+  bigintvec v=hilb(M,2);
+  ring R = 0,t,ds;
+  poly hp=hilbconstruct(v);
+  if(debug == 0)
+  {"dim =",d;}
+  return(hdepth_p(hp,d,debug));
+}
+example
+{
+  "EXAMPLE:";echo=2;
+  ring R = 0,(x(1..10)),dp;
+  ideal i=maxideal(1);
+  module M=i;
+  hdepth(M);
+  hdepth(M,0);
+  hdepth(M,1);
+}