passagemath-singular 10.6.31rc3__cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl

sage_wheels/share/singular/LIB/rwalk.lib

@@ -0,0 +1,336 @@
+/////////////////////////////////////////////////
+version="version rwalk.lib 4.1.2.0 Feb_2019 "; // $Id: 29e67168ee8de0af42332736422ca3a47fd25327 $
+category="Commutative Algebra";
+
+info="
+LIBRARY: rwalk.lib   Groebner Walk Conversion Algorithms
+AUTHOR: Stephan Oberfranz
+
+PROCEDURES:
+prwalk(ideal,int,int[,intvec,intvec]);   standard basis of ideal via Random Perturbation Walk algorithm
+rwalk(ideal,int[,intvec,intvec]);       standard basis of ideal via Random Walk algorithm
+frandwalk(ideal,int[,intvec,intvec]);      standard basis of ideal via Random Fractal Walk algorithm
+
+KEYWORDS: walk, groebner;Groebnerwalk
+SEE ALSO: grwalk_lib; swalk_lib
+";
+
+/***********************************
+ * Argument string for Random Walk *
+ ***********************************/
+static proc OrderStringalp_NP(string Wpal,list #)
+{
+  int n= nvars(basering);
+  string order_str = "dp";
+
+  int nP = 1;
+
+  //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);
+}
+
+/****************
+ * Random Walk  *
+ ****************/
+proc rwalk(ideal Go, int radius, int pert_deg, list #)
+"SYNTAX: rwalk(ideal i, int radius);
+         if size(#)>0 then rwalk(ideal i, int radius, intvec v, intvec w);
+         intermediate Groebner bases are not reduced if reduction = 0
+TYPE:    ideal
+PURPOSE: compute the standard basis of the ideal, calculated via
+         the Random walk algorithm  from the ordering
+         \"(a(v),lp)\", \"dp\", \"Dp\" or \"M\"
+         to the ordering  \"(a(w),lp)\", \"(a(1,0,...,0),lp)\" or \"M\".
+SEE ALSO: std, stdfglm, groebner, gwalk, pwalk, fwalk, twalk, awalk1, awalk2
+KEYWORDS: Groebner walk
+EXAMPLE: example rwalk; shows an example"
+{
+//--------------------  Initialize parameters  ------------------------
+int n= nvars(basering);
+list OSCTW = OrderStringalp_NP("al",#);
+if(size(#)>1)
+  {
+  if(size(#[2]) == n*n)
+    {
+    OSCTW= OrderStringalp_NP("M", #);
+    }
+  }
+else
+  {
+  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;
+
+//--------------------  Initialize parameters  ------------------------
+int reduction=1;
+int printout=0;
+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);
+G = system("Mrwalk", G, curr_weight, target_weight, radius, pert_deg, 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 = y3+xyz+y2z+xz3, 3+xy+x2y+y2z;
+  int radius = 1;
+  int perturb_deg = 2;
+  rwalk(I,radius,perturb_deg);
+}
+
+/*****************************************
+ * Perturbation Walk with random element *
+ *****************************************/
+proc prwalk(ideal Go, int radius, int o_pert_deg, int t_pert_deg, list #)
+"SYNTAX: rwalk(ideal i, int radius);
+         if size(#)>0 then rwalk(ideal i, int radius, intvec v, intvec w);
+TYPE:    ideal
+PURPOSE: compute the standard basis of the ideal, calculated via
+         the Random Perturbation Walk algorithm  from the ordering
+         \"(a(v),lp)\", \"dp\", \"Dp\" or \"M\"
+         to the ordering  \"(a(w),lp)\", \"(a(1,0,...,0),lp)\" or \"M\".
+SEE ALSO: std, stdfglm, groebner, gwalk, pwalk, fwalk, twalk, awalk1, awalk2
+KEYWORDS: Groebner walk
+EXAMPLE: example prwalk; shows an example"
+{
+//--------------------  Initialize parameters  ------------------------
+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]; // target weight vector
+kill OSCTW;
+
+//--------------------  Initialize parameters  ------------------------
+int reduction=1;
+int printout=0;
+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);
+G = system("Mprwalk", G, curr_weight, target_weight, radius, o_pert_deg, t_pert_deg,
+           nP, 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 = y3+xyz+y2z+xz3, 3+xy+x2y+y2z;
+  int radius = 1;
+  int o_perturb_deg = 2;
+  int t_perturb_deg = 2;
+  prwalk(I,radius,o_perturb_deg,t_perturb_deg);
+}
+
+/************************************
+ * Fractal Walk with random element *
+ ************************************/
+proc frandwalk(ideal Go, int radius, list #)
+"SYNTAX: frwalk(ideal i, int radius);
+         frwalk(ideal i, int radius, 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 Random Fractal walk algorithm.
+SEE ALSO: std, stdfglm, groebner, gwalk, pwalk, twalk, awalk1, awalk2
+KEYWORDS: The fractal walk algorithm
+EXAMPLE: example frandwalk; 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]; /* current weight vector */
+   intvec target_weight =   OSCTW[4]; /* target weight vector */
+   kill OSCTW;
+   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("Mfrwalk", G, curr_weight, target_weight, radius, 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 = 0,(z,y,x), lp;
+    ideal I = y3+xyz+y2z+xz3, 3+xy+x2y+y2z;
+    int reduction = 0;
+    frandwalk(I,2);
+}