passagemath-singular 10.6.29__cp311-cp311-musllinux_1_2_aarch64.whl → 10.6.31__cp311-cp311-musllinux_1_2_aarch64.whl

sage_wheels/share/singular/LIB/normaliz.lib

@@ -1,5 +1,5 @@
 //// Singular library normaliz.lib
-version="version normaliz.lib 4.3.1.0 June_2022 "; // $Id: e4de2ef9d38ebc698e86bc054dbee8a4456b5e70 $
+version="version normaliz.lib 4.4.1.2 July_2025 "; // $Id: 92f0b75c305fabbb45fb0054da4108ddb8c9cb52 $
 category="Commutative Algebra";
 info="
 LIBRARY: normaliz.lib  Provides an interface for the use of Normaliz 3.10.0 or
@@ -464,6 +464,41 @@ static proc getInt(string s, int p)
     return(i,p);
 }
 
+static proc getBigInt(string s, int p)
+{
+    string nst;
+    int j,en,sn;
+    bigint i;
+
+    for(;p<=size(s);p++)
+    {
+
+        if(digit(s[p]))
+        {
+            sn=p; break;
+        }
+    }
+    if(not(sn))
+    {
+        return(0,-1); // -1 indicates: no number found
+    }
+    p++;
+    for(;p<=size(s);p++)
+    {
+        if(!digit(s[p]))
+        {
+            en=p-1; break;
+        }
+    }
+    if(p>size(s))
+    {
+        en=size(s);
+    }
+    nst="i="+s[sn,en-sn+1];
+    execute(nst);
+    return(i,p);
+}
+
 
 static proc getRational(string s, int p)
 {
@@ -982,6 +1017,7 @@ static proc runNormaliz(list #)
     }
 
     Num_Invs=getNuminvs();
+
     int gens_computed = 0;
     for( int i = 1; i <= size(Num_Invs); i = i+1){
         if(Num_Invs[i][1] == "hilbert_basis_elements"){
@@ -1018,6 +1054,12 @@ RETURN:   The function applies Normaliz to the matrix input_mat ofe type nmz_typ
           The function returns the intmat defined by the file ith suffix gen, provided it has been computed. Otherwise it returns the input_mat.
 NOTE:     You will find procedures for many applications of Normaliz in this
           library, so the explicit call of this procedure may not be necessary.
+
+          The function reads the numerical invariants computed by normaliz. The integers among
+          them are converted to the Singular type int. It may to bee too small for
+          the Hilbert function or the multiplicity, especially if computed for a non-standard grading.
+          To prevent a disaster set the predefined global variable BigNumInvs = 1. Returnung to
+          BigNumInvs = 0 switches this feature off.
 SEE ALSO: intclToricRing, normalToricRing, ehrhartRing, intclMonIdeal,
           torusInvariants, diagInvariants, finiteDiagInvariants, intersectionValRings,
              intersectionValRingIdeals
@@ -1048,8 +1090,10 @@ static proc getNuminvs()
     string s;
     list num_invs;
     int p,sw,v_length,i,dummy_int;
+    bigint DummyInt;
     intvec dummy_vec;
     string type_inv,name_inv,dummy_bool;
+    int make_big_int;
 
     link in_f=":r "+ getNmzFile() + "."+"inv";
     s=read(in_f);
@@ -1072,23 +1116,46 @@ static proc getNuminvs()
             {
                 name_inv="h_vector";
             }
+            make_big_int = 0;
+            if(name_inv == "hilbert_series_num" || name_inv == "hilbert_series_cyclo_num"){
+                if(BigNumInvs){
+                    make_big_int = 1;
+                }
+            }
+              if(defined(DummyMat)==voice){
+                kill(DummyMat);
+            }
+            bigintmat DummyMat[1][v_length];
             if(name_inv!="hilbert_polynomial"
               && name_inv!="hilbert_quasipolynomial")
             {
                 for(i=1;i<=v_length;i++)
                 {
-                    if(i==1)
+                    if(i==1 && !make_big_int)
                     {
-                        (dummy_int,p)=getInt(s,p);
-                        dummy_vec=dummy_int;
+                        if(!make_big_int){
+                            (dummy_int,p)=getInt(s,p);
+                            dummy_vec=dummy_int;
+                        }
                     }
                     else
                     {
-                        (dummy_int,p)=getInt(s,p);
-                        dummy_vec=dummy_vec,dummy_int;
+                        if(!make_big_int){
+                            (dummy_int,p)=getInt(s,p);
+                            dummy_vec=dummy_vec,dummy_int;
+                        }
+                        else{
+                            (DummyInt,p) = getBigInt(s,p);
+                            DummyMat[1,i] = DummyInt;
+                        }
                     }
                 }
-                num_invs=num_invs+list(list(name_inv,dummy_vec,"intvec"));
+                if(!make_big_int){
+                    num_invs=num_invs+list(list(name_inv,dummy_vec,"intvec"));
+                }
+                else{
+                    num_invs=num_invs+list(list(name_inv,DummyMat,"bigintvec", v_length));
+                }
             }
             else
             {
@@ -1100,8 +1167,14 @@ static proc getNuminvs()
             (sw,p)=nextWord(s,p);
             name_inv=s[sw..p-1];
             if (name_inv!="hilbert_quasipolynomial_denom") {
-              (dummy_int,p)=getInt(s,p);
-              num_invs=num_invs+list(list(name_inv,dummy_int,"int"));
+                if(!BigNumInvs || (name_inv != "multiplicity" && name_inv != "multiplicity_num" && name_inv != "multiplicity_denom")){
+                   (dummy_int,p)=getInt(s,p);
+                    num_invs=num_invs+list(list(name_inv,dummy_int,"int"));
+                }
+                else {
+                    (DummyInt,p)=getBigInt(s,p);
+                    num_invs=num_invs+list(list(name_inv,dummy_int,"bigint"));
+                }
             }
         }
         if(type_inv=="boolean")
@@ -1122,6 +1195,7 @@ static proc getNuminvs()
     return(num_invs);
 }
 
+
 proc showNuminvs()
 "USAGE:   showNuminvs();
 PURPOSE:  prints the numerical invariants
@@ -1168,7 +1242,15 @@ EXAMPLE:  example exportNuminvs; shows an example
     for(i=1;i<=size(Num_Invs);i++)
     {
         dummy=Num_Invs[i];
-        s=dummy[3]+" nmz_" + dummy[1] + "=dummy[2]; exportto(Top," + "nmz_" + dummy[1] + ");";
+        if(dummy[3] != "bigintvec"){
+            s=dummy[3]+" nmz_" + dummy[1] + "=dummy[2]; exportto(Top," + "nmz_" + dummy[1] + ");";
+        }
+        else{
+            s = "bigintmat " + "nmz_" + dummy[1] + "[1][";
+            s = s + string(dummy[4]) + "]";
+            s = s + " = dummy[2];  exportto(Top," + "nmz_" + dummy[1] + ");";
+        }
+
         execute(s);
     }
     Exported_Num_Invs = Num_Invs;
@@ -1184,7 +1266,8 @@ example
   nmz_number_extreme_rays;
   nmz_rank;
   nmz_number_support_hyperplanes;
-  nmz_multiplicity;
+  if (defined(nmz_multiplicity)) {nmz_multiplicity;}
+  else {nmz_multiplicity_num;}
   nmz_primary;
 }
 
@@ -1592,7 +1675,7 @@ RETURN:   The toric ring S is the subalgebra of the basering generated by the
           leading monomials of the elements of I (considered as a list of
           polynomials). The function computes the computes the definig binomial
           ideal J of S with respect to the generators and returns it, together with
-          J. See eample.
+          J. DSee eample.
 NOTE:     A mathematical remark: the toric ring depends on the list of
           monomials given, and not only on the ideal they generate!
           This function requires the previous setting of an NmzFilename.
@@ -2092,13 +2175,13 @@ static proc mod_init()
   // int GenGen=1; export GenGen; // indicates whether "gen" is generated // no longer used
   list Num_Invs; export Num_Invs;
   list Exported_Num_Invs; export Exported_Num_Invs;
-// running normaliz (with options)
 
+// options for running normaliz
+//
 // component 1 is name of option
 // 2 is default value
 // 3 is command line option to be passed to Normaliz
-// 4 indicates whether file "gen" is generated
-// value 2 of 4 indicates "no influence"
+// 4 is a potential comment pointing to better use
 
   list nmz_options=
         list("supp",0,"-s"),
@@ -2137,4 +2220,7 @@ static proc mod_init()
     export nmz_options;
     list default_options = nmz_options;
     export default_options;
+
+    int BigNumInvs = 0;
+    exportto(Top, BigNumInvs);
 }

