Changeset 670b30 in git

Timestamp:

Sep 20, 2016, 2:56:17 PM (8 years ago)

Author:

Hans Schoenemann <hannes@…>

Branches:

(u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')

Children:

a97bfe477e8180255c6c6d799daf426b583ef490

Parents:

42f8ecb28b8f9585dce0eaa92b2d9aaf26288bac

Message:

G.Pfister: add classifyMapGerms.lib, add to classify_aeq.lib

Location:

Singular

Files:

• LIB/classifyMapGerms.lib (added)
• LIB/classify_aeq.lib (modified) (3 diffs)
• singular-libs (modified) (1 diff)

Singular/LIB/classify_aeq.lib

@@ -1 +1 @@
 ///////////////////////////////////////////////////////////////////////////////
-version="version classify_aeq.lib 4.0.0.0 Jun_2013 "; // $Id$
+version="version classify_aeq.lib 4.0.3.2 Sep_2016 "; // $Id$
 category="Singularities";
 info="
@@ -25 +25 @@
   [5] Ishikawa,G; Janeczko,S.: The Complex Symplectic Moduli Spaces of Unimodal Parametric Plane Curve  NEU Singularities. Insitute of Mathematics of the Polish Academy of Sciences,Preprint 664(2006)
 PROCEDURES:
-          sagbiAlg(G);    Compute the Sagbi-basis of the Algebra.
-          sagbiMod(I,A);  Compute the Sagbi- basis of the Module.
-          semiGroup(G);   Compute the Semi-Group of the Algebra provided the input is Sagbi Bases of the Algebra.
-          semiMod(I,A);   Compute the Semi-Module provided that the input are the Sagbi Bases of the Algebra resp.Module.
-          planeCur(I);    Compute the type of the Simple Plane Curve singularity.
-          spaceCur(I);    Compute the type of the simple Space Curve singularity.
+  sagbiAlg(G);    Compute the Sagbi-basis of the Algebra.
+  sagbiMod(I,A);  Compute the Sagbi- basis of the Module.
+  semiGroup(G);   Compute the Semi-Group of the Algebra provided the input is Sagbi Bases of the Algebra.
+  semiMod(I,A);   Compute the Semi-Module provided that the input are the Sagbi Bases of the Algebra resp.Module.
+  planeCur(I);    Compute the type of the Simple Plane Curve singularity.
+  spaceCur(I);    Compute the type of the simple Space Curve singularity.
+  inVar(I);       computes for the parametrization defined by Is
+                  semi group, semi module of differentials,
+                  Zariski number and moduli
+  normalForm(I);  computes for the parametrization defined by I
+                  normal form, semi group, semi module of differentials,
+                  Zariski number and moduli
 ";
 LIB "algebra.lib";
@@ -1921 +1927 @@
    return(K);
 }
