passagemath-singular 10.6.30__cp310-cp310-musllinux_1_2_aarch64.whl → 10.6.31rc1__cp310-cp310-musllinux_1_2_aarch64.whl

sage_wheels/share/singular/LIB/assprimeszerodim.lib

@@ -1,5 +1,5 @@
 ///////////////////////////////////////////////////////////////////////////////
-version="version assprimeszerodim.lib 4.4.0.7 Jan_2025 "; // $Id: 0162ca730506c26c2300f08ea75b597ca25d42ca $
+version="version assprimeszerodim.lib 4.4.0.7 Jan_2025 "; // $Id: ef1e7451637c24425c1196163d51fd098220dd2b $
 category="Commutative Algebra";
 info="
 LIBRARY:  assprimeszerodim.lib   associated primes of a zero-dimensional ideal
@@ -53,26 +53,19 @@ EXAMPLE: example zeroRadical; shows an example
       I = modStd(I, exactness);
    }
 
-   if(system("cpu")>0)
+   /* call modular() */
+   // TODO: write deleteUnluckyPrimes_zeroRadical()
+   if(exactness)
    {
-     /* call modular() */
-     // TODO: write deleteUnluckyPrimes_zeroRadical()
-     if(exactness)
-     {
-      ideal F = modular("Assprimeszerodim::zeroRadP", list(I),
-         Modstd::primeTest_std, Modular::deleteUnluckyPrimes_default,
-         pTest_zeroRadical, finalTest_zeroRadical);
-     }
-     else
-     {
-      ideal F = modular("Assprimeszerodim::zeroRadP", list(I),
-         Modstd::primeTest_std, Modular::deleteUnluckyPrimes_default,
-         pTest_zeroRadical);
-     }
+    ideal F = modular("Assprimeszerodim::zeroRadP", list(I),
+       Modstd::primeTest_std, Modular::deleteUnluckyPrimes_default,
+       pTest_zeroRadical, finalTest_zeroRadical);
    }
    else
    {
-     ideal F=zeroRadP(I);
+    ideal F = modular("Assprimeszerodim::zeroRadP", list(I),
+       Modstd::primeTest_std, Modular::deleteUnluckyPrimes_default,
+       pTest_zeroRadical);
    }
 
    /* compute the squarefree parts */
@@ -241,27 +234,20 @@ EXAMPLE: example assPrimes; shows an example
    I = J;
    kill J;
 
-   if (system("cpu")>0)
-   {
-     /* call modular() */
-     if(exactness)
-     {
-      ideal F = modular("Assprimeszerodim::modpSpecialAlgDep",
-         list(I, f, d, a),
-         Modstd::primeTest_std, Modular::deleteUnluckyPrimes_default,
-         pTest_assPrimes, finalTest_assPrimes);
-     }
-     else
-     {
-      ideal F = modular("Assprimeszerodim::modpSpecialAlgDep",
-         list(I, f, d, a),
-         Modstd::primeTest_std, Modular::deleteUnluckyPrimes_default,
-         pTest_assPrimes);
-     }
+   /* call modular() */
+   if(exactness)
+   {
+    ideal F = modular("Assprimeszerodim::modpSpecialAlgDep",
+       list(I, f, d, a),
+       Modstd::primeTest_std, Modular::deleteUnluckyPrimes_default,
+       pTest_assPrimes, finalTest_assPrimes);
    }
    else
    {
-     ideal F=modpSpecialAlgDep(I,f,d,a);
+    ideal F = modular("Assprimeszerodim::modpSpecialAlgDep",
+       list(I, f, d, a),
+       Modstd::primeTest_std, Modular::deleteUnluckyPrimes_default,
+       pTest_assPrimes);
    }
 
    /* compute the components */

sage_wheels/share/singular/LIB/gmspoly.lib

@@ -1,5 +1,5 @@
 //////////////////////////////////////////////////////////////////////////////
-version="version gmspoly.lib 4.1.2.0 Feb_2019 "; // $Id: 264cf0a57042ad73de9f7a4d323de57c3f4bdca1 $
+version="version gmspoly.lib 4.1.2.0 Feb_2019 "; // $Id: b27adbe7809d78a2fbdb3361179238f229630648 $
 category="Singularities";
 
 info="
@@ -180,7 +180,7 @@ static proc vfiltmat(matrix B,int d)
     attrib(V0,"isSB",1);
     V1=B*matrix(V1)-var(1)^d*diff(matrix(V1),var(1));
   }
