Changeset 1418c4 in git


Ignore:
Timestamp:
Aug 1, 2001, 2:33:41 PM (22 years ago)
Author:
Mathias Schulze <mschulze@…>
Branches:
(u'spielwiese', '91fdef05f09f54b8d58d92a472e9c4a43aa4656f')
Children:
4b6c751b1fadaa54d2622f7071de1b4113148c5f
Parents:
34a9eb1eb751113c0633d266eb927061823c9864
Message:
*mschulze: nilpotency index replaced by weight filtration index in sppairs; dbprints in sppairs


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

Legend:

Unmodified
Added
Removed

  • Singular/LIB/gaussman.lib

    r34a9eb1 r1418c4  
    11///////////////////////////////////////////////////////////////////////////////
    2 version="$Id: gaussman.lib,v 1.46 2001-07-31 17:37:43 mschulze Exp $";
     2version="$Id: gaussman.lib,v 1.47 2001-08-01 12:33:41 mschulze Exp $";
    33category="Singularities";
    44
    … …  
    359359static proc maxintdif(ideal e)
    360360{
    361   dbprint(printlevel-voice+2,"//gaussman::maxintdif");
    362361  int i,j,id;
    363362  int mid=0;
    … …  
    383382static proc maxorddif(matrix H)
    384383{
    385   dbprint(printlevel-voice+2,"//gaussman::maxorddif");
    386384  int i,j,d;
    387385  int d0,d1=-1,-1;
    … …  
    439437  def G=gmsring(f,"s");
    440438  setring G;
     439
    441440  int mu,modm=ncols(gmsbasis),maxorddif(gmsbasis);
    442441  ideal r=gmspoly*gmsbasis;
    … …  
    450449  {
    451450    k++;
    452     dbprint(printlevel-voice+2,"//gaussman::monodromy: k="+string(k));
    453     dbprint(printlevel-voice+2,"//gaussman::monodromy: compute C");
     451    dbprint(printlevel-voice+2,"// k="+string(k));
     452    dbprint(printlevel-voice+2,"// compute matrix A of t");
    454453    if(opt==0)
    455454    {
    … …  
    463462    A0=A0+C;
    464463
     464    dbprint(printlevel-voice+2,"// compute saturation of H''");
    465465    H0=H;
    466     dbprint(printlevel-voice+2,"//gaussman::monodromy: compute dH");
    467466    dH=jet(module(A0*dH+s^2*diff(matrix(dH),s)),k);
    468467    H=H*s+dH;
    469 
    470     dbprint(printlevel-voice+2,"//gaussman::monodromy: test dH==0");
    471468  }
    472469  A0=A0-k*s;
    473470
    474   dbprint(printlevel-voice+2,
    475     "//gaussman::monodromy: compute basis of saturation");
     471  dbprint(printlevel-voice+2,"// compute basis of saturation of H''");
    476472  H=std(H0);
    477473  int modH=maxorddif(H)/deg(s);
    478   dbprint(printlevel-voice+2,"//gaussman::monodromy: k="+string(modH+1));
    479   dbprint(printlevel-voice+2,"//gaussman::monodromy: compute C");
     474  dbprint(printlevel-voice+2,"// k="+string(modH+1));
     475  dbprint(printlevel-voice+2,"// compute matrix A of t");
    480476  if(opt==0)
    481477  {
    … …  
    488484  C,r=l[1..2];
    489485  A0=A0+C;
    490   dbprint(printlevel-voice+2,
    491     "//gaussman::monodromy: compute A on saturation");
     486  dbprint(printlevel-voice+2,"// transform A to saturation of H''");
    492487  l=division(H*s,A0*H+s^2*diff(matrix(H),s));
    493488  matrix A=jet(l[1],l[2],0);
    494489
    495490  dbprint(printlevel-voice+2,
    496     "//gaussman::monodromy: compute eigenvalues e and "+
    497     "multiplicities b of A");
     491    "// compute eigenvalues e with multiplicities m of A");
    498492  l=eigenval(jet(A,0));
    499   ideal e=l[1];
    500   intvec b=l[2];
    501   dbprint(printlevel-voice+2,"//gaussman::monodromy: e="+string(e));
    502   dbprint(printlevel-voice+2,"//gaussman::monodromy: b="+string(b));
     493  def e,m=l[1..2];
     494  dbprint(printlevel-voice+2,"// e="+string(e));
     495  dbprint(printlevel-voice+2,"// m="+string(m));
    503496
    504497  if(opt==0)
    … …  
    509502  }
    510503
     504  dbprint(printlevel-voice+2,"// compute maximal integer difference of e");
    511505  int mide=maxintdif(e);
     506  dbprint(printlevel-voice+2,"// mide="+string(mide));
     507
    512508  if(mide>0)
    513509  {
    514     dbprint(printlevel-voice+2,
    515       "//gaussman::monodromy: k="+string(modH+1+mide));
    516     dbprint(printlevel-voice+2,"//gaussman::monodromy: compute C");
     510    dbprint(printlevel-voice+2,"// k="+string(modH+1+mide));
     511    dbprint(printlevel-voice+2,"// compute matrix A of t");
    517512    l=gmscoeffs(r,modH+1+mide,modH+1+mide);
    518513    C,r=l[1..2];
    519514    A0=A0+C;
     515    dbprint(printlevel-voice+2,"// transform A to saturation of H''");
    520516    l=division(H*s,A0*H+s^2*diff(matrix(H),s));
    521517    A=jet(l[1],l[2],mide);
    … …  
    541537    for(j,k=ncols(e),mu;j>=1;j--)
    542538    {
    543       for(i=b[j];i>=1;i--)
     539      for(i=m[j];i>=1;i--)
    544540      {
    545541        ide[k]=ide[j];
    … …  
    550546    while(mide>0)
    551547    {
    552       dbprint(printlevel-voice+2,"//gaussman::monodromy: mide="+string(mide));
     548      dbprint(printlevel-voice+2,"// transform basis to reduce mide by 1");
    553549
    554550      A0=jet(A,0);
    … …  
    585581        }
    586582      }
     583
    587584      mide--;
     585      dbprint(printlevel-voice+2,"// mide="+string(mide));
    588586    }
    589587
    … …  
    639637
    640638  def R=basering;
     639  int n=nvars(R)-1;
    641640  def G=gmsring(f,"s");
    642641  setring G;
    643642
    644   int n=nvars(R)-1;
    645643  int mu,modm=ncols(gmsbasis),maxorddif(gmsbasis);
    646644  ideal r=gmspoly*gmsbasis;
    … …  
    650648  module H,dH=freemodule(mu),freemodule(mu);
    651649  module H0;
    652   int sdH=1;
    653650  int k=-1;
    654651  int N=n+1;
    655652
    656   while(sdH>0)
     653  while(size(reduce(H,std(H0*s)))>0)
    657654  {
    658655    k++;
    659     dbprint(printlevel-voice+2,"//gaussman::vfilt: k="+string(k));
    660     dbprint(printlevel-voice+2,"//gaussman::vfilt: compute C");
     656    dbprint(printlevel-voice+2,"// k="+string(k));
     657    dbprint(printlevel-voice+2,"// compute matrix A of t");
    661658    l=gmscoeffs(r,k);
    662659    C,r=l[1..2];
    663660    A=A+C;
    664661
     662    dbprint(printlevel-voice+2,"// compute saturation of H''");
    665663    H0=H;
    666     dbprint(printlevel-voice+2,"//gaussman::vfilt: compute dH");
    667664    dH=jet(module(A*dH+s^2*diff(matrix(dH),s)),k);
    668665    H=H*s+dH;
    669 
    670     dbprint(printlevel-voice+2,"//gaussman::vfilt: test dH==0");
    671     sdH=size(reduce(H,std(H0*s)));
    672666  }
    673667  A=A-k*s;
    674668
    675   dbprint(printlevel-voice+2,"//gaussman::vfilt: compute basis of saturation");
    676   H=minbase(H0);
     669  dbprint(printlevel-voice+2,"// compute basis of saturation of H''");
     670  H=std(H0);
    677671  int modH=maxorddif(H)/deg(s);
    678   dbprint(printlevel-voice+2,"//gaussman::monodromy: k="+string(N+modH));
    679   dbprint(printlevel-voice+2,"//gaussman::monodromy: compute C");
     672  dbprint(printlevel-voice+2,"// k="+string(N+modH));
     673  dbprint(printlevel-voice+2,"// compute matrix A of t");
    680674  l=gmscoeffs(r,N+modH,N+modH);
    681675  C,r=l[1..2];
    682676  A=A+C;
    683677
    684   dbprint(printlevel-voice+2,"//gaussman::vfilt: transform H0 to saturation");
     678  dbprint(printlevel-voice+2,"// transform H'' to saturation of H''");
    685679  l=division(H,freemodule(mu)*s^k);
    686680  H0=jet(l[1],l[2],N-1);
    687681
    688   dbprint(printlevel-voice+2,
    689     "//gaussman::vfilt: compute H0 as vector space V0");
    690   dbprint(printlevel-voice+2,
    691     "//gaussman::vfilt: compute H1 as vector space V1");
     682  dbprint(printlevel-voice+2,"// compute vector spaces");
    692683  poly p;
    693684  int i0,j0,i1,j1;
    … …  
    716707  }
    717708
    718   dbprint(printlevel-voice+2,"//gaussman::vfilt: compute A on saturation");
     709  dbprint(printlevel-voice+2,"// transform A to saturation of H''");
    719710  l=division(H*s,A*H+s^2*diff(matrix(H),s));
    720711  A=jet(l[1],l[2],N-1);
    721712
    722   dbprint(printlevel-voice+2,"//gaussman::vfilt: compute matrix M of A");
     713  dbprint(printlevel-voice+2,"// compute matrix M of A");
    723714  matrix M[mu*N][mu*N];
    724715  for(i0=mu;i0>=1;i0--)
    … …  
    746737  }
    747738
    748   dbprint(printlevel-voice+2,"//gaussman::vfilt: compute eigenvalues eA of A");
     739  dbprint(printlevel-voice+2,"// compute eigenvalues eA of A");
    749740  ideal eA=eigenval(jet(A,0))[1];
    750   dbprint(printlevel-voice+2,"//gaussman::vfilt: eA="+string(eA));
    751 
    752   dbprint(printlevel-voice+2,"//gaussman::vfilt: compute eigenvalues eM of M");
     741  dbprint(printlevel-voice+2,"// eA="+string(eA));
     742
     743  dbprint(printlevel-voice+2,"// compute eigenvalues eM of M");
    753744  ideal eM;
    754745  k=0;
    … …  
    776767    }
    777768  }
    778   dbprint(printlevel-voice+2,"//gaussman::vfilt: eM="+string(eM));
    779 
    780   dbprint(printlevel-voice+2,
    781     "//gaussman::vfilt: compute V-filtration on H0/H1");
     769  dbprint(printlevel-voice+2,"// eM="+string(eM));
     770
     771  dbprint(printlevel-voice+2,"// compute V-filtration on H''/sH''");
    782772  ideal a;
    783773  k=0;
    … …  
    789779    for(i=ncols(eM);number(eM[i])-1>number(n-1)/2;i--)
    790780    {
    791       dbprint(printlevel-voice+2,
    792         "//gaussman::vfilt: compute V["+string(i)+"]");
     781      dbprint(printlevel-voice+2,"// compute V["+string(i)+"]");
    793782      V1=module(V1)+syz(power(M-eM[i],n+1));
    794783      V[i]=interred(intersect(V1,V0));
    … …  
    802791    }
    803792
    804     dbprint(printlevel-voice+2,
    805       "//gaussman::vfilt: symmetry index found");
     793    dbprint(printlevel-voice+2,"// symmetry index found");
    806794    int j=k;
    807795
    808796    if(number(eM[i])-1==number(n-1)/2)
    809797    {
    810       dbprint(printlevel-voice+2,
    811         "//gaussman::vfilt: compute V["+string(i)+"]");
     798      dbprint(printlevel-voice+2,"// compute V["+string(i)+"]");
    812799      V1=module(V1)+syz(power(M-eM[i],n+1));
    813800      V[i]=interred(intersect(V1,V0));
    … …  
    821808    }
    822809
    823     dbprint(printlevel-voice+2,"//gaussman::vfilt: apply symmetry");
     810    dbprint(printlevel-voice+2,"// apply symmetry");
    824811    while(j>=1)
    825812    {
    … …  
    841828    for(i=ncols(eM);i>=1;i--)
    842829    {
    843       dbprint(printlevel-voice+2,
    844         "//gaussman::vfilt: compute V["+string(i)+"]");
     830      dbprint(printlevel-voice+2,"// compute V["+string(i)+"]");
    845831      V1=module(V1)+syz(power(M-eM[i],n+1));
    846832      V[i]=interred(intersect(V1,V0));
    … …  
    852838          k++;
    853839          a[k]=eM[i]-1;
    854           dbprint(printlevel-voice+2,
    855             "//gaussman::vfilt: transform to V0");
    856840          v[k]=matrix(freemodule(ncols(V[i])),mu,mu*N)*division(V0,V[i])[1];
    857841        }
    … …  
    873857          a[j]=eM[i]-1;
    874858          v[k]=v[j];
    875           dbprint(printlevel-voice+2,
    876             "//gaussman::vfilt: transform to V0");
    877859          v[j]=matrix(freemodule(ncols(V[i])),mu,mu*N)*division(V0,V[i])[1];
    878860          j--;
    … …  
    881863    }
    882864
    883     dbprint(printlevel-voice+2,"//gaussman::vfilt: compute graded parts");
     865    dbprint(printlevel-voice+2,"// compute graded parts");
    884866    for(k=1;k<size(v);k++)
    885867    {
    … …  
    960942  }
    961943
    962   dbprint(printlevel-voice+2,
    963     "//gaussman::endfilt: compute multiplication in Jacobian algebra");
     944  dbprint(printlevel-voice+2,"// compute multiplication in Jacobian algebra");
    964945  list M;
    965946  matrix U=freemodule(ncols(m));
    … …  
    979960  while(b0<number(a[ncols(a)]-a[1]))
    980961  {
    981     dbprint(printlevel-voice+2,
    982       "//gaussman::endfilt: find next possible index");
     962    dbprint(printlevel-voice+2,"// find next possible index");
    983963    b1=number(a[ncols(a)]-a[1]);
    984964    for(j=ncols(a);j>=1;j--)
    … …  
    1008988    }
    1009989
    1010     dbprint(printlevel-voice+2,
    1011       "//gaussman::endfilt: collect conditions for V1["+string(b0)+"]");
     990    dbprint(printlevel-voice+2,"// collect conditions for V1["+string(b0)+"]");
    1012991    j=ncols(a);
    1013992    j0=mu;
    … …  
    10381017    }
    10391018
    1040     dbprint(printlevel-voice+2,
    1041       "//gaussman::endfilt: compose condition matrix");
     1019    dbprint(printlevel-voice+2,"// compose condition matrix");
    10421020    L=transpose(module(l[1]));
    10431021    for(k=2;k<=ncols(m);k++)
    … …  
    10461024    }
    10471025
    1048     dbprint(printlevel-voice+2,
    1049       "//gaussman::endfilt: compute kernel of condition matrix");
     1026    dbprint(printlevel-voice+2,"// compute kernel of condition matrix");
    10501027    v0=v0+list(syz(L));
    10511028    a0=a0,b0;
    10521029  }
    10531030
    1054   dbprint(printlevel-voice+2,"//gaussman::endfilt: compute graded parts");
     1031  dbprint(printlevel-voice+2,"// compute graded parts");
    10551032  option(redSB);
    10561033  for(i=1;i<size(v0);i++)
    … …  
    10601037  }
    10611038
    1062   dbprint(printlevel-voice+2,
    1063     "//gaussman::endfilt: remove trivial graded parts");
     1039  dbprint(printlevel-voice+2,"// remove trivial graded parts");
    10641040  i=1;
    10651041  while(size(v0[i])==0)
    … …  
    11301106list Spp: spectral pairs of f
    11311107  ideal Spp[1]: spectral numbers in increasing order
    1132   intvec Spp[2]: corresponding nilpotency indices in increasing order
     1108  intvec Spp[2]: corresponding weight filtration indices in increasing order
    11331109  intvec Spp[3]: corresponding multiplicities of spectral pairs
    11341110default: opt=1
    … …  
    11531129  def G=gmsring(f,"s");
    11541130  setring(G);
     1131
    11551132  int mu,modm=ncols(gmsbasis),maxorddif(gmsbasis);
    11561133  ideal r=gmspoly*gmsbasis;
    … …  
    11641141  {
    11651142    k++;
     1143    dbprint(printlevel-voice+2,"// k="+string(k));
     1144    dbprint(printlevel-voice+2,"// compute matrix A of t");
    11661145    l=gmscoeffs(r,k,mu+n);
    11671146    C,r=l[1..2];
    11681147    A0=A0+C;
     1148
     1149    dbprint(printlevel-voice+2,"// compute saturation of H''");
    11691150    H0=H;
    11701151    dH=jet(module(A0*dH+s^2*diff(matrix(dH),s)),k);
    … …  
    11731154  A0=A0-k*s;
    11741155
     1156  dbprint(printlevel-voice+2,"// compute basis of saturation of H''");
    11751157  H=std(H0);
    11761158  int modH=maxorddif(H)/deg(s);
     1159  dbprint(printlevel-voice+2,"// transform H'' to saturation of H''");
    11771160  l=division(H,freemodule(mu)*s^k);
    11781161  H0=l[1];
     1162
     1163  dbprint(printlevel-voice+2,"// k="+string(modH+1));
     1164  dbprint(printlevel-voice+2,"// compute matrix A of t");
    11791165  l=gmscoeffs(r,modH+1,modH+1+n);
    11801166  C,r=l[1..2];
    11811167  A0=A0+C;
     1168  dbprint(printlevel-voice+2,"// transform A to saturation of H''");
    11821169  l=division(H*s,A0*H+s^2*diff(matrix(H),s));
    11831170  matrix A=jet(l[1],l[2],0);
    … …  
    11871174  if(!opt)
    11881175  {
    1189     U=jordanbasis(A);
     1176    dbprint(printlevel-voice+2,"// transform to Jordan basis");
     1177    U=jordanbasis(A)[1];
    11901178    V=lift(U,freemodule(mu));
    11911179    A=V*A*U;
     1180    dbprint(printlevel-voice+2,"// compute normal form of H''");
    11921181    H0=std(V*H0);
     1182
     1183    dbprint(printlevel-voice+2,"// compute spectral numbers");
    11931184    ideal a;
    11941185    for(i=1;i<=mu;i++)
    … …  
    11971188      a[i]=A[j,j]+deg(lead(H0[i]))/deg(s)-1;
    11981189    }
     1190
    11991191    setring(R);
    12001192    return(spgen(imap(G,a)));
    12011193  }
    12021194
     1195  dbprint(printlevel-voice+2,
     1196    "// compute eigenvalues e with multiplicities m of A");
    12031197  l=eigenval(A);
    1204   def e,b=l[1..2];
     1198  def e,m=l[1..2];
     1199  dbprint(printlevel-voice+2,"// e="+string(e));
     1200  dbprint(printlevel-voice+2,"// m="+string(m));
     1201  dbprint(printlevel-voice+2,"// compute maximal integer difference of e");
    12051202  int mide=maxintdif(e);
     1203  dbprint(printlevel-voice+2,"// mide="+string(mide));
     1204
    12061205  if(mide>0)
    12071206  {
     1207    dbprint(printlevel-voice+2,"// k="+string(modH+1+mide));
     1208    dbprint(printlevel-voice+2,"// compute matrix A of t");
    12081209    l=gmscoeffs(r,modH+1+mide,modH+1+mide);
    12091210    C,r=l[1..2];
    12101211    A0=A0+C;
     1212    dbprint(printlevel-voice+2,"// transform A to saturation of H''");
    12111213    l=division(H*s,A0*H+s^2*diff(matrix(H),s));
    12121214    A=jet(l[1],l[2],mide);
    … …  
    12311233    for(j,k=ncols(e),mu;j>=1;j--)
    12321234    {
    1233       for(i=b[j];i>=1;i--)
     1235      for(i=m[j];i>=1;i--)
    12341236      {
    12351237        ide[k]=ide[j];
    … …  
    12401242    while(mide>0)
    12411243    {
     1244      dbprint(printlevel-voice+2,"// transform to separate eigenvalues");
    12421245      A0=jet(A,0);
    12431246      U=0;
    … …  
    12501253      H0=V*H0;
    12511254
     1255      dbprint(printlevel-voice+2,"// transform to reduce mide by 1");
    12521256      for(i=mu;i>=1;i--)
    12531257      {
    … …  
    12781282      }
    12791283      H0=transpose(H0);
     1284
    12801285      mide--;
     1286      dbprint(printlevel-voice+2,"// mide="+string(mide));
    12811287    }
    12821288
    … …  
    12841290  }
    12851291
    1286   U=jordanbasis(A);
     1292  dbprint(printlevel-voice+2,"// transform to Jordan basis");
     1293  intvec w0;
     1294  l=jordanbasis(A);
     1295  U,w0=l[1..2];
    12871296  V=lift(U,freemodule(mu));
    12881297  A0=V*A*U;
    12891298
    1290   intvec w;
    1291   w[mu]=1;
    1292   j=1;
    1293   for(i=mu-1;i>=1;i--)
    1294   {
    1295     j++;
    1296     if(A0[i,i+1]==0)
    1297     {
    1298       j=1;
    1299     }
    1300     w[i]=j;
    1301   }
    1302 
     1299  dbprint(printlevel-voice+2,"// compute weight filtration basis");
    13031300  vector u;
    1304   for(i=1;i<ncols(A);i++)
     1301  i=1;
     1302  while(i<ncols(A))
    13051303  {
    13061304    j=i+1;
    13071305    while(j<ncols(A)&&A[i,i]==A[j,j])
    13081306    {
    1309       if(w[i]<w[j])
    1310       {
    1311         k=w[i];
    1312         w[i]=w[j];
    1313         w[i]=k;
     1307      if(w0[i]>w0[j])
     1308      {
     1309        k=w0[i];
     1310        w0[i]=w0[j];
     1311        w0[i]=k;
    13141312        u=U[i];
    13151313        U[i]=U[j];
    … …  
    13181316      j++;
    13191317    }
    1320   }
    1321 
     1318    if(j==ncols(A)&&A[i,i]==A[j,j]&&w0[i]>w0[j])
     1319    {
     1320      k=w0[i];
     1321      w0[i]=w0[j];
     1322      w0[i]=k;
     1323      u=U[i];
     1324      U[i]=U[j];
     1325      U[j]=u;
     1326    }
     1327    i=j;
     1328  }
     1329
     1330  dbprint(printlevel-voice+2,"// transform to weight filtration basis");
    13221331  V=lift(U,freemodule(mu));
    13231332  A=V*A*U;
     1333  dbprint(printlevel-voice+2,"// compute normal form of H''");
    13241334  H0=std(V*H0);
     1335
     1336  dbprint(printlevel-voice+2,"// compute spectral pairs");
    13251337  ideal a;
     1338  intvec w;
    13261339  for(i=1;i<=mu;i++)
    13271340  {
    13281341    j=leadexp(H0[i])[nvars(basering)+1];
    13291342    a[i]=A[j,j]+deg(lead(H0[i]))/deg(s)-1;
     1343    w[i]=w0[j]+n;
    13301344  }
    13311345  setring(R);
    … …  
    13531367  ideal a0=jet(a,0);
    13541368  int i,j;
    1355   number n;
     1369  poly p;
    13561370  for(i=1;i<=ncols(a0);i++)
    13571371  {
    … …  
    13601374      if(number(a0[i])>number(a0[j]))
    13611375      {
    1362         n=a0[i];
     1376        p=a0[i];
    13631377        a0[i]=a0[j];
    1364         a0[j]=n;
     1378        a0[j]=p;
    13651379      }
    13661380    }
    … …  
    14071421  intvec w0=w;
    14081422  int i,j,k;
    1409   number n;
     1423  poly p;
    14101424  for(i=1;i<=ncols(a0);i++)
    14111425  {
    … …  
    14141428      if(number(a0[i])>number(a0[j])||a0[i]==a0[j]&&w0[i]>w0[j])
    14151429      {
    1416         n=a0[i];
     1430        p=a0[i];
    14171431        a0[i]=a0[j];
    1418         a0[j]=n;
     1432        a0[j]=p;
    14191433        k=w0[i];
    14201434        w0[i]=w0[j];
Note: See TracChangeset for help on using the changeset viewer.