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

sage_wheels/share/singular/LIB/stdmodule.lib

@@ -0,0 +1,547 @@
+/////// Procedure to compute Standard Bases for Modules Over Subalgebras //////
+category="Commutative Algebra";
+info="
+LIBRARY: stdmodule.lib  Compute Standard Bases of submodule of free module over polynomial subalgebra w.r.t Natural Grading.
+AUTHORS:
+ Nazish Kanwal, Assistant Professor of Mathematics, Department of Sciences & Humanities, FAST-National University of Computer & Emerging Sciences-Karachi, Pakistan
+ Email: nkanwal@iba.edu.pk, nazish.kanwal@nu.edu.pk
+
+PROCEDURES:
+ MPGS(G,A);         Maximal part generating set for syzygies of G over subalgebra A
+ SNF(f,G,A);        normalform of vector f wrt. G in subalgebra A.
+ MSPOLY(G,A);       S-vectors of module G over subalgebra A.
+ MSGB(G,A):         Standard basis of module G over subalgebra A.
+
+REFERENCE:
+N, Kanwal, N, Jabeen & J. A, Khan (2021) Standard bases for modules over polynomial subalgebras, Communications in Algebra, 49:1, 58-72, DOI: 10.1080/00927872.2020.1793160
+
+SEE ALSO: sagbi_lib
+";
+LIB "teachstd.lib";
+LIB "algebra.lib";
+LIB "sagbi.lib";
+LIB "grobcov.lib";
+
+////////////////////////////////////////
+
+// Before start the main procedures we need these procedures
+// for sorting maximal part of polynomial, ideal, vector, and module w.r.t natural grading.
+
+
+/////// Procedure for computing maximal part of a polynomial \\\\\\\
+
+// This procedure compute the maximal part of a polynomial g w.r.t natural grading.
+
+proc Mpart (poly g)
+
+"USAGE: Mpart(g); a polynomial g.
+RETURN: a polynomial q: Maximal part of polynomial g."
+
+{
+ poly q=0;
+ int a,i,j;
+ a=deg(g);
+ poly h;
+ while(g!=0)
+ {
+   h=lead(g);
+   g=g-h;
+   if(deg(h)==a)
+   {
+      q=q+h;
+    }
+ }
+ return(q);
+}
+
+///////// Procedure for computing maximal part of an ideal//////
+
+
+// This procedure compute the maximal part of a ideal A w.r.t natural grading.
+
+proc Maxpart(ideal A)
+
+"USAGE: Maxpart(A); an ideal A .
+RETURN: an ideal D: Maximal part of ideal A."
+
+{
+ ideal D;
+ for(int i=ncols(A);i>0;i--)
+ {
+   D[i]=Mpart(A[i]);
+ }
+ return(D);
+}
+
+////// procedure for computing maximal part of a vector /////
+
+
+// This procedure compute the maximal part of a vector v w.r.t natural grading.
+
+proc Maxipart(vector v)
+
+"USAGE:Maxipart(v); a vector v.
+
+RETURN: a vector w: Maximal part of vector v."
+
+{
+ int i,j,a;
+ a=deg(leadmonom(v));
+ vector w=0;
+ poly v_i;
+ for (i=1;i<=nrows(v);i++)
+ {
+   v_i=v[i];
+   for (j=1;j<=size(v_i);j++)
+   {
+     if(deg(v_i[j])==a)
+     {
+       w=w+v_i[j]*gen(i);
+     }
+   }
+ }
+ return (w);
+}
+
+//////// Programm for sorting maximal part of a module /////.
+
+
+// This procedure compute the maximal part of a module L w.r.t natural grading.
+
+proc Maximalpart(module L)
+
+"USAGE:Maximalpart(L); L module.
+
+RETURN: a module M: Maximal part of module L. "
+
+{
+  int k;
+  module M;
+  vector v;
+  for (k=1;k<=size(L);k++)
+  {
+    v=L[k];
+    M[k]=Maxipart(v);
+  }
+  return(M);
+}
+
+/*
+// SINGULAR EXAMPLE for above procedures:
+
+// ring r=0,(x,y,z),Dp;
+// poly g= y6-x3z3-3y4z-3x2z3+y4+x3z+3y2z2-3xz3+x2z-xyz-2y2z-2z3+x2-yz+z2-y;
+
+\\ Mpart(g);
+y6-x3z3
+
+\\ ideal B=x3y5-z8+x4y3z-xy2,y4+x3z+3y2z2-3xz3+x2z-xyz,x3-y3+xz2-yxz+z2-xy+2y;
+
+\\ Maxpart(B);
+_[1]=x3y5+x4y3z-z8
+_[2]=y4+x3z+3y2z2-3xz3
+_[3]=x3-y3-xyz+xz2
+
+\\ vector f=[x2y2+x3z-y3-xyz-x3y2z-x2y2z+xy3z+x3z2+y3z+x2z2-xyz2-yz2, x6-3x4y+3x2y2-y3-xz-z];
+
+\\ Maxipart(f);
+x6*gen(2)-x3y2z*gen(1)
+
+\\ module G=[x3z+x2z-xyz-yz, y2+xz],[y4-2y2z+z2,xy2z+y2z-xz2-z2],[x2y2-y3-x2z+yz,x4-2x2y+y2];
+
+\\ Maximalpart(G);
+_[1]=x3z*gen(1)
+_[2]=y4*gen(1)+xy2z*gen(2)
+_[3]=x4*gen(2)+x2y2*gen(1)
+
+*/
+
+////////// Procedure to compute normal form ////////
+
+// For a vector f over subalgebra A and a finite set of vectors G ,
+// the following procedure compute a normal form of f with respect to G over subalgebra A.
+
+// For this procedure we required a procedure for one-step reduction.
+// This procedure compute a one-step reduction of vector f w.r.t module G over subalgebra A.
+
+proc divs(vector f, module G, ideal A)
+
+"USAGE: divs(f,G,A); f vector, G free module over A, A  subalgebra (which is a finite Sagbi bases).
+
+RETURN: a vector h: one step reduction of vector f wrt G over subalgebra A."
+
+{
+ A=sagbi(A);
+ module H=G;
+ ideal B=Maxpart(A);
+ int n=size(H);
+ vector h=f;
+ map psi;
+ int a=nrows(f);
+ module L=Maximalpart(H);
+ int i,j,k,l,b,c,d,e,u;
+ list T;
+ module Z,Q,Y;
+ vector v;
+ v=Maxipart(h);
+ poly ti;
+ ideal pj;
+ list D;
+ for(i=1;i<=a;i++)
+ {
+   D=list();
+   ti=v[i];
+   for(j=1;j<=n;j++)
+   {
+     if(ti==0){D[j]=0;}
+     else
+     {
+       if(L[j][i]!=0)
+       {
+         pj=L[j][i];
+         def Wi=pdivi(ti,pj);
+         D[j]=Wi[2][1];
+         kill Wi;
+       }
+       else
+       {D[j]=0;}
+     }
+   }
+   T[i]=D;
+ }
+ poly pl,jl;
+ vector z;
+ for(l=1;l<=a;l++)
+ {
+   for(b=1;b<=n;b++)
+   {
+     if(T[l][b]!=0)
+     {
+       pl=T[l][b];
+       list Ml=algebra_containment(pl,B,1);
+       if(Ml[1]==1)
+       {
+         def s=Ml[2];
+         psi=s,maxideal(1),A;
+         jl=psi(check);
+         Z=Z+jl*H[b];
+         kill s;
+         for(e=1;e<=size(Z);e++)
+         {
+           z=Maxipart(Z[e]);
+           if(v==z)
+           {
+             h=h-Z[e];
+             return(h);
+           }
+         }
+       }
+       kill Ml;
+     }
+   }
+   Q=Q+Z;
+ }
+ list N=Maximalpart(Q);
+ vector q;
+ for(c=1;c<=size(N)-1;c++)
+ {
+   for(d=c+1;d<=size(N);d++)
+   {
+     vector qcd=N[c]+N[d];
+     if((v-qcd)==0)
+     {
+       h=h-(Q[c]+Q[d]);
+       return(h);
+     }
+   }
+ }
+ return(h);
+}
+
+//////////////////////////////////////////////
+
+// This procedure compute the normal form of f w.r.t G over subalgebra A.
+
+// Here we use vector p=divs(f,G,A)
+
+proc SNF(vector f,module G, ideal A)
+
+"USAGE: SNF(f,G,A); f vector, G free module over A, A subalgebra (which is a finite Sagbi bases).
+
+RETURN: a vector g: normal form of a vector g wrt G over subalgebra A."
+{
+  vector g=divs(f,G,A);
+  vector p,g1;
+  while(g!=0 && g1!=g)
+  {
+    if(g==f)
+    {
+      g1=g;
+    }
+    else
+    {
+      p=divs(g,G,A);
+      g1=g;
+      g=p;
+    }
+  }
+  return(g);
+}
+example
+{
+  "EXAMPLE:"; echo = 2;
+  ring r=0,(x,y,z),dp;
+  ideal A=x2-y,xz+z,y2-z;
+  module G=[x3z+x2z-xyz-yz,y2+xz],[y4-2y2z+z2,xy2z+y2z-xz2-z2],[x2y2-y3-x2z+yz,x4-2x2y+y2];
+  vector v=[x2y4-y5-2x2y2z+2y3z+x2z2-yz2-xz-z, x4y2-2x2y3-x4z+y4+2x2yz-y2z+2];
+  vector u=[x2y4-y5-2x2y2z+2x3z+2y3z+x2z2+2x2z-2xyz-yz2-xz-2yz-z, x4y2-2x2y3-x4z+y4+2x2yz-y2z+3y2-3z+7];
+  SNF(v,G,A);
+  SNF(u,G,A);
+}
+
+//////// Maximal Part generating set for syzygies //////
+
+// This is a procedure for computing generating set for syzygies of
+// Maximal part of module G over subalgebra A.
+
+proc MPGS(module G,ideal A)
+
+"USAGE: G free module over subalgebra A, A subalgebra(which is finite sagbi basis).
+RETURN: a list W: generating set for syzygies of G over subalgebra A."
+
+{
+ A=sagbi(A);
+ module F=G;
+ ideal B=Maxpart(A);
+ ideal vars = maxideal(1) ;
+ def save_ring=basering;
+ int n=nvars(basering);
+ int m=ncols(A) ;
+ int i,k,c ;
+ module Q1 ;
+ if(G==0)
+ {
+   return(Q1) ;
+ }
+ else
+ {
+   execute("ring R1=("+charstr(save_ring)+"),(y(1..m),"+varstr(save_ring)+"),(dp(m),dp(n));");
+   module F=imap(save_ring,F);
+   ideal A=imap(save_ring,A);
+   ideal B=Maxpart(A);
+   module H=Maximalpart(F);
+   module J;
+   vector hk;
+   list M,Li;
+   vector vk;
+   poly pc;
+   for(k=1;k<=size(H);k++)
+   {
+     hk=Maxipart(H[k]);
+     M=list();
+     for(i=1;i<=nrows(hk);i++)
+     {
+       if(hk[i]!=0)
+       {
+         Li=algebra_containment((hk[i]),B,1);
+         if (Li[1]==1)
+         {
+           if (defined(Si)) { kill Si;}
+           def Si=Li[2];
+           setring Si;
+           poly ji=check;
+           setring R1;
+           poly ji=imap(Si,ji);
+           M[i]=ji;
+           kill ji;
+         }
+       }
+       else
+       {M[i]=0;}
+     }
+     for(c=1;c<=size(M);c++)
+     {
+       pc=M[c];
+       vk=vk+(pc*gen(c));
+     }
+     J[k]=vk;
+   }
+   int a=size(J);
+   list N=syz(J);
+   setring save_ring;
+   map psi=R1,A,maxideal(1);
+   list W=psi(N);
+   return(W);
+ }
+}
+example
+{
+  "EXAMPLE:"; echo = 2;
+// Example 1:
+   ring r=QQ,(x,y),Dp;
+   ideal A=x2,y2;
+   module G=[x4+2x2y2-1,y4],[-x2y2,x2y2],[2x2y4-y2,x4y2+y6],[-x2y2,x2y6+x6y2+2x4y4];
+   MPGS(G,A);
+
+// Example 2:
+   ring r2=QQ,(x,y),Dp;
+   ideal A=x2-xy+y, y2+x;
+   module G=x2y2-xy3+x3-x2y+y3+x2+y, y4+2xy2+x2-y2-x, 2xy-2x2+2xy-2y;
+   MPGS(G,A);
+}
+
+////////// S-vectors of module G over subalgebra A //////////////
+
+// This procedure compute S-vectors of module G over subalgebra A.
+
+// Here we use list P=MPGS(G,A) for computing S-vectors.
+
+proc MSPOLY(module G,ideal A)
+
+"USAGE: MSPOLY(G,A); G free module over subalgebra A, A subalgebra (which is a finite sagbi basis).
+
+RETURN" a module S: S-vectors of module G over subalgebra A."
+
+{
+ int i,j;
+ list P=MPGS(G,A);
+ module S;
+ vector hj;
+ vector Vj;
+ vector pij;
+ for(j=1;j<=size(P[1]);j++)
+ {
+   Vj=P[1][j];
+   hj=[0];
+   for(i=1;i<=nrows(Vj);i++)
+   {
+      pij = Vj[i]*G[i];
+      hj=hj+pij;
+   }
+   S=S+hj;
+ }
+ return(S);
+}
+example
+{
+  "EXAMPLE:"; echo = 2;
+  // Example 1:
+   ring r=QQ,(x,y,z),Dp;
+   ideal A=x2-yz,xy+x,xz;
+   module G=[x2yz+x2z-2,xz+xyz2-x3z],[x3y-xy2z+x3-xyz,-1],[xy+x,x2z2-x2+yz];
+   MSPOLY(G,A);
+
+  // Example 2:
+   ring r2=QQ,(x,y,z),dp;
+   ideal A=x2-y,xz+z,y2-z;
+   module G=[x2yz+x2z-2, xyz2+xz-x3z],[x3y+x3-xy2z-xyz,xz-xz-1],[xy+x,x2z2-x2+yz];
+   MSPOLY(G,A);
+}
+
+//////// Standard Bases Construction //////////
+
+// This procedure give Standard bases of
+// module G over subalgebra A.
+
+// We used module T=MSPOLY(G,A);
+
+proc MSGB(module G,ideal A)
+
+"USAGE: MSGB(G,A); G submodule over subalgebra A, A subalgebra (which is a finite sagbi basis).
+
+RETURN: a module MB: standard bases of G over subalgebra A."
+
+{
+ module MB,oldMB;
+ vector Red ;
+ module T ;
+ int k,l ;
+ MB=G ;
+ while( size(MB)!=size(oldMB))
+ {
+   T=MSPOLY(MB,A);
+   l=size(T);
+   if(l==0)
+   {oldMB=MB;}
+   else
+   {
+     for (k=1; k<=l;k++)
+     {
+       Red=T[k];
+       Red=SNF(Red,G,A);
+       oldMB=MB;
+       MB=MB+Red;
+     }
+   }
+ }
+ return(MB) ;
+}
+example
+{
+  "EXAMPLE:"; echo = 2;
+  // Example 1:
+  ring r=ZZ,(x,y),Dp;
+  ideal A=2x2+xy,2y2,3xy;
+  ideal I=4x2y2+2xy3,18x2y4;
+  MSGB(I,A);
+
+  // Example 2:
+   ring r2=QQ,(x,y),Dp;
+   ideal A= x2-xy+y, y2+x;
+   module G=x2y2-xy3+x3-x2y+y3+x2+y, y4+2xy2+x2-y2-x;
+   MSGB(G,A);
+
+  // Example 3:
+  ring r3=QQ,(x,y,z),Dp;
+  ideal A= x3-yz+2x, x2y2+xz2+3z;
+  module G=[x3-yz+2x, x2y2+xz2+3z, 2],[x2y2-x3+xz2+yz-2x-3z, 2x3-2yz+4x, -x2y2-xz2-3z+3],[x6-2x3yz+4x4+y2z2-4xyz+4x2, x6y6+3x5y4z2+3x4y2z4+9x4y4z+x3z6+18x3y2z3+x5y2+9x2z5+27x2y2z2+27xz4+27z3, x5y2+x4z2-x2y3z+2x3y2-xyz3+3x3z+2x2z2-3yz2+6xz];
+  MSGB(G,A);
+}
+/*
+// SINGULAR EXAMPLE #01 for all Procedures:
+
+// ring r=0,(x,y,z),Dp;
+// ideal A=x2-yz,xy+x,xz;
+// ideal A=x2-yz, xy+x, xz;
+// module G=[x2yz+x2z-2,xz+xyz2-x3z],[x3y-xy2z+x3-xyz,-1],[xy+x,x2z2-x2+yz];
+
+// MPGS(G,A);
+
+_[1]=x4*gen(3)+x3z*gen(1)-2x2yz*gen(3)-x2z2*gen(2)-xyz2*gen(1)+y2z2*gen(3)
+
+// MSPOLY(G,A);
+
+_[1]=-x6*gen(2)+x5y*gen(1)+3x4yz*gen(2)+x4z2*gen(2)-2x3y2z*gen(1)-3x2y2z2*gen(2)-x2yz3*gen(2)+xy3z2*gen(1)+y3z3*gen(2)+x5*gen(1)-2x3yz*gen(1)+xy2z2*gen(1)-2x3z*gen(1)+x2z2*gen(2)+2xyz2*gen(1)
+
+// MSGB(G,A);
+
+_[1]=-x3z*gen(2)+x2yz*gen(1)+xyz2*gen(2)+x2z*gen(1)+xz*gen(2)-2*gen(1)
+_[2]=x3y*gen(1)-xy2z*gen(1)+x3*gen(1)-xyz*gen(1)-gen(2)
+_[3]=x2z2*gen(2)-x2*gen(2)+xy*gen(1)+yz*gen(2)+x*gen(1)
+_[4]=-x6*gen(2)+x5y*gen(1)+3x4yz*gen(2)+x4z2*gen(2)-2x3y2z*gen(1)-3x2y2z2*gen(2)-x2yz3*gen(2)+xy3z2*gen(1)+y3z3*gen(2)+x5*gen(1)-2x3yz*gen(1)+xy2z2*gen(1)-2x3z*gen(1)+x2z2*gen(2)+2xyz2*gen(1)
+_[5]=x4yz*gen(1)+2x4z2*gen(1)-x3z3*gen(2)-x2y2z2*gen(1)-2x2yz3*gen(1)+x4z*gen(1)-x2yz2*gen(1)-2x4*gen(1)+4x2yz*gen(1)-2y2z2*gen(1)
+
+// SINGULAR EXAMPLE #02 for all Procedures:
+
+// ring r=0,(x,y),Dp;
+// ideal A=x2, y2;
+// module G=[x4+2x2y2-1,y4],[-x2y2,x2y2],[2x2y4-y2,x4y2+y6],[-x2y2,x6y2+2x4y4+x2y6];
+
+// MPGS(G,A);
+
+-[1]=x2*gen(2)+y2*gen(1)-gen(3)
+-[2]=2y4*gen(1)-x2*gen(3)-2y2*gen(3)+gen(4)
+
+// MSPOLY(G,A);
+
+-[1]=0
+
+// MSGB(G,A);
+
+-[1]=x4*gen(1)+2x2y2*gen(1)+y4*gen(2)-gen(1)
+-[2]=x2y2*gen(2)-x2y2*gen(1)
+-[3]=x4y2*gen(2)+2x2y4*gen(1)+y6*gen(2)-y2*gen(1)
+-[4]=x6y2*gen(2)+2x4y4*gen(2)+x2y6*gen(2)-x2y2*gen(1)
+
+*/
+