-  option("noredSB");
+  option(noredSB);
 
   B=lift(V0,B*matrix(V)-var(1)^d*diff(matrix(V),var(1)));
   list l=eigenvals(B);

sage_wheels/share/singular/LIB/homolog.lib

@@ -1,5 +1,5 @@
 //////////////////////////////////////////////////////////////////////////////
-version="version homolog.lib 4.3.1.3 Feb_2023 "; // $Id: 3755d88b9200ca6640a2db98b0067769fed4ec9a $
+version="version homolog.lib 4.3.1.3 Feb_2023 "; // $Id: edb4d3f6872be2a174b59bb155ac537334344b34 $
 category="Commutative Algebra";
 info="
 LIBRARY:  homolog.lib   Procedures for Homological Algebra
@@ -435,6 +435,30 @@ example
   printlevel = p;
 }
 ///////////////////////////////////////////////////////////////////////////////
+static proc get_weight(vector t, intvec shifts)
+{
+  int n = nrows(t);
+  for (int i = 1; i <= n; i++)
+  {
+    if (t[i] != 0)
+    {
+      return( deg(t[i]) + shifts[i]);
+    }
+  }
+  return(-1);
+}
+
+static proc get_list_of_weights(module M)
+{
+  int r = ncols(M);
+  intvec shifts = attrib(M, "isHomog");
+  intvec weights = 0:r;
+  for (int i = 1; i <= r; i++)
+  {
+    weights[i] = get_weight(M[i], shifts);
+  }
+  return(weights);
+}
 
 proc Ext_R (intvec v, module M, list #)
 "USAGE:   Ext_R(v,M[,p]);  v int resp. intvec , M module, p int
@@ -606,7 +630,14 @@ EXAMPLE: example Ext_R; shows an example
       if ((typeof(attrib(m2t,"isHomog"))!="string" ) && (withWeight))
       {
         // ------------- compute weights for dual -----------------------------
-        weightR=attrib(m2t,"isHomog");
+        if (k == 0)
+        {
+          weightR = attrib(m2t, "isHomog");
+        }
+        else
+        {
+          weightR = get_list_of_weights(resl[k]);
+        }
         // --------------------------------------------------------------------
         // *** set correct weights (at this writing, shift in resolution
         // *** is not considered when defining the weights for the
@@ -663,7 +694,14 @@ EXAMPLE: example Ext_R; shows an example
         m1 = transpose(resl[k]);
         if ((typeof(attrib(m1t,"isHomog"))!="string" ) && (withWeight)) {
         // ------------- compute weights for dual -----------------------------
-          weightR=attrib(resl[k],"isHomog");
+          if (k == 1)
+          {
+            weightR = attrib(resl[k], "isHomog");
+          }
+          else
+          {
+            weightR = get_list_of_weights(resl[k - 1]);
+          }
           // ------------------------------------------------------------------
           // *** set correct weights (at this writing, shift in resolution
           // *** is not considered when defining the weights for the

sage_wheels/share/singular/LIB/modprimdec.lib

@@ -1,5 +1,5 @@
 ////////////////////////////////////////////////////////////////////////////
-version="version modprimdec.lib 4.4.0.7 Jan_2014 "; //$Id: c157e2206dcf892b94c2ab104249b53dca2f15df $
+version="version modprimdec.lib 4.4.0.7 Jan_2014 "; //$Id: 9573497bec1b34b20ed6b267445b396a2739f9e0 $
 category="Commutative Algebra";
 info="
 LIBRARY:  modprimdec.lib   Primary Decomposition via Modular Methods
@@ -1107,9 +1107,29 @@ EXAMPLE: example primdecGTZ_wrapper; shows an example
       return(li);
    }
 
+   i=simplify(i,2); // erase 0-generators
+   if (ncols(i) >= 1) {
+       if ((i[1]==0)||(i[1]==1))
+       {
+         list L = list(ideal(i[1]), ideal(i[1]) );
+         return(list(L));
+       }
+   }
+   if((ncols(i)==1)&&(attrib(basering,"ring_cf")==0)) // handle principal ideal
+   {
+     list @fac=factorize(i[1],2);
+     list result;
+     for(int @i=size(@fac[1]);@i>0;@i--)
+     {
+       result[@i]=list(ideal(@fac[1][@i]^@fac[2][@i]),
+                        ideal(@fac[1][@i]));
+     }
+     return(result);
+   }
+
    if(minpoly!=0)
    {
-      return(algeDeco(i,0));
+      return(Primdec::algeDeco(i,0));
    }
   return(Primdec::convList(decomp_parallel(i, exactness, mod_only)));
 }

sage_wheels/share/singular/LIB/modstd.lib

@@ -1,5 +1,5 @@
 ///////////////////////////////////////////////////////////////////////////////
-version="version modstd.lib 4.3.0.1 Mar_2022 "; // $Id: 49bcd8b8463c6dab12a3bac756f807885c0472e7 $
+version="version modstd.lib 4.3.0.1 Mar_2022 "; // $Id: f61b67b01efbf6f676552231c956f9e079dc9c20 $
 category="Commutative Algebra";
 info="
 LIBRARY:  modstd.lib      Groebner bases of ideals/modules using modular methods
@@ -43,7 +43,6 @@ NOTE:     The procedure computes a standard basis of I (over the rational
 SEE ALSO: modular
 EXAMPLE:  example modStd; shows an example"
 {
-    if (system("--cpus")<1) { return(groebner(I)); }
     /* read optional parameter */
     int exactness = 1;
     if (size(#) > 0)

sage_wheels/share/singular/LIB/modular.lib

@@ -1,5 +1,5 @@
 ////////////////////////////////////////////////////////////////////
-version="version modular.lib 4.2.0.0 Dec_2020 "; // $Id: e3c81f6b38861e00f9a7575e74ef097b2ba98a32 $
+version="version modular.lib 4.4.1.1 Feb_2025 "; // $Id: 46167e43bde95cf43e83f5255177ca733f180d56 $
 category="General purpose";
 info="
 LIBRARY:   modular.lib  An abstraction layer for modular techniques
@@ -128,6 +128,8 @@ EXAMPLE:  example modular; shows an example"
     int ncores_available;
     while (1)
     {
+      if(system("cpu")>1)
+      {
         // compute list of primes
         if (nAllPrimes == 0)
         {
@@ -211,6 +213,68 @@ EXAMPLE:  example modular; shows an example"
 
         // finalTest
         if (finalTest(Command, Arguments, result)) break;
+      }
+      else
+      {
+        // compute list of primes
+        nNewPrimes = 3;
+        primes = primeList(nNewPrimes, pmax);
+        pmax = primes[size(primes)]-1;
+        nAllPrimes = nAllPrimes+nNewPrimes;
+
+        // do computation modulo several primes
+        for (i = size(primes); i > 0; i--)
+        {
+            modresults[i]=Modular::modp(primes[i]);
+        }
+
+        // delete unlucky primes
+        indices = deleteUnluckyPrimes(modresults);
+        indices = sort(indices)[1];
+        for (i = size(indices); i > 1; i--)
+        {
+            if (indices[i] == indices[i-1])
+            {
+                indices = delete(indices, i);
+            }
+        }
+        for (i = size(indices); i > 0; i--)
+        {
+            modresults = delete(modresults, indices[i]);
+            primes = delete(primes, indices[i]);
+        }
+
+        // lift result
+        if (N == 1)
+        {
+            result_lift = chinrem_recursive(modresults, primes);
+        }
+        else
+        {
+            result_lift = chinrem_recursive(list(result_lift)+modresults,
+                list(N)+primes);
+        }
+        modresults = list();
+        for (i = size(primes); i > 0; i--)
+        {
+            N = N*primes[i];
+        }
+
+        // apply farey
+        result = farey_parallel(result_lift, N);
+
+        // pTest
+        p = prime(random(pmax div 2, pmax-1));
+        while (!Modular::primeTest(p, Arguments))
+        {
+            if (p <= 2) { ERROR("no more primes"); }
+            p = prime(random(p div 2, p-1));
+        }
+        if (!pTest(Command, Arguments, result, p)) { continue; }
+
+        // finalTest
+        if (finalTest(Command, Arguments, result)) break;
+      }
     }
 
     /* kill exported data */
@@ -265,9 +329,11 @@ static proc chinrem_recursive(list modresults, list moduli)
 
 static proc primeList(int n, int pmax)
 {
-    list primes;
-    int p = pmax;
-    int i;
+  list primes;
+  int p = pmax;
+  int i;
+  if (system("cpu")>1)
+  {
     for (i = 1; i <= n; i++)
     {
         if (p < 2)
@@ -288,11 +354,28 @@ static proc primeList(int n, int pmax)
         }
         killTask(t(i));
     }
-    if (j < n)
+  }
+  else
+  {
+    int j;
+    for (i = 1; i <= n; i++)
     {
-        primes = primes+primeList(n-j, p);
+        if (p < 2)
+        { ERROR("no more primes"); }
+        p = prime(p);
+        if (Modular::primeList_task(p))
+        {
+          j++;
+          primes[j]=p;
+        }
+        p--;
     }
-    return(primes);
+  }
+  if (j < n)
+  {
+      primes = primes+primeList(n-j, p);
+  }
+  return(primes);
 }
 
 static proc primeList_task(int p)
@@ -342,7 +425,6 @@ static proc finalTest_default(string command, alias list args,
 
 static proc farey_parallel(def farey_arg, bigint farey_N)
 {
-    if(system("cpu")==0) { return(farey(farey_arg,farey_N)); }
     arg_type = typeof(farey_arg);
     if (arg_type != "bigint" && arg_type != "ideal" && arg_type != "module"
         && arg_type != "matrix" && arg_type != "list")
@@ -350,6 +432,8 @@ static proc farey_parallel(def farey_arg, bigint farey_N)
     int i;
     if (arg_type == "list")
     {
+      if(system("cpu")>1)
+      {
         int size_farey_arg = size(farey_arg);
         for (i = size_farey_arg; i > 0; i--)
         {
@@ -363,7 +447,16 @@ static proc farey_parallel(def farey_arg, bigint farey_N)
             result[i] = getResult(t(i));
             killTask(t(i));
         }
-        return(result);
+      }
+      else
+      {
+        int size_farey_arg = size(farey_arg);
+        for (i = size_farey_arg; i > 0; i--)
+        {
+          result[i] = Modular::farey_parallel(farey_arg[i], farey_N);
+        }
+      }
+      return(result);
     }
     if (arg_type == "bigint" || arg_type == "matrix")
     { return(farey(farey_arg, farey_N)); }
@@ -373,22 +466,36 @@ static proc farey_parallel(def farey_arg, bigint farey_N)
     //  return(farey(farey_arg,farey_N));
     //}
     exportto(Modular, farey_arg);
-    exportto(Modular, farey_N);
+    if (defined(farey_N)>1) {exportto(Modular, farey_N);}
     int size_arg = ncols(farey_arg);
     int chunks = par_range(size_arg);
     intvec range;
-    for (i = chunks; i > 0; i--)
+    if(system("cpu")>1)
     {
+      for (i = chunks; i > 0; i--)
+      {
         range = par_range(size_arg, i);
         task t(i) = "Modular::farey_task", list(range);
-    }
-    startTasks(t(1..chunks));
-    waitAllTasks(t(1..chunks));
-    def result = getResult(t(chunks));
-    for (i = chunks-1; i > 0; i--)
-    {
+      }
+      startTasks(t(1..chunks));
+      waitAllTasks(t(1..chunks));
+      def result = getResult(t(chunks));
+      for (i = chunks-1; i > 0; i--)
+      {
         result = getResult(t(i)), result;
         killTask(t(i));
+      }
+    }
+    else
+    {
+      def result;
+      range = par_range(size_arg, chunks);
+      result = Modular::farey_task(range);
+      for (i = chunks-1; i > 0; i--)
+      {
+        range = par_range(size_arg, i);
+        result = Modular::farey_task(range),result;
+      }
     }
     kill farey_arg;
     kill farey_N;

sage_wheels/share/singular/LIB/modules.lib

@@ -1,5 +1,5 @@
 ///////////////////////////////////////////////////////////////////////////////
-version="version modules.lib 4.1.2.0 Feb_2019 "; // $Id: f041236f3424a3f877c78d1b38553570372af682 $
+version="version modules.lib 4.1.2.0 Feb_2019 "; // $Id: c75205a956e2064a09eb3d8f6805d5eed9e904fc $
 category="Commutative Algebra";
 info="
 LIBRARY:  modules.lib    Modules
@@ -486,18 +486,26 @@ matrix a=R.reso[1];
 R.dd[1]=makeMatrix(a);
 if(!(R.dd[1].ishomogeneous)){
   R.isgraded=0;
-  for(int i=2;i<=(size(R.reso)+1);i++){
-    a=R.reso[i];
-    R.dd[i]=nongradedMatrix(a);
+  for(int i=2;i<=(size(R.reso)+1);i++)
+  {
+    if(size(module(a))>0)
+    {
+      a=R.reso[i];
+      R.dd[i]=nongradedMatrix(a);
+    }
   }
 
 }
 else{
   R.isgraded=1;
-  for(int i=2;i<=(size(R.reso));i++){
+  for(int i=2;i<=(size(R.reso));i++)
+  {
     a=R.reso[i];
-    mydeg=R.dd[i-1].source.grading;
-    R.dd[i]=resMatrix(a,mydeg,R.dd[i-1].source);
+    if(size(module(a))>0)
+    {
+      mydeg=R.dd[i-1].source.grading;
+      R.dd[i]=resMatrix(a,mydeg,R.dd[i-1].source);
+    }
   }
 }
 R.over=M.over;

sage_wheels/share/singular/LIB/ncpreim.lib

@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////
-version="version ncpreim.lib 4.1.2.0 Feb_2019 "; // $Id: 6e8ad12f315e785ef78646924a92982d37221d62 $
+version="version ncpreim.lib 4.1.2.0 Feb_2019 "; // $Id: f12c1cc4074988e006ec2eaea73e2a69d604427f $
 category="Noncommutative";
 info="
 LIBRARY: ncpreim.lib    Non-commutative elimination and preimage computations
@@ -124,7 +124,7 @@ EXAMPLE:  example admissibleSub; shows examples
   M = simplify(M,2); // get rid of double entries in v
   intvec opt = option(get);
   attrib(M,"isSB",1);
-  option("redSB");
+  option(redSB);
   J = NF(I,M);
   option(set,opt);
   for (i=1; i<=ncols(I); i++)

sage_wheels/share/singular/LIB/normal.lib

@@ -1,6 +1,6 @@
 //////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////
-version="version normal.lib 4.3.2.10 Nov_2023 "; // $Id: 76a6039ff3cbeb86af5b829fd9dea81803cb208f $
+version="version normal.lib 4.3.2.10 Nov_2023 "; // $Id: 3046fde492a13a76f318c7c627e4fea52f9fd221 $
 category="Commutative Algebra";
 info="
 LIBRARY:  normal.lib     Normalization of Affine Rings
@@ -7380,8 +7380,8 @@ EXAMPLE: example modNormal; shows an example
   int d = dim(I);
   ideal IMin = IM[2];
   qring Q = I;   // We work in the quotient by the groebner base of the ideal I
-  option("redSB");
-  option("returnSB");
+  option(redSB);
+  option(returnSB);
   ideal I = fetch(R, I);
   attrib(I, "isSB", 1);
   ideal IMin = fetch(R, IMin);
@@ -7446,7 +7446,7 @@ EXAMPLE: example modNormal; shows an example
     maxModularTime=0;
     totalModularTime = timer;
     if (k==1) {sh=0;} else {sh=1;}
-    if (ncores == 1)
+    if (ncores <= 1)
     {
       for(j = (k-1)*n2+1+sh; j <= k*n2+1; j++)
       {
@@ -7760,8 +7760,8 @@ EXAMPLE: example locNormal; shows an example
   int d = dim(I);
   ideal IMin = IM[2];
   qring Q = I;   // We work in the quotient by the groebner base of the ideal I
-  option("redSB");
-  option("returnSB");
+  option(redSB);
+  option(returnSB);
   ideal I = fetch(R, I);
   attrib(I, "isSB", 1);
   ideal IMin = fetch(R, IMin);