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

sage_wheels/share/singular/LIB/methods.lib

@@ -0,0 +1,212 @@
+///////////////////////////////////////////////////////////////////////////////
+version="version methods.lib 4.3.1.3 Feb_2023 "; //$Id: 7a36197a385ecb3774d2bfa2365fbfbda5183461 $
+category="Miscellaneous";
+info="
+LIBRARY:  methods.lib    installing methods in Singular
+
+AUTHORS:  J. Boehm, boehm @ mathematik.uni-kl.de
+
+OVERVIEW:
+
+Methods select the function to execute by the types of the input tuple.
+The central function is installMethod, which takes a hashtable associating a tuple of
+input types to function names and creates a corresponding procedure.
+
+HashTables are lists with arbitrary index sets. They can be created by the
+command hashTable. Their size can be determined by the command size. Values
+can be extracted by selectKey or the * operator. HashTables can also be added
+using addHashTables or the + operator.
+
+Methods can be added with the + operator.
+
+TYPES:
+Method                the class of all methods
+HashTable             the class of all hash tables
+
+KEYWORDS:
+methods, hashtables
+
+
+PROCEDURES:
+
+installMethod                  install a method
+method                         make a method
+hashTable                      make a HashTable
+selectKey                      select a key in a HashTable, can also be used by *
+addHashTables                  add two HashTables, can also be used by +
+";
+
+static proc mod_init()
+{
+  newstruct("HashTable","list keys, list values");
+  system("install","HashTable","print",printHashTable,1);
+  system("install","HashTable","size",sizeHashTable,1);
+  system("install","HashTable","*",selectKey,2);
+  system("install","HashTable","+",addHashTables,2);
+
+  newstruct("Method","HashTable functionClosures");
+
+  system("install","Method","print",printMethod,1);
+  system("install","Method","+",addMethods,2);
+}
+
+
+proc hashTable(list k, list v)
+"USAGE: hashTable(k, v); k,v,lists
+RETURN: makes a HashTable with keys k and values v
+EXAMPLE: example hashTable, shows an example
+"
+{
+  HashTable H;
+  H.keys = k;
+  H.values = v;
+  return(H);
+}
+example
+{ "EXAMPLE:"; echo=2;
+  HashTable H = hashTable(list("a","b","c"),list("aa","bb","cc"));
+  H;
+}
+
+
+proc printHashTable(HashTable H)
+{
+  for (int j=1; j<=size(H); j++)
+  {
+    print(string((H.keys)[j])+" => "+string((H.values)[j]));
+  }
+}
+
+proc sizeHashTable(HashTable H)
+{
+  return(size(H.keys));
+}
+
+
+proc selectKey(HashTable H, def k)
+"USAGE: selectKey(H, k); H HashTable, k key
+RETURN: returns the k-th value of H
+EXAMPLE: example selectKey, shows an example
+"
+{
+  for (int j=1; j<=size(H); j++)
+  {
+    if ((H.keys)[j]==k){return((H.values)[j]);}
+  }
+  ERROR("key not found");
+}
+example
+{ "EXAMPLE:"; echo=2;
+  HashTable H = hashTable(list("a","b","c"),list("aa","bb","cc"));
+  selectKey(H,"b");
+  selectKey(H,"d");
+  H*"b";
+}
+
+
+proc addHashTables(HashTable H, HashTable W)
+ "USAGE: addHashTables(H, L); H HashTable, L HashTable
+ RETURN: joins two hash tables with disjoint key sets
+ THEORY: At the moment, the function does not check whether the key sets are disjoint.
+ EXAMPLE: example addHashTables, shows an example
+ "
+{
+  HashTable D;
+  D.keys = (H.keys)+(W.keys);
+  D.values = (H.values)+(W.values);
+  return(D);
+}
+example
+{ "EXAMPLE:"; echo=2;
+  HashTable H = hashTable(list("a","b","c"),list("aa","bb","cc"));
+  HashTable W = hashTable(list("d","e","f"),list("aa","bb","cc"));
+  addHashTables(H,W);
+  H+W;
+}
+
+proc method(HashTable #)
+{
+  Method M;
+  //typeof(#);
+  //if (typeof(#)=="HashTable"){
+    M.functionClosures = #;
+  //} else
+  //{
+   // HashTable H;
+   // H.keys=list(#[1]);
+    //H.values=list(#[2]);
+    //M.functionClosures = H;
+  //}
+  return(M);
+}
+
+proc printMethod(Method f)
+{
+  print(f.functionClosures);
+}
+
+proc addMethods(Method f, Method g)
+{
+  Method M;
+  HashTable H = (f.functionClosures)+(g.functionClosures);
+  M.functionClosures = H;
+  return(M);
+}
+
+proc installMethod(Method M,string fname)
+"USAGE: installMethod(M, st); M Method, st string
+RETURN: installs a method calling procedures according to M
+EXAMPLE: example installMethod, shows an example
+"
+{
+  HashTable H = M.functionClosures;
+  //string fname = nameof(M);
+  //fname=fname[1..size(fname)-1];
+  string s = "";
+  string ff;
+  list v = H.values;
+  list k = H.keys;
+  string ki;
+  int i,j,l;
+  for (i=1; i<=size(H); i++)
+  {
+    ff = v[i];
+    ki="";
+    for (j=1; j<size(k[i]); j++)
+    {
+      ki=ki+"\""+k[i][j]+"\",";
+    }
+    ki=ki+"\""+k[i][size(k[i])]+"\"";
+    s=s+"branchTo("+ki+","+ff+");";
+ };
+  s=s+"ERROR(\"No method found\");";
+  //s;
+  intvec o=option(get);
+  option(noredefine);
+  proc `fname`=s;
+  exportto(Top,`fname`);
+  option(set,o);
+}
+example
+{ "EXAMPLE:"; echo=2;
+  proc square(int i){return(i^2);}; export(square);
+  HashTable H1 = hashTable(list(list("int")),list("square"));
+  Method m1 = method(H1);
+  installMethod(m1,"tst");
+  tst(2);
+  proc kbase2(ideal I,int n){return(kbase(I,n));};export(kbase2);
+  HashTable H2 = hashTable(list(list("ideal","int")),list("kbase2"));
+  Method m2=method(H2);
+  Method m=m1+m2;
+  installMethod(m,"tst");
+  ring R=0,(x,y),dp;
+  ideal I = x^3,y^7;
+  I=std(I);
+  tst(I,2);
+  HashTable F = hashTable(list(list("int"),list("ideal","int")),list("square","kbase2"));
+  Method m3 = method(F);
+  installMethod(m3,"tst");
+  tst(I,2);
+  tst(3);
+}
+

sage_wheels/share/singular/LIB/moddiq.lib

@@ -0,0 +1,322 @@
+///////////////////////////////////////////////////////////////////////////////
+version="version moddiq.lib 4.3.2.2 Jun_2023 "; // $Id: 1a9cf95b4aa16fae3f71be46f8cf9290b2a90199 $
+category="Commutative Algebra";
+info="
+LIBRARY:  moddiq.lib       Double ideal quotient using modular methods
+
+AUTHORS:  Y. Ishihara     yishihara@rikkyo.ac.jp
+
+OVERVIEW:
+  A library for computing ideal quotient and saturation in the polynomial ring
+  over the rational numbers using modular methods.
+
+REFERENCES:
+  M. Noro, K. Yokoyama: Usage of Modular Techniques for Efficient Computation of Ideal Operations.
+  Math.Comput.Sci. 12: 1, 1-32. (2017).
+
+PROCEDURES:
+  modQuotient(I,J); standard basis of (I:J) using modular methods
+  modSat(I,J); standard basis of (I:J^\infty) using modular methods
+";
+//UPCOMING PROCEDURES:
+//  moddiq(I,J); standard basis of (I:(I:J)) using modular methods
+//  modAssCheck(I,P); check if P is associated of I or not using modular methods
+//  IntermediatePrimaryDecomposition(I); compute intermediate primary decomposition of I
+//                                       by using modular method
+
+LIB "polylib.lib";
+LIB "elim.lib";
+LIB "modular.lib";
+LIB "modstd.lib";
+
+proc modQuotient(def I, def J)
+"USAGE:   modQuotient(I,J); I,J ideal
+RETURN:   a standard basis of (I:J)
+NOTE:     The procedure computes a standard basis of (I:J) (over the rational
+          numbers) by using modular methods.
+SEE ALSO: modular; quotient
+EXAMPLE:  example modQuotient; shows an example"
+{
+    if(system("--cpus")<1) { return(quotient(I,J));}
+    I = modStd(I);
+    def IJ=modular("quotient",list(I,J),primeTest_quotient,
+      Modstd::deleteUnluckyPrimes_std,pTest_quotient,finalTest_quotient);
+    return(IJ);
+}
+example
+{
+    "EXAMPLE:";
+    echo=2;
+    ring r=0,x(1..6),dp;
+    ideal i=cyclic(6);
+    ideal j=-15*var(5)+16*var(6)^3-60*var(6)^2+225*var(6)-4,2*var(5)^2-7*var(5)+2*var(6)^2-7*var(6)+28,(4*var(6)-1)*var(5)-var(6)+4,4*var(1)+var(5)+var(6),4*var(2)+var(5)+var(6),4*var(3)+var(5)+var(6),4*var(4)+var(5)+var(6);
+    modQuotient(i,modQuotient(i,j));
+    ideal id2=x(1)^2+x(1)*x(2)*x(3),x(2)^2-x(3)^3*x(2),x(3)^3+x(2)^5*x(1)*x(3);
+    quotient(id2,maxideal(3));
+}
+
+/* test if a prime number p is permissible for an ideal I
+ * i.e. it does not divide the denominator of any of the coefficients
+ * or numerator of any of the leading coefficients */
+static proc isPermissible(int p,ideal I)
+{
+    /* erase zero generators */
+    def J = simplify(I, 2);
+
+    /* clear denominators and compute the leading coefficients of
+       the cleared one and the original one*/
+    int n = ncols(J);
+    int i;
+    ideal K;
+    for(i = n; i > 0; i--)
+    {
+        K[i] = leadcoef(cleardenom(J[i]))*var(1)+leadcoef(J[i]);
+    }
+
+    /* change to characteristic p */
+    def br = basering;
+    list lbr = ringlist(br);
+    if (typeof(lbr[1]) == "int") { lbr[1] = p; }
+    else { lbr[1][1] = p; }
+    def rp = ring(lbr);
+    setring(rp);
+    ideal Kp = fetch(br, K);
+
+    /* test if any leading coefficient is missing */
+    if (intvec(size(Kp[1..n])) != 2:n) { setring(br); return(0); }
+    setring(br);
+    return(1);
+}
+
+/* test if the prime p is permissible for I and J */
+static proc primeTest_quotient(int p, alias list args)
+{
+    def I = args[1];
+    def J = args[2];
+    if(!isPermissible(p,I)){print("not permissible");return(0);}
+    if(!isPermissible(p,J)){print("not permissible");return(0);}
+    return(1);
+}
+
+/* test if 'command' applied to 'args' in characteristic p is the same as
+   'result' mapped to characteristic p */
+static proc pTest_quotient(string command, alias list args, alias def result,
+    int p)
+{
+    /* change to characteristic p */
+    def br = basering;
+    list lbr = ringlist(br);
+    if (typeof(lbr[1]) == "int") { lbr[1] = p; }
+    else { lbr[1][1] = p; }
+    def rp = ring(lbr);
+    setring(rp);
+    list args_fetched = fetch(br, args);
+    def Ip = args_fetched[1];
+    def Jp = args_fetched[2];
+    def Gp = fetch(br, result);
+    def IJp;
+    attrib(Ip, "isSB", 1);
+    attrib(Gp, "isSB", 1);
+
+    /* test if (Ip:Jp) is in Gp */
+    /* compute command(args) */
+    execute("IJp = "+command+"(Ip,Jp);");
+    int i;
+    for (i = ncols(IJp); i > 0; i--)
+    {
+        if (reduce(IJp[i], Gp, 1) != 0)
+        {
+            setring(br);
+            return(0);
+        }
+    }
+
+    /* test if Gp is in (Ip:Jp) */
+    ideal GpJp=Gp*Jp;
+    for (i = ncols(GpJp); i > 0; i--)
+    {
+        if (reduce(GpJp[i], Ip, 1) != 0) { setring(br); return(0); }
+    }
+    setring(br);
+    return(1);
+}
+
+/* test if 'result' is a GB of (I:J) */
+static proc finalTest_quotient(string command, alias list args, def result)
+{
+    /* test if result is in (I:J)*/
+    attrib(result, "isSB", 1);
+    int i;
+    def IJ=result*args[2];
+    for (i = ncols(IJ); i > 0; i--)
+    {
+        if (reduce(IJ[i], args[1], 1) != 0) {print("fail") return(0); }
+    }
+    return(1);
+}
+
+proc modSat(def I, def J)
+"USAGE:   modSat(I,J); I,J ideal
+RETURN:   a standard basis of (I:J^\infty)
+NOTE:     The procedure computes a standard basis of (I:J^\infty) (over the rational
+          numbers) by using modular methods.
+KEYWORDS: saturation
+SEE ALSO: modular; sat_with_exp
+EXAMPLE:  example modSat; shows an example"
+{
+    I = modStd(I);
+    def IJ=modular("sat_with_exp",list(I,J),primeTest_sat,
+      deleteUnluckyPrimes_sat,pTest_sat,finalTest_sat);
+    return(IJ);
+}
+example
+{
+    "EXAMPLE:";
+    echo=2;
+    ring r=0,x(1..6),dp;
+    ideal i=cyclic(6);
+    ideal j=-15*var(5)+16*var(6)^3-60*var(6)^2+225*var(6)-4,2*var(5)^2-7*var(5)+2*var(6)^2-7*var(6)+28,(4*var(6)-1)*var(5)-var(6)+4,4*var(1)+var(5)+var(6),4*var(2)+var(5)+var(6),4*var(3)+var(5)+var(6),4*var(4)+var(5)+var(6);
+    modSat(i,modSat(i,j)[1])[1];
+    poly F     = x(1)^5+x(2)^5+(x(1)-x(2))^2*x(1)*x(2)*x(3);
+    ideal J    = jacob(F);
+    modSat(J,maxideal(1));
+}
+
+/* test if the prime p is permissible for I and J */
+static proc primeTest_sat(int p, alias list args)
+{
+    return(primeTest_quotient(p,args));
+}
+
+/* find entries in modresults which come from unlucky primes.
+ * For this, sort the entries into categories depending on their leading
+ * ideal and return the indices in all but the biggest category.
+ * Referring to Modstd::deleteUnlickyPrimes_std. */
+static proc deleteUnluckyPrimes_sat(alias list modresults)
+{
+    int size_modresults = size(modresults);
+
+    /* sort results into categories.
+     * each category is represented by three entries:
+     * - the corresponding leading ideal
+     * - the number of elements
+     * - the indices of the elements
+     */
+    list cat;
+    int size_cat;
+    def L=modresults[1][1]; // dummy assign to get the type of L
+    int i;
+    int j;
+    for (i = 1; i <= size_modresults; i++)
+    {
+        L = lead(modresults[i][1]);
+        attrib(L, "isSB", 1);
+        for (j = 1; j <= size_cat; j++)
+        {
+            if (size(L) == size(cat[j][1]))
+            {
+            if (size(reduce(L, cat[j][1], 5)) == 0)
+            {
+            if (size(reduce(cat[j][1], L, 5)) == 0)
+            {
+                cat[j][2] = cat[j][2]+1;
+                cat[j][3][cat[j][2]] = i;
+                break;
+            }
+            }
+            }
+        }
+        if (j > size_cat)
+        {
+            size_cat++;
+            cat[size_cat] = list();
+            cat[size_cat][1] = L;
+            cat[size_cat][2] = 1;
+            cat[size_cat][3] = list(i);
+        }
+    }
+
+    /* find the biggest categories */
+    int cat_max = 1;
+    int max = cat[1][2];
+    for (i = 2; i <= size_cat; i++)
+    {
+        if (cat[i][2] > max)
+        {
+            cat_max = i;
+            max = cat[i][2];
+        }
+    }
+
+    /* return all other indices */
+    list unluckyIndices;
+    for (i = 1; i <= size_cat; i++)
+    {
+        if (i != cat_max) { unluckyIndices = unluckyIndices + cat[i][3]; }
+    }
+    return(unluckyIndices);
+}
+
+/* test if 'command' applied to 'args' in characteristic p is the same as
+   'result' mapped to characteristic p */
+static proc pTest_sat(string command, alias list args, alias def result,
+    int p)
+{
+    /* change to characteristic p */
+    def br = basering;
+    list lbr = ringlist(br);
+    if (typeof(lbr[1]) == "int") { lbr[1] = p; }
+    else { lbr[1][1] = p; }
+    def rp = ring(lbr);
+    setring(rp);
+    list args_fetched = fetch(br, args);
+    def Ip = args_fetched[1];
+    def Jp = args_fetched[2];
+    def pResult = fetch(br, result);
+    def Gp=pResult[1];
+    def IJp;
+    attrib(Ip, "isSB", 1);
+    attrib(Gp, "isSB", 1);
+
+    /* test if (Ip:Jp^\infty) is in Gp */
+    /* compute command(args) */
+    execute("IJp = "+command+"(Ip,Jp)[1];");
+    int i;
+    for (i = ncols(IJp); i > 0; i--)
+    {
+        if (reduce(IJp[i], Gp, 5) != 0)
+        {
+            setring(br);
+            return(0);
+        }
+    }
+
+    /* test if Gp is in (Ip:Jp^\infty) */
+    for (i = ncols(Gp); i > 0; i--)
+    {
+        if (reduce(Gp[i], IJp, 5) != 0) { setring(br); return(0); }
+    }
+    setring(br);
+    return(1);
+}
+
+/* test if 'result' is a GB of (I:J^\infty) */
+static proc finalTest_sat(string command, alias list args, def result)
+{
+    /* test if result is in (I:J^\infty)*/
+    int i;
+    ideal H = result[1];
+    int m=0;
+    for (i = 0 ; i < result[2]; i++){m++;}
+    ideal JGm;
+    for (i = 0 ; i < size(args[2]); i++)
+    {
+      JGm = JGm + args[2]^m;
+    }
+    def K=H*JGm;
+    for (i = ncols(K); i > 0; i--)
+    {
+        if (reduce(K[i], args[1], 5) != 0) {print("fail") return(0); }
+    }
+    return(1);
+}

sage_wheels/share/singular/LIB/modfinduni.lib

@@ -0,0 +1,181 @@
+///////////////////////////////////////////////////////////////////////////////
+version="version modfinduni.lib 4.4.0.0 Dec_2023 "; // $Id: 69c17fd1790f448fc2f1a7f30ac28a8aec62c6a6 $
+category="Commutative Algebra";
+info="
+LIBRARY:  modfinduni.lib  finduni using modular methods
+
+AUTHORS:  H. Schoenemann  hannes@mathematik.uni-kl.de
+
+OVERVIEW: parallel version of finduni via modular.lib
+
+PROCEDURES:
+  modFinduni(I);    finduni of I using modular methods
+";
+
+LIB "modular.lib";
+
+proc modFinduni(ideal I)
+"USAGE:   modFinduni(I); I ideal
+RETURN:
+NOTE:     The procedure computes a standard basis of I (over the rational
+          numbers) by using modular methods.
+SEE ALSO: modular
+EXAMPLE:  example modFinduni; shows an example"
+{
+    /* save options */
+    intvec opt = option(get);
+    option(redSB);
+    /* choose the right command */
+    string command = "nFinduni";
+
+    /* call modular() */
+    I = modular(command, list(I), primeTest_std,
+            deleteUnluckyPrimes_default, pTest_default,
+            finalTest_finduni,536870909);
+    /* return the result */
+    option(set, opt);
+    return(I);
+}
+example
+{
+    "EXAMPLE:";
+    echo = 2;
+}
+
+/* test if the prime p is suitable for the input, i.e. it does not divide
+ * the numerator or denominator of any of the coefficients */
+static proc primeTest_std(int p, alias list args)
+{
+    /* erase zero generators */
+    def I = simplify(args[1], 2);
+
+    /* clear denominators and count the terms */
+    def J=I; // dummy assign, to get the type of I
+    ideal K;
+    int n = ncols(I);
+    intvec sizes;
+    number cnt;
+    int i;
+    for(i = n; i > 0; i--)
+    {
+        J[i] = cleardenom(I[i]);
+        cnt = leadcoef(J[i])/leadcoef(I[i]);
+        K[i] = numerator(cnt)*var(1)+denominator(cnt);
+    }
+    sizes = size(J[1..n]);
+
+    /* change to characteristic p */
+    def br = basering;
+    list lbr = ringlist(br);
+    if (typeof(lbr[1]) == "int") { lbr[1] = p; }
+    else { lbr[1][1] = p; }
+    def rp = ring(lbr);
+    setring(rp);
+    def Jp = fetch(br, J);
+    ideal Kp = fetch(br, K);
+
+    /* test if any coefficient is missing */
+    if (intvec(size(Kp[1..n])) != 2:n) { setring(br); return(0); }
+    if (intvec(size(Jp[1..n])) != sizes) { setring(br); return(0); }
+    setring(br);
+    return(1);
+}
+
+static proc deleteUnluckyPrimes_default(alias list modresults)
+{
+    return(list());
+}
+
+proc nFinduni(ideal I)
+{
+  attrib(I,"isSB",1);
+  I=finduni(I);
+  I=simplify(I,1);
+  return(I);
+}
+
+/* find entries in modresults which come from unlucky primes.
+ * For this, sort the entries into categories depending on their leading
+ * ideal and return the indices in all but the biggest category. */
+static proc deleteUnluckyPrimes_std(alias list modresults)
+{
+    int size_modresults = size(modresults);
+
+    /* sort results into categories.
+     * each category is represented by three entries:
+     * - the corresponding leading ideal
+     * - the number of elements
+     * - the indices of the elements
+     */
+    list cat;
+    int size_cat;
+    def L=modresults[1]; // dummy assign to get the type of L
+    int i;
+    int j;
+    for (i = 1; i <= size_modresults; i++)
+    {
+        L = lead(modresults[i]);
+        attrib(L, "isSB", 1);
+        for (j = 1; j <= size_cat; j++)
+        {
+            if (size(L) == size(cat[j][1])
+            && size(reduce(L, cat[j][1], 5)) == 0
+            && size(reduce(cat[j][1], L, 5)) == 0)
+            {
+                cat[j][2] = cat[j][2]+1;
+                cat[j][3][cat[j][2]] = i;
+                break;
+            }
+        }
+        if (j > size_cat)
+        {
+            size_cat++;
+            cat[size_cat] = list();
+            cat[size_cat][1] = L;
+            cat[size_cat][2] = 1;
+            cat[size_cat][3] = list(i);
+        }
+    }
+
+    /* find the biggest categories */
+    int cat_max = 1;
+    int max = cat[1][2];
+    for (i = 2; i <= size_cat; i++)
+    {
+        if (cat[i][2] > max)
+        {
+            cat_max = i;
+            max = cat[i][2];
+        }
+    }
+
+    /* return all other indices */
+    list unluckyIndices;
+    for (i = 1; i <= size_cat; i++)
+    {
+        if (i != cat_max) { unluckyIndices = unluckyIndices + cat[i][3]; }
+    }
+    return(unluckyIndices);
+}
+////////////////////////////////////////////////////////////////////////////////
+
+/* test if 'result' is finduni of the input ideal */
+static proc finalTest_finduni(string command, alias list args, def result)
+{
+    /* test if args[1] is in result */
+    int i;
+    ideal I=args[1];
+    attrib(I,"isSB",1);
+    for (i = ncols(result); i > 0; i--)
+    {
+        if (reduce(result[i], I, 5) != 0) { return(0); }
+    }
+    return(1);
+}
+
+static proc pTest_default(string command, alias list args, alias def result,
+    int p)
+{
+    return(1);
+}
+