Changeset 4f364b in git


Ignore:
Timestamp:
Jul 23, 2002, 5:29:34 PM (22 years ago)
Author:
Mathias Schulze <mschulze@…>
Branches:
(u'spielwiese', 'd1d239e9808fca76a9497a01fa91ad4e8db6fba5')
Children:
7b55a0e38a9c0eb63e42fa62d62c5c184a1ac512
Parents:
a6e7d5259f6bf527575d6768fa2ffd0b7bbb02db
Message:
*** empty log message ***


git-svn-id: file:///usr/local/Singular/svn/trunk@6215 2c84dea3-7e68-4137-9b89-c4e89433aadc
File:
1 edited

Legend:

Unmodified
Added
Removed
  • Singular/LIB/gaussman.lib

    ra6e7d52 r4f364b  
    11///////////////////////////////////////////////////////////////////////////////
    2 version="$Id: gaussman.lib,v 1.85 2002-07-16 14:37:39 mschulze Exp $";
     2version="$Id: gaussman.lib,v 1.86 2002-07-23 15:29:34 mschulze Exp $";
    33category="Singularities";
    44
     
    373373  list l;
    374374
    375   while(size(reduce(H,std(H0*s)))>0)
     375  while(size(reduce(H,std(H0*var(1))))>0)
    376376  {
    377377    dbprint(printlevel-voice+2,"// compute matrix A of t");
     
    384384    dbprint(printlevel-voice+2,"// compute saturation of H''");
    385385    H0=H;
    386     H1=jet(module(A0*H1+s^2*diff(matrix(H1),s)),k);
    387     H=H*s+H1;
    388   }
    389 
    390   A0=A0-k*s;
     386    H1=jet(module(A0*H1+var(1)^2*diff(matrix(H1),var(1))),k);
     387    H=H*var(1)+H1;
     388  }
     389
     390  A0=A0-k*var(1);
    391391  dbprint(printlevel-voice+2,"// compute basis of saturation of H''");
    392392  H=std(H0);
    393393
    394394  dbprint(printlevel-voice+2,"// transform H'' to saturation of H''");
    395   H0=division(freemodule(mu)*s^k,H,k*deg(s))[1];
     395  H0=division(freemodule(mu)*var(1)^k,H,k*deg(var(1)))[1];
    396396
    397397  return(A0,r,H,H0,k);
     
    408408  A0=A0+C;
    409409  dbprint(printlevel-voice+2,"// transform A to saturation of H''");
    410   matrix A=division(A0*H+s^2*diff(matrix(H),s),H,(K+1)*deg(s))[1]/s;
    411 
     410  matrix A=division(A0*H+var(1)^2*diff(matrix(H),var(1)),H,
     411    (K+1)*deg(var(1)))[1]/var(1);
    412412  return(A,A0,r);
    413413}
     
    424424  dbprint(printlevel-voice+2,"// e="+string(e));
    425425  dbprint(printlevel-voice+2,"// m="+string(m));
    426 
    427426  return(e,m,A0,r);
    428427}
    429428///////////////////////////////////////////////////////////////////////////////
    430429
    431 static proc transform(matrix A,matrix A0,ideal r,module H,module H0,ideal e,intvec m,int k0,int K,int opt)
     430static proc transform(matrix A,matrix A0,ideal r,module H,module H0,ideal e,
     431  intvec m,int k0,int K,int opt)
    432432{
    433433  int mu=ncols(gmsbasis);
     
    482482
    483483  A,A0,r=tjet(A0,r,H,k0,K+k1);
    484   module U0=s^k0*freemodule(mu);
     484  module U0=var(1)^k0*freemodule(mu);
    485485
    486486  if(k>0)
     
    515515              if(d[i0]==0&&d[j0]>0)
    516516              {
    517                 A[i,j]=A[i,j]/s;
     517                A[i,j]=A[i,j]/var(1);
    518518              }
    519519              if(d[i0]>0&&d[j0]==0)
    520520              {
    521                 A[i,j]=A[i,j]*s;
     521                A[i,j]=A[i,j]*var(1);
    522522              }
    523523            }
     
    534534          {
    535535            A[i,i]=A[i,i]-1;
    536             H0[i]=H0[i]*s;
    537             U0[i]=U0[i]/s;
     536            H0[i]=H0[i]*var(1);
     537            U0[i]=U0[i]/var(1);
    538538          }
    539539          e[i0]=e[i0]-1;
     
    10611061  matrix V=inverse(U);
    10621062  A=V*A*U;
    1063   dbprint(printlevel-voice+2,"// compute normal form of H''");
     1063  dbprint(printlevel-voice+2,"// compute standard basis of H''");
    10641064  H0=std(V*H0);
    10651065  U0=U0*U;
     
    10711071  {
    10721072    j=leadexp(H0[i])[nvars(basering)+1];
    1073     a[i]=A[j,j]+ord(H0[i])/deg(s)-1;
     1073    a[i]=A[j,j]+ord(H0[i])/deg(var(1))-1;
    10741074    w[i]=v[j]+n;
    10751075  }
    10761076  kill v;
    1077   module v=simplify(jet(H*U0*H0,2*k0)/s^(2*k0),1);
     1077  module v=simplify(jet(H*U0*H0,2*k0)/var(1)^(2*k0),1);
    10781078
    10791079  kill l;
     
    11211121RETURN:
    11221122@format
    1123 list A;  C[[s]]-matrix A[1]+s*A[2] of t on H''
    1124   matrix A[1];
    1125   matrix A[2];
     1123list l=A0,A1,T,M;
     1124  matrix A0,A1;  t=A0+s*A1+s^2*(d/ds) on H'' w.r.t. C[[s]]-basis M*T
     1125  module T;  C-basis of C^mu
     1126  ideal M;  monomial C-basis of H''/sH''
    11261127@end format
    11271128KEYWORDS: singularities; Gauss-Manin connection; Brieskorn lattice;
     
    11451146  int k1=int(nmax(e)-nmin(e));
    11461147  A,A0,r,H0,U0,e,m=transform(A,A0,r,H,H0,e,m,k0,k0+k1,1);
     1148  module T=H*U0;
    11471149
    11481150  ring S=0,s,(ds,c);
    11491151  matrix A=imap(G,A);
    11501152  module H0=imap(G,H0);
     1153  module T=imap(G,T);
    11511154  ideal e=imap(G,e);
    1152   kill G,gmsmaxdeg;
    11531155
    11541156  dbprint(printlevel-voice+2,"// transform to Jordan basis");
     
    11571159  A=V*A*U;
    11581160  module H=V*H0;
     1161  T=T*U;
    11591162
    11601163  dbprint(printlevel-voice+2,"// compute splitting of V-filtration");
     
    11681171    for(j=0;j<k;j++)
    11691172    {
    1170       V=matrix(V)-(jet(A,k-j)/s^(k-j))*(jet(U,j)/s^j);
     1173      V=matrix(V)-(jet(A,k-j)/var(1)^(k-j))*(jet(U,j)/var(1)^j);
    11711174    }
    11721175    v=V[1..mu,1..mu];
    11731176    v=inverse(A0+k)*v;
    11741177    V=v[1..mu^2,1];
    1175     U=matrix(U)+s^k*V;
     1178    U=matrix(U)+var(1)^k*V;
    11761179  }
    11771180  attrib(U,"isSB",1);
     
    11791182  dbprint(printlevel-voice+2,"// transform to V-splitting basis");
    11801183  A=jet(A,0);
    1181   H=std(division(H,U,(k0+k1)*deg(s))[1]);
     1184  H=std(division(H,U,(k0+k1)*deg(var(1)))[1]);
     1185  T=T*U;
    11821186
    11831187  dbprint(printlevel-voice+2,"// compute V-leading terms of H''");
     
    11871191  {
    11881192    i0=leadexp(H1[k])[nvars(basering)+1];
    1189     j0=ord(H1[k]);//deg(s);
     1193    j0=ord(H1[k]);
    11901194    H0[k]=lead(H1[k]);
    11911195    H1[k]=H1[k]-lead(H1[k]);
     
    11931197    {
    11941198      i=leadexp(H1[k])[nvars(basering)+1];
    1195       j=ord(H1[k]);//deg(s);
     1199      j=ord(H1[k]);
    11961200      while(A[i,i]+j==A[i0,i0]+j0)
    11971201      {
     
    11991203        H1[k]=H1[k]-lead(H1[k]);
    12001204        i=leadexp(H1[k])[nvars(basering)+1];
    1201         j=ord(H1[k]);//deg(s);
     1205        j=ord(H1[k]);
    12021206      }
    12031207    }
     
    12451249      for(i=ncols(F0);i>=1;i--)
    12461250      {
    1247         F0[i]=F0[i]/s;
     1251        F0[i]=F0[i]/var(1);
    12481252      }
    12491253    }
     
    12791283  A=V*A*U;
    12801284  H=V*H;
     1285  T=T*U;
    12811286
    12821287  dbprint(printlevel-voice+2,"// compute reduced standard basis of H''");
     
    12881293  H=simplify(jet(H,k0+k1),1);
    12891294  attrib(H,"isSB",1);
    1290 
    12911295  dbprint(printlevel-voice+2,"// compute matrix A0+sA1 of t");
    1292   A=division(s*A*H+s^2*diff(matrix(H),s),H,deg(s))[1];
     1296  A=division(var(1)*A*H+var(1)^2*diff(matrix(H),var(1)),H,deg(var(1)))[1];
    12931297  A0=jet(A,0);
    1294   A=jet(A,1)/s;
     1298  A=jet(A,1)/var(1);
     1299  T=jet(T*H,2*k0)/var(1)^(2*k0);
    12951300
    12961301  setring(R);
    12971302  matrix A0=imap(S,A0);
    12981303  matrix A1=imap(S,A);
     1304  module T=imap(S,T);
     1305  ideal M=imap(G,gmsbasis);
     1306  kill G,gmsmaxdeg;
    12991307  kill S;
    1300   return(list(A0,A1));
     1308  return(list(A0,A1,T,M));
    13011309}
    13021310example
     
    13071315  print(A[1]);
    13081316  print(A[2]);
     1317  print(A[3]);
     1318  print(A[4]);
    13091319}
    13101320///////////////////////////////////////////////////////////////////////////////
Note: See TracChangeset for help on using the changeset viewer.