sage_wheels/share/singular/LIB/parallel.lib

@@ -1,5 +1,5 @@
 ////////////////////////////////////////////////////////////////////
-version="version parallel.lib 4.1.2.0 Feb_2019 "; // $Id: 8563f7dbb774bd733a709484252543895a896dd9 $
+version="version parallel.lib 4.4.1.1 Feb_2025 "; // $Id: a5e93aee5a9d3333810fc57b6fd047fa89e9f5b9 $
 category="General purpose";
 info="
 LIBRARY:   parallel.lib  An abstraction layer for parallel skeletons
@@ -91,25 +91,39 @@ EXAMPLE:  example parallelWaitN; shows an example"
         }
     }
 
-    // compute the tasks
-    for (i = 1; i <= njobs; i++) {
-        task t(i) = commands[i], args[i];
+    list results;
+    if(system("cpu")<=1)
+    {
+      list tmp;
+      int tmp_s;
+      for(i=njobs;i>0;i--)
+      {
+        tmp=args[i];
+        tmp_s=size(tmp);
+        execute("results[i]="+commands[i]+"(tmp[1..tmp_s]);");
+      }
     }
-    startTasks(t(1..njobs));
-    list indices = waitTasks(list(t(1..njobs)), N, timeout);
+    else
+    {
+      // compute the tasks
+      for (i = 1; i <= njobs; i++) {
+        task t(i) = commands[i], args[i];
+      }
+      startTasks(t(1..njobs));
+      list indices = waitTasks(list(t(1..njobs)), N, timeout);
 
-    // wrap back to saved semaphore
-    if (ncores) {
+      // wrap back to saved semaphore
+      if (ncores) {
         Resources::resetcores_subtree(semaphore_save);
-    }
+      }
 
-    // return results
-    list results;
-    for (i = size(indices); i > 0; i--) {
+      // return results
+      for (i = size(indices); i > 0; i--) {
         results[indices[i]] = getResult(t(indices[i]));
-    }
-    for (i = 1; i <= njobs; i++) {
+      }
+      for (i = 1; i <= njobs; i++) {
         killTask(t(i));
+      }
     }
     return(results);
 }

sage_wheels/share/singular/LIB/primdec.lib

@@ -1,5 +1,5 @@
 ////////////////////////////////////////////////////////////////////////////
-version="version primdec.lib 4.4.0.8 Dec_2024 "; // $Id: ef016f38b5efd97b3139c386d3370839f804cc42 $
+version="version primdec.lib 4.4.1.0 Febv_2025 "; // $Id: 9c0e76a43c07747eb051110c4388a436dd9cd264 $
 category="Commutative Algebra";
 info="
 LIBRARY: primdec.lib   Primary Decomposition and Radical of Ideals
@@ -55,7 +55,7 @@ PROCEDURES:
  gcdTest(I);
  zero_decomp(I,..); list of primary ideals and their radicals (I zero dimensional)
 
-SEE ALSO: primdecint_lib
+SEE ALSO: primdecint_lib; modprimdec_lib
 KEYWORDS: primary decomposition
 ";
 
@@ -1279,14 +1279,11 @@ static proc zeroSp(ideal i)
 
   //i has to be a reduced groebner basis
   ASSUME(1, dim(i)==0);
-  if (hasQQCoefficient(basering) && (nvars(basering)*vdim(I)>300))
+  if (hasQQCoefficient(basering)
+  && (nvars(basering)*vdim(I)>300))
   {
     ideal F=modFinduni(i);
   }
-  else
-  {
-    ideal F=finduni(i);
-  }
   int j,k,l,ready;
   list fa;
   fa[1]=factorize(F[1],1);
@@ -1785,7 +1782,7 @@ EXAMPLE: example prepareQuotientring; shows an example
     }
     else
     {
-      if (typeof(rl[1]=="cring"))
+      if (typeof(rl[1])=="cring")
       {
         cring p=rl[1];
         list rl2=rl[2];
@@ -2171,15 +2168,6 @@ static proc minAssPrimes_i(int patchPrimaryDecomposition, ideal i, list #)
       option( set,origOp );
       return( ideal(1) );
     }
-    //if (dim(i)>0)
-    //{
-    //  if(fastIrred(i))
-    //  {
-    //    setring P0;
-    //    option( set,origOp );
-    //    return(list(fetch(P,i)));
-    //  } // irreducible
-    //}
     if( (dim(i) == 0 ) && ( npars(P) == 0) )
     {
       int di = vdim(i);
@@ -3275,17 +3263,6 @@ EXAMPLE: example decomp_i; shows an example
   list fett;
   int lauf,di,newtest;
   //------------------------------------------------------------------
-  if(!abspri)
-  {
-    if((@wr!=2) && fastIrred(@j)) // #[1] for minAssGTZ
-    {
-      list res=@j,@j;
-      setring @P;
-      option(set,initialOp);
-      return(fetch(gnir,res));
-    }
-  }
-  //------------------------------------------------------------------
   //search for a maximal independent set indep,i.e.
   //look for subring such that the intersection with the ideal is zero
   //j intersected with K[var(indep[3]+1),...,var(nvar] is zero,
@@ -4072,7 +4049,8 @@ EXAMPLE: example zeroRad; shows an example"
 
    option(redSB);
    ASSUME(1, dim(I)==0);
-   if (hasQQCoefficient(basering) && (nvars(basering)*vdim(I)>300))
+   if (hasQQCoefficient(basering)
+   && (nvars(basering)*vdim(I)>300))
    {
      ideal F=modFinduni(I); //F[i] generates I intersected with K[var(i)]
    }
@@ -4293,6 +4271,7 @@ RETURN:  ideal, the annihilator of coker(M)
 NOTE:    The output is the ideal of all elements a of the basering R such that
          a * R^m is contained in M  (m=number of rows of M).
 EXAMPLE: example Ann; shows an example
+KEYWORDS: annihilator of a module
 "
 {
   M=prune(M);  //to obtain a small embedding
@@ -5646,6 +5625,7 @@ NOTE:    - Algorithm of Gianni/Trager/Zacharias.
          - For local and mixed orderings, the decomposition in the
            corresponding global ring is returned if the string 'global'
            is specified as second argument
+SEE ALSO: modPrimdecGTZ
 EXAMPLE: example primdecGTZE; shows an example
 "
 {
@@ -5679,6 +5659,7 @@ NOTE:    - Algorithm of Gianni/Trager/Zacharias.
          - For local and mixed orderings, the decomposition in the
            corresponding global ring is returned if the string 'global'
            is specified as second argument
+SEE ALSO: modPrimdecGTZ
 EXAMPLE: example primdecGTZ; shows an example
 "
 {
@@ -5737,6 +5718,25 @@ static proc primdecGTZ_i(int patchPrimaryDecomposition,ideal i, list #)
       }
       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))
+   {
+     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)
    {
@@ -6114,10 +6114,23 @@ static proc primdecSY_i(int patchPrimaryDecomposition, ideal i, list #)
    }
    i=simplify(i,2);
 
-   if ((i[1]==0)||(i[1]==1))
+   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))
    {
-     list L = list(ideal(i[1]), ideal(i[1]) );
-     return(list(L));
+     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)
@@ -6252,7 +6265,7 @@ static proc minAssGTZ_i(int patchPrimaryDecomposition, ideal i,list #)
   int useFac;
 
   // Set input parameters
-  algorithm = "GTZ";         // Default: GTZ algorithm
+  algorithm = "SL";         // Default: GTZ algorithm
   facstdOption = "facstd";
   if(size(#) > 0)
   {
@@ -6466,11 +6479,15 @@ EXAMPLE: example radical; shows an example
       def j=imap(s,j);
       return(j);
   }
+  int j;
+  if(!hasGFCoefficient(basering))
+  {
+    for(j=ncols(i);j>0;j--) { i[j]=sqrfree(i[j],3);}
+  }
   if(hasAlgExtensionCoefficient(basering))
   {
     return(algeRad(i));
   }
-  int j;
   def P0 = basering;
   list Pl=ring_list(P0);
   Pl[3]=list(list("dp",1:nvars(P0)),list("C",0));
@@ -9373,40 +9390,6 @@ EXAMPLE: example primdec; shows an example
   return(res);
 }
 
-static proc fastIrred(ideal j)
-// the ideal is a not zero dimensional GB
-// return 1 if it is irreducble for sure, 0 otherwise:
-// substituite indep. variables by random values,
-/ factor the univariate poly
-{
-  if (char(basering)!=0) { return(0);}
-  if (npars(basering)!=0) { return(0);}
-  int i;
-  for(i=1;i<=ncols(j);i++)
-  {
-    if(size(factorize(j[i],1))>1) { return(0);} // generators have factors
-  }
-  def savering=basering;
-  // find max. indep. set
-  intvec indep=indepSet(j);
-  int d=0;
-  for(i=1;i<=nvars(basering);i++)
-  {
-    if(indep[i]==1) { d++; j=subst(j,var(i),7 /*random(-5,5)*/);}
-  }
-  def R=changeordTo(savering,"lp");
-  setring R;
-  ideal j=fetch(savering,j);
-  j=std(j);
-  if (dim(j)!=d) {"ZERO";setring savering;return(0);} // zero found
-  list F=factorize(j[1]);
-  if (size(F[1])==2)
-  {
-    if (F[2][2]==1) {setring savering;return(1);} // irreducible
-  }
-  setring savering;
-  return(0); // may be reducible
-}
 ////////////////////////////////////////////////////////////////////////////
 /*
 //Beispiele Wenk-Dipl (in ~/Texfiles/Diplom/Wenk/Examples/)

sage_wheels/share/singular/LIB/primdecint.lib

@@ -1,5 +1,5 @@
 //////////////////////////////////////////////////////////////////////////////
-version="version primdecint.lib 4.3.2.2 Nov_2022 "; // $Id: 7d72592f6c9d06a5410650885197f494c7d72a6d $
+version="version primdecint.lib 4.4.1.1 Feb_2025 "; // $Id: c3a7a5c16612ce896fb311ab4e8c3ca7dff29ea4 $
 category = "Commutative Algebra";
 info="
 LIBRARY:  primdecint.lib   primary decomposition of an ideal in the polynomial
@@ -71,6 +71,7 @@ EXAMPLE: example primdecZ; shows an example
       int n = 1;
       ideal TES = 1;
    }
+   if (system("cpu")<=1) { n=1; }
 
 
    if(size(I)==1 && deg(I[1]) == 0)
@@ -129,7 +130,6 @@ EXAMPLE: example primdecZ; shows an example
          {
             p=int(L[1][i + 1]);
             nu=int(L[2][i + 1]);
-            //link l(i) = "MPtcp:fork";
             link l(i) = "ssi:fork";
             open(l(i));
             write(l(i), quote(modp(eval(J), eval(p), eval(nu))));

sage_wheels/share/singular/LIB/random.lib

@@ -1,5 +1,5 @@
 ///////////////////////////////////////////////////////////////////////////
-version="version random.lib 4.1.2.0 Feb_2019 "; // $Id: b9d4e8846557832cf2710837f16652894b5cb966 $
+version="version random.lib 4.1.2.0 Feb_2019 "; // $Id: ec617edc25603cabbc227492f80090f5c76c3e7a $
 category="General purpose";
 info="
 LIBRARY:  random.lib    Creating Random and Sparse Matrices, Ideals, Polys
@@ -391,7 +391,7 @@ EXAMPLE: example randomLast; shows an example
 "
 {
   ideal i=maxideal(1);
-  int k=size(i);
+  int k=nvars(basering);
   if (k<=1) { return(i);}
   i[k]=0;
   i=randomid(i,size(i),b);

sage_wheels/share/singular/LIB/resources.lib

@@ -1,5 +1,5 @@
 ////////////////////////////////////////////////////////////////////
-version="version resources.lib 4.1.2.0 Feb_2019 "; // $Id: 1cca86bcb27eefb3ab84076ef9a06a2e1fa897ec $
+version="version resources.lib 4.1.2.0 Feb_2019 "; // $Id: cc0371b2cd2ba4822fc7b167ef219c96bb57c506 $
 category="General purpose";
 info="
 LIBRARY:   resources.lib  Tools to manage the computational resources
@@ -30,18 +30,18 @@ PROCEDURES:
 /* initialize (lib-)global variables */
 static proc mod_init()
 {
-  if(system("cpu")>0)
+  if(system("cpu")>1)
   {
     int sem_cores = semaphore(system("--cpus")-1);
     int NCORES = system("semaphore", "get_value", sem_cores)+1;
   }
   else
   {
-    int sem_cores = 0;
-    int NCORES = 0;
+    int sem_cores = semaphore(0);
+    int NCORES = 1;
   }
-    exportto(Resources, sem_cores);
-    exportto(Resources, NCORES);
+  exportto(Resources, sem_cores);
+  exportto(Resources, NCORES);
 }
 
 proc addcores(int n)
@@ -76,6 +76,7 @@ EXAMPLE:  example addcores; shows an example"
 
     /* adjust and return NCORES */
     NCORES = NCORES+n;
+    if (system("cpu")) {system("--cpus",NCORES);}
     return(NCORES);
 }
 example