+
+proc inVar(ideal I)
+"USAGE:   inVar(I);  I=ideal, I=<x(t),y(t)>, ord(x(t))=n<ord(y(t))=m,
+          n does not divide m
+COMPUTE:  for the parametrization defined by I semi group, semi module
+          of differentials, Zariski number and moduli
+RETURN:  a list L with 5 entries
+   L[1] the semi group Gamma
+   L[2] the semi module Lambda
+   L[3] 0 if Lambda=Gamma or lambda=min(Lambda-Gamma) -n, the Zariski number
+   L[4] the integers i, i>lambda, i+n not in Lambda, 0 if this set is empty
+   L[5] 0 or the smallest integer i, i not in Gamma, i+m-n not in Gamma
+        i-lambda not in Gamma but i+n in Lambda
+EXAMPLE:  example inVar; shows an example"
+{
+   ideal G=sagbiAlg(I);
+   ideal M=diff(I,t);
+   ideal K=sagbiMod(M,G);
+   list L=semiMod(K,G);
+   intvec v=L[3];   //semi group Gamma
+   intvec w=L[6]+1;
+   w=0,w;           //semin module Lambda
+   intvec mo;
+   int i,l,k;
+   l=-1;
+   int n=ord(G[1]);
+   int m=ord(G[2]);
+   for(i=1;i<=size(w);i++)
+   {
+      if(v[i]!=w[i])
+      {
+         l=w[i]-v[2];  //lambda
+         break;
+      }
+   }
+   if(i==size(w)+1)
+   {
+      for(k=i;k<=size(v);k++)
+      {
+         if(v[k]!=w[i-1]+k-i+1)
+         {
+            l=w[i-1]+k-i+1-v[2];  //lambda
+            break;
+         }
+      }
+   }
+
+   if(l==-1){return(-1);}
+   for(i=l+1;i<=w[size(w)]-n;i++)
+   {
+       if(!ivec(i+n,w))
+       {
+          mo=mo,i;       //i+n not in Lambda
+       }
+   }
+   if(size(mo)>1){mo=mo[2..size(mo)];}
+   for(i=l+1;i<=v[size(v)]-1;i++)
+   {
+       if(!ivec(i,v)&&!ivec(i+n-m,v)&&ivec(i+n,w)&&(i<mo[size(mo)]))
+       {
+          return(list(v,w,l,mo,i));
+       }
+   }
+   return(list(v,w,l,mo,0));
+}
+example
+{
+ "EXAMPLE"; echo=2;
+  ring r=0,t,Ds;
+  ideal I=t6+3t7,t8+t13+t19;
+  inVar(I);
+}
+
+static proc ivec(int a, intvec v)
+{
+   int i;
+   if(a>=v[size(v)]){return(a);}
+   for(i=1;i<=size(v);i++)
+   {
+      if(a==v[i]){return(i);}
+   }
+   return(0);
+}
+
+proc normalMap(ideal I, int bound)
+{
+// returns (t^n,h) A-equivalent to I modulo <t>^bound+1
+
+   I=jet(I,bound);
+   def R=basering;
+   map phi;
+   poly p;
+   if(ord(I[1])>ord(I[2])){p=I[1];I[1]=I[2];I[2]=p;}
+   I[1]=simplify(I[1],1);
+   int n=ord(I[1]);
+   phi=R,var(1)-1/number(n)*I[1][2]/var(1)^(n-1);
+   I=phi(I);
+   while(size(I[1])>1)
+   {
+      phi=R,var(1)-1/number(n)*I[1][2]/var(1)^(n-1);
+
+      I=jet(phi(I),bound);
+   }
+   I[2]=simplify(I[2],1);
+   p=lead(I[2])+reduc(I[2]-lead(I[2]),I,bound);
+   I[2]=p;
+   return(I);
+}
+
+static proc reduc(poly f,ideal I, int b)
+{
+// computes the normal form of f with respect to the algebra generated by I
+   list L=1;
+   map psi;
+   f=jet(f,b);
+   if(f==0){return(f);}
+   while((f!=0) && (L[1]!=0))
+   {
+     L= algebra_containment(lead(f),lead(I),1);
+     if (L[1]==1)
+     {
+        def S= L[2];
+        psi= S,maxideal(1),I;
+        f=jet(f-psi(check),b);
+        kill S;
+     }
+   }
+   return (lead(f)+reduc(f-lead(f),I,b));
+}
+
+proc normalForm(ideal I, list #)
+"USAGE:   normalForm(I), I=<x(t),y(t)> an ideal, # optional, a bound for the
+          conductor
+COMPUTE:  computes the Hefez-Hernandez normal form of the ideal I=<x(t),y(t)>
+RETURN:  a list L with 5 entries
+   L[1] the Hefei-Hernandez normal form of the ideal I=<x(t),y(t)>
+   L[2] the semi group Gamma
+   L[3] the semi module Lambda
+   L[4] 0 if Lambda=Gamma or lambda=min(Lambda-Gamma) -n, the Zariski number
+   L[5] the integers i, i>lambda, i+n not in Lambda, 0 if this set is empty
+EXAMPLE:  example normalForm; shows an example"
+{
+   int b,i,l,k;
+   poly p;
+   map phi;
+   def R=basering;
+   if(size(#)>0)
+   {
+      b=#[1];
+      ideal G=sagbiAlg(I,b);
+   }
+   else
+   {
+      ideal G=sagbiAlg(I);
+   }
+   ideal M=diff(I,t);
+   ideal K=sagbiMod(M,G);
+   list L=semiMod(K,G);
+   intvec v=L[3];   //semi group Gamma
+   intvec w=L[6]+1;
+   w=0,w;           //semi module Lambda
+   b=v[size(v)]+1;
+   I=normalMap(I,b);
+   int n=ord(I[1]);
+   int m=ord(I[2]);
+   poly g;
+   if(v==w){return(list(ideal(var(1)^n,var(1)^m),v,w,0,0));}
+   for(i=1;i<=size(w);i++)
+   {
+      if(v[i]!=w[i])
+      {
+         l=w[i]-v[2];  //lambda
+         break;
+      }
+   }
+   if(i==size(w)+1)
+   {
+      for(k=i;k<=size(v);k++)
+      {
+         if(v[k]!=w[i-1]+k-i+1)
+         {
+            l=w[i-1]+k-i+1-v[2];  //lambda
+            break;
+         }
+      }
+   }
+   intvec moduli;
+   for(i=l+1;i<=w[size(w)]-n;i++)
+   {
+       if(!ivec(i+n,w))
+       {
+          moduli=moduli,i;       //i+n not in Lambda
+       }
+   }
+   if(size(moduli)>1){moduli=moduli[2..size(moduli)];}
+   int momax=moduli[size(moduli)];
+   if(momax==0){momax=l;}
+   b=momax;
+   i=1;
+   while(i<b)
+   {
+      i++;
+      k=ord(I[2][i]);
+      if(k==-1){break;}
+      if(k==l){i++;k=ord(I[2][i]);}
+      if(k>b){return(list(jet(I,b),v,w,l,moduli));}
+      if(ivec(k,v))                //k is in Gamma
+      {
+        I[2]=lead(I[2])+reduc(I[2]-lead(I[2]),G,b);
+        i--;
+      }
+      else
+      {
+         if(ivec(k+n-m,v))         //k+n-m is in Gamma
+         {
+            phi=R,var(1)-1/number(m)*I[2][i]/var(1)^(m-1);
+            I=phi(I);
+            I[1]=lead(I[1])+reduc(I[1]-lead(I[1]),G,b);
+            I=normalMap(I,b);
+            i--;
+         }
+         else
+         {
+            if(ivec(k+n,w))         //k+n is in Lambda
+            {
+               g=findTrafo(I,i);
+               g=jet(g,b-m+1);
+               phi=R,g;
+               I=phi(I);
+               I[1]=lead(I[1])+reduc(I[1]-lead(I[1]),G,b);
+               I[2]=lead(I[2])+reduc(I[2]-lead(I[2]),G,b);
+               I=normalMap(I,b);
+               i--;
+            }
+         }
+      }
+      G=sagbiAlg(I,b);
+   }
+   return(list(I,v,w,l,moduli));
+}
+example
+{
+ "EXAMPLE"; echo=2;
+  ring r=0,t,Ds;
+  ideal I=t6+3t7,t8+t13+t19;
+  normalForm(I);
+}
+
+static proc findTrafo(ideal I, int i)
+{
+//I[2][i]=a*t^k, I[1]=x{t}=t^n, I[2]=y(t)=t^m+c*t^lambda+...+a*t^k+...
+//find the map to kill the term a*t^k of y(t) for k+n in Lambda
+//find g,h such that a*t^k*x'(t)=h(x(t),y(t))*x'(t)-g(x(t),y(t))*y'(t) mod t^(k+n)
+//return the map t---> t+g(x(t),y(t))/x'(t) mod t^(k+1)
+
+   def R0=basering;
+   int p=char(R0);
+   int k=ord(I[2][i]);
+   int n=ord(I[1]);
+   int m=ord(I[2]);
+   poly f=I[2][i]*diff(I[1],var(1));
+   ring R=p,var(1),dp;
+   ideal I=imap(R0,I);
+   poly f=imap(R0,f);
+   ideal Q=std(ideal(var(1)*f));
+   qring T=Q;
+   ideal I=imap(R,I);
+   poly f=imap(R,f);
+   ring S=p,(@z,@u,@v,@x,@y),(dp(1),dp(2),dp(2));
+   setring T;
+   map psi=S,f,diff(I[1],var(1)),diff(I[2],var(1)),I[1],I[2];
+   setring S;
+   ideal J=kernel(T,psi);
+   option(redSB);
+   J=std(J);
+   //we look for an element @z-@u*h(@x,@y)-@v*g(@x,@y) in J
+   for(i=1;i<=ncols(J);i++)
+   {
+      if((@z*diff(J[i],@z)+@u*diff(J[i],@u)+@v*diff(J[i],@v)==J[i])&&(deg(diff(J[i],@z))==0))
+      {
+         poly f=J[i]/(-diff(J[i],@z)); //the element is in the standard basis
+         break;
+      }
+   }
+   poly g;
+   if(i==ncols(J)+1)
+   {
+      //the last element in the standard basis is of type @z-@u*h(@x,@y)-@v*g(@x,@y)+k(@x,@y)
+      //we have to kill k(@x,@y) using the other standard basis elements
+      poly f=J[i-1];
+      ideal K;
+      for(i=1;i<ncols(J);i++)
+      {
+          g=lead(J[i]);
+          if(((g==diff(g,@u)*@u)&&(diff(g,@v)==0))||((g==diff(g,@v)*@v)&&(diff(g,@u)==0)))
+          {
+             K[size(K)+1]=J[i];
+          }
+      }
+      ring S1=p,(@z,@u,@v,@x,@y),(a(-1,-1,-1,0,0),dp(1),dp(2),dp(2));
+      ideal K=imap(S,K);
+      attrib(K,"isSB",1);
+      poly f=imap(S,f);
+      f=reduce(f,K);
+      setring S;
+      f=imap(S1,f);
+      f=f/(-diff(f,@z));  //f=@z-@u*h(@x,@y)-@v*g(@x,@y)
+   }
+   matrix M=coef(f,@v);
+   g=M[2,1];
+   setring T;
+   poly g=psi(g);
+   setring R0;
+   poly g=imap(T,g);
+   g=g/diff(I[1],var(1));
+   return(var(1)-g);
+}
+
+//============================ Examples========================
+/*
+  ring r=0,t,(c,ds);
+  ideal I=t4+t7,t6+t7;
+  normalForm(I);
+
+  ring r=0,t,(c,ds);
+  ideal I=t4+t7+t9,t6+t11;
+  normalForm(I);
+
+  ring r=0,t,(c,ds);
+  ideal I=t4+t5,t9+t10;
+  normalForm(I);
+
+  ring r=0,t,Ds;
+  ideal I=t6+3t7,t8+t13+t19;
+  normalForm(I);
+
+  ring r=32003,t,Ds;
+  ideal I=t8,t12+3t15+7t19;
+  normalForm(I);
+*/
 ////////////////////////////////////////////////////////////////////////////////
 /*

Singular/singular-libs

@@ -52 +52 @@
         schubert.lib tasks.lib tropical.lib hdepth.lib gradedModules.lib \
         arr.lib brillnoether.lib chern.lib cimonom.lib GND.lib \
-        graal.lib hess.lib modwalk.lib rwalk.lib swalk.lib
+        graal.lib hess.lib modwalk.lib rwalk.lib swalk.lib \
+        claasifyMapGerms.lib
 
 PLIBS = bimodules.lib bfun.lib central.lib dmod.lib dmodapp.lib dmodvar.lib\