Changeset cc3a04 in git


Ignore:
Timestamp:
Dec 21, 2000, 7:05:53 PM (22 years ago)
Author:
Mathias Schulze <mschulze@…>
Branches:
(u'spielwiese', '0d6b7fcd9813a1ca1ed4220cfa2b104b97a0a003')
Children:
8a87a6b98e5b111b6f0b8118be4369ea7ec4089e
Parents:
19df79cae9ee20cd44dcdef39057b9bb94b3dc3c
Message:
*** empty log message ***


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

Legend:

Unmodified
Added
Removed

  • Singular/LIB/gaussman.lib

    r19df79 rcc3a04  
    11///////////////////////////////////////////////////////////////////////////////
    22
    3 version="$Id: gaussman.lib,v 1.16 2000-12-19 15:05:25 anne Exp $";
     3version="$Id: gaussman.lib,v 1.17 2000-12-21 18:05:53 mschulze Exp $";
    44category="Singularities";
    55info="
    … …  
    88AUTHOR:   Mathias Schulze, email: mschulze@mathematik.uni-kl.de
    99
     10OVERVIEW: A library to compute invariants related to the Gauss-Manin connection
     11          of a an isolated hypersurface singularity.
     12
    1013PROCEDURES:
    11  monomat   monodromy matrix
    12  monospec  spectrum of monodromy
    13  vfilt     V-filtration on H''/H'
    14  singspec  singularity spectrum
    15  vjacob    V-filtration on Jacobian algebra
    16  gamma     Hertling's gamma invariant
    17  gamma4    Hertling's gamma4 invariant
     14 monodromy(f[,...]);    monodromy matrix of f, spectrum of monodromy of f
     15 vfiltration(f[,...]);  V-filtration of f on H''/H', singularity spectrum of f
     16 vfiltjacalg(...);      V-filtration on Jacobian algebra
     17 gamma(...);            Hertling's gamma invariant
     18 gamma4(...);           Hertling's gamma4 invariant
     19
     20SEE ALSO: mondromy.lib, spectrum.lib, jordan.lib
     21KEYWORDS: singularities; Gauss-Manin connection; monodromy; spectrum;
     22          Brieskorn lattice; Hodge filtration; V-filtration;
    1823";
    1924
    … …  
    136141///////////////////////////////////////////////////////////////////////////////
    137142
    138 proc monomat(poly f,list #)
    139 "USAGE:   <matrix> M=monomat(<poly> f);
    140 ASSUME:  f isolated singularity
    141 RETURN:  exp(-2*pi*i*M) is a monodromy matrix
    142 EXAMPLE: example monomat; shows an example
     143proc monodromy(poly f,list #)
     144"USAGE:    monodromy(f[,mode]); poly f, int mode[=1]
     145ASSUME:   local ordering, f isolated singularity at 0
     146RETURN:   if mode=0 :
     147            matrix M : exp(-2*pi*i*M) monodromy matrix of f
     148          if mode=1 :
     149            ideal e : exp(-2*pi*i*e) spectrum of monodromy of f
     150SEE ALSO: monodromy.lib, jordan.lib
     151KEYWORDS: singularities; Gauss-Manin connection; monodromy;
     152          Brieskorn lattice
     153EXAMPLE:  example monodromy; shows an example
    143154"
    144155{
    145   int mide=-1;
     156  int mode=1;
    146157  if(size(#)>0)
    147158  {
    148     mide=0;
     159    if(typeof(#[1])=="int")
     160    {
     161      mode=#[1];
     162    }
    149163  }
    150164
    … …  
    155169    if(var(i)>1)
    156170    {
    157       ERROR("basering not local");
     171      ERROR("no local ordering");
    158172    }
    159173  }
    … …  
    164178    if(vdim(sJ)==0)
    165179    {
    166       ERROR("singularity not singular");
     180      ERROR("no singularity at 0");
    167181    }
    168182    else
    169183    {
    170       ERROR("singularity not isolated");
     184      ERROR("no isolated singularity at 0");
    171185    }
    172186  }
    … …  
    182196  int sdH=1;
    183197  int k=-1;
    184   int K,N;
     198  int K,N,mide;
    185199
    186200  while(k<K||sdH>0)
    187201  {
    188202    k++;
    189     dbprint(printlevel-voice+2,"//gaussman::monomat: k="+string(k));
    190 
    191     dbprint(printlevel-voice+2,"//gaussman::monomat: compute C");
     203    dbprint(printlevel-voice+2,"//gaussman::monodromy: k="+string(k));
     204
     205    dbprint(printlevel-voice+2,"//gaussman::monodromy: compute C");
    192206    C=coeffs(redNF(w,sJ,U),m);
    193207    A0=A0+C*var(1)^k;
    … …  
    196210    {
    197211      H0=H;
    198       dbprint(printlevel-voice+2,"//gaussman::monomat: compute dH");
     212      dbprint(printlevel-voice+2,"//gaussman::monodromy: compute dH");
    199213      dH=jet(module(A0*dH+var(1)^2*diff(matrix(dH),var(1))),k);
    200214      H=H*var(1)+dH;
    201215
    202       dbprint(printlevel-voice+2,"//gaussman::monomat: test dH==0");
     216      dbprint(printlevel-voice+2,"//gaussman::monodromy: test dH==0");
    203217      sdH=size(reduce(H,std(H0*var(1))));
    204218      if(sdH>0)
    … …  
    209223      {
    210224        dbprint(printlevel-voice+2,
    211           "//gaussman::monomat: compute basis of saturation");
     225          "//gaussman::monodromy: compute basis of saturation");
    212226        H=minbase(H0);
    213227        int modH=maxorddif(H);
    … …  
    220234      N=k-modH;
    221235      dbprint(printlevel-voice+2,
    222         "//gaussman::monomat: compute A on saturation");
     236        "//gaussman::monodromy: compute A on saturation");
    223237      l=division(H*var(1),A0*H+var(1)^2*diff(matrix(H),var(1)));
    224238      A=expand(l[1],l[2],N-1);
    225       if(mide<0)
    226       {
    227         dbprint(printlevel-voice+2,
    228           "//gaussman::monomat: compute eigenvalues e of A");
    229         ideal e=jordan(A,-1)[1];
    230         dbprint(printlevel-voice+2,"//gaussman::monomat: e="+string(e));
     239      dbprint(printlevel-voice+2,
     240        "//gaussman::monodromy: compute eigenvalues e of A");
     241      ideal e=jordan(A,-1)[1];
     242      dbprint(printlevel-voice+2,"//gaussman::monodromy: e="+string(e));
     243      if(mode==1)
     244      {
    231245        mide=maxintdif(e);
    232246        K=K+mide;
    … …  
    236250    if(k<K||sdH>0)
    237251    {
    238       dbprint(printlevel-voice+2,"//gaussman::monomat: divide by J");
     252      dbprint(printlevel-voice+2,"//gaussman::monodromy: divide by J");
    239253      l=division(J,ideal(matrix(w)-matrix(m)*C*U));
    240254      D=l[1];
    241255
    242       dbprint(printlevel-voice+2,"//gaussman::monomat: compute w/U");
     256      dbprint(printlevel-voice+2,"//gaussman::monodromy: compute w/U");
    243257      for(j=mu;j>=1;j--)
    244258      {
    … …  
    246260        {
    247261          dbprint(printlevel-voice+2,
    248             "//gaussman::monomat: compute U["+string(j)+"]");
     262            "//gaussman::monodromy: compute U["+string(j)+"]");
    249263          U[j,j]=U[j,j]*l[2][j,j];
    250264        }
    251265        dbprint(printlevel-voice+2,
    252           "//gaussman::monomat: compute w["+string(j)+"]");
     266          "//gaussman::monodromy: compute w["+string(j)+"]");
    253267        w[j]=0;
    254268        for(i=n+1;i>=1;i--)
    … …  
    263277  while(mide>0)
    264278  {
    265     dbprint(printlevel-voice+2,"//gaussman::monomat: mide="+string(mide));
     279    dbprint(printlevel-voice+2,"//gaussman::monodromy: mide="+string(mide));
    266280
    267281    intvec b;
    … …  
    334348  }
    335349
    336   return(jet(A,0));
     350  if(mode==1)
     351  {
     352    return(jet(A,0));
     353  }
     354  else
     355  {
     356    return(e);
     357  }
    337358}
    338359example
    … …  
    340361  ring R=0,(x,y),ds;
    341362  poly f=x5+x2y2+y5;
    342   matrix M=monomat(f);
     363  matrix M=monodromy(f);
    343364  print(M);
    344365}
    345366///////////////////////////////////////////////////////////////////////////////
    346367
    347 proc monospec(poly f)
    348 "USAGE:   <matrix> M=monospec(<poly> f);
    349 ASSUME:  f isolated singularity
    350 RETURN:  the spectrum of exp(-2*pi*i*M) is the spectrum of monodromy
    351 EXAMPLE: example monospec; shows an example
     368proc vfiltration(poly f,list #)
     369"USAGE:    vfiltration(f[,mode]); poly f, int mode[=1]
     370ASSUME:   local ordering, f isolated singularity at 0
     371RETURN:   list l :
     372          if mode=0 or mode=1 :
     373            ideal l[1] : spectral numbers in increasing order
     374            intvec l[2] :
     375              int l[2][i] : multiplicity of spectral number l[1][i]
     376          if mode=1 :
     377            list l[3] :
     378              module l[3][i] : vector space basis of l[1][i]-th graded part
     379                               of the V-filtration on H''/H' in terms of l[4]
     380            ideal l[4] : monomial vector space basis of H''/H'
     381            ideal l[5] : standard basis of Jacobian ideal
     382NOTE:     H' and H'' denote Brieskorn lattices
     383SEE ALSO: spectrum.lib
     384KEYWORDS: singularities; Gauss-Manin connection; spectrum;
     385          Brieskorn lattice; Hodge filtration; V-filtration;
     386EXAMPLE:  example vfiltration; shows an example
    352387"
    353388{
    354   return(monomat(f,0));
    355 }
    356 example
    357 { "EXAMPLE:"; echo=2;
    358   ring R=0,(x,y),ds;
    359   poly f=x5+x2y2+y5;
    360   matrix M=monospec(f);
    361   print(M);
    362 }
    363 ///////////////////////////////////////////////////////////////////////////////
    364 
    365 proc vfilt(poly f,list #)
    366 "USAGE:   <list> l=vfilt(<poly> f);
    367 ASSUME:  f isolated singularity
    368 RETURN:  <ideal> l[1] : spectral numbers in increasing order
    369          <intvec> l[2] :
    370            <int> l[2][i] : multiplicity of spectral number l[1][i]
    371          <list> l[3] :
    372            <module> l[3][i] : vector space basis of l[1][i]-th graded part
    373                               of the V-filtration on H''/H' in terms of l[4]
    374          <ideal> l[4] : monomial vector space basis of H''/H'
    375          <ideal> l[5] : standard basis of Jacobian ideal
    376 EXAMPLE: example vfilt; shows an example
    377 "
    378 {
     389  int mode=1;
     390  if(size(#)>0)
     391  {
     392    if(typeof(#[1])=="int")
     393    {
     394      mode=#[1];
     395    }
     396  }
     397
    379398  int i,j;
    380399  int n=nvars(basering)-1;
    … …  
    383402    if(var(i)>1)
    384403    {
    385       ERROR("basering not local");
     404      ERROR("no local ordering");
    386405    }
    387406  }
    … …  
    392411    if(vdim(sJ)==0)
    393412    {
    394       ERROR("singularity not singular");
     413      ERROR("no singularity at 0");
    395414    }
    396415    else
    397416    {
    398       ERROR("singularity not isolated");
     417      ERROR("no isolated singularity at 0");
    399418    }
    400419  }
    … …  
    415434  {
    416435    k++;
    417     dbprint(printlevel-voice+2,"//gaussman::vfilt: k="+string(k));
    418 
    419     dbprint(printlevel-voice+2,"//gaussman::vfilt: compute C");
     436    dbprint(printlevel-voice+2,"//gaussman::vfiltration: k="+string(k));
     437
     438    dbprint(printlevel-voice+2,"//gaussman::vfiltration: compute C");
    420439    C=coeffs(redNF(w,sJ,U),m);
    421440    A=A+C*var(1)^k;
    … …  
    424443    {
    425444      H0=H;
    426       dbprint(printlevel-voice+2,"//gaussman::vfilt: compute dH");
     445      dbprint(printlevel-voice+2,"//gaussman::vfiltration: compute dH");
    427446      dH=jet(module(A*dH+var(1)^2*diff(matrix(dH),var(1))),k);
    428447      H=H*var(1)+dH;
    429448
    430       dbprint(printlevel-voice+2,"//gaussman::vfilt: test dH==0");
     449      dbprint(printlevel-voice+2,"//gaussman::vfiltration: test dH==0");
    431450      sdH=size(reduce(H,std(H0*var(1))));
    432451      if(sdH>0)
    … …  
    437456      {
    438457        dbprint(printlevel-voice+2,
    439           "//gaussman::vfilt: compute basis of saturation");
     458          "//gaussman::vfiltration: compute basis of saturation");
    440459        H=minbase(H0);
    441460        int modH=maxorddif(H);
    … …  
    454473    if(k<K||sdH>0)
    455474    {
    456       dbprint(printlevel-voice+2,"//gaussman::vfilt: divide by J");
     475      dbprint(printlevel-voice+2,"//gaussman::vfiltration: divide by J");
    457476      l=division(J,ideal(matrix(w)-matrix(m)*C*U));
    458477      D=l[1];
    459478
    460       dbprint(printlevel-voice+2,"//gaussman::monomat: compute w/U");
     479      dbprint(printlevel-voice+2,"//gaussman::vfiltration: compute w/U");
    461480      for(j=mu;j>=1;j--)
    462481      {
    … …  
    464483        {
    465484          dbprint(printlevel-voice+2,
    466             "//gaussman::monomat: compute U["+string(j)+"]");
     485            "//gaussman::vfiltration: compute U["+string(j)+"]");
    467486          U[j,j]=U[j,j]*l[2][j,j];
    468487        }
    469488        dbprint(printlevel-voice+2,
    470           "//gaussman::monomat: compute w["+string(j)+"]");
     489          "//gaussman::vfiltration: compute w["+string(j)+"]");
    471490        w[j]=0;
    472491        for(i=n+1;i>=1;i--)
    … …  
    480499  int N=k-modH;
    481500
    482   dbprint(printlevel-voice+2,"//gaussman::vfilt: transform H0 to saturation");
     501  dbprint(printlevel-voice+2,
     502    "//gaussman::vfiltration: transform H0 to saturation");
    483503  l=division(H,H0);
    484504  H0=expand(l[1],l[2],N-1);
    485505
    486506  dbprint(printlevel-voice+2,
    487     "//gaussman::vfilt: compute H0 as vector space V0");
     507    "//gaussman::vfiltration: compute H0 as vector space V0");
    488508  dbprint(printlevel-voice+2,
    489     "//gaussman::vfilt: compute H1 as vector space V1");
     509    "//gaussman::vfiltration: compute H1 as vector space V1");
    490510  poly p;
    491511  int i0,j0,i1,j1;
    … …  
    514534  }
    515535
    516   dbprint(printlevel-voice+2,"//gaussman::vfilt: compute A on saturation");
     536  dbprint(printlevel-voice+2,
     537    "//gaussman::vfiltration: compute A on saturation");
    517538  l=division(H*var(1),A*H+var(1)^2*diff(matrix(H),var(1)));
    518539  A=expand(l[1],l[2],N-1);
    519540
    520   dbprint(printlevel-voice+2,"//gaussman::vfilt: compute matrix M of A");
     541  dbprint(printlevel-voice+2,"//gaussman::vfiltration: compute matrix M of A");
    521542  matrix M[mu*N][mu*N];
    522543  for(i0=mu;i0>=1;i0--)
    … …  
    544565  }
    545566
    546   dbprint(printlevel-voice+2,"//gaussman::vfilt: compute eigenvalues eA of A");
     567  dbprint(printlevel-voice+2,
     568    "//gaussman::vfiltration: compute eigenvalues eA of A");
    547569  ideal eA=jordan(A,-1)[1];
    548   dbprint(printlevel-voice+2,"//gaussman::vfilt: eA="+string(eA));
    549 
    550   dbprint(printlevel-voice+2,"//gaussman::vfilt: compute eigenvalues eM of M");
     570  dbprint(printlevel-voice+2,"//gaussman::vfiltration: eA="+string(eA));
     571
     572  dbprint(printlevel-voice+2,
     573    "//gaussman::vfiltration: compute eigenvalues eM of M");
    551574  ideal eM;
    552575  k=0;
    … …  
    574597    }
    575598  }
    576   dbprint(printlevel-voice+2,"//gaussman::vfilt: eM="+string(eM));
     599  dbprint(printlevel-voice+2,"//gaussman::vfiltration: eM="+string(eM));
    577600
    578601  dbprint(printlevel-voice+2,
    579     "//gaussman::vfilt: compute V-filtration on H0/H1");
     602    "//gaussman::vfiltration: compute V-filtration on H0/H1");
    580603  ideal s;
    581604  k=0;
    … …  
    584607  V[ncols(eM)+1]=std(V1);
    585608  intvec d;
    586   if(size(#)>0)
     609  if(mode==0)
    587610  {
    588611    for(i=ncols(eM);number(eM[i])-1>number(n-1)/2;i--)
    … …  
    595618
    596619      dbprint(printlevel-voice+2,
    597         "//gaussman::vfilt: compute V["+string(i)+"]");
     620        "//gaussman::vfiltration: compute V["+string(i)+"]");
    598621      V1=module(V1)+syz(Me);
    599622      V[i]=std(intersect(V1,V0));
    … …  
    607630    }
    608631
    609     dbprint(printlevel-voice+2,"//gaussman::vfilt: symmetry index found");
     632    dbprint(printlevel-voice+2,
     633      "//gaussman::vfiltration: symmetry index found");
    610634    j=k;
    611635    if(number(eM[i])-1==number(n-1)/2)
    … …  
    618642
    619643      dbprint(printlevel-voice+2,
    620         "//gaussman::vfilt: compute V["+string(i)+"]");
     644        "//gaussman::vfiltration: compute V["+string(i)+"]");
    621645      V1=module(V1)+syz(Me);
    622646      V[i]=std(intersect(V1,V0));
    … …  
    630654    }
    631655
    632     dbprint(printlevel-voice+2,"//gaussman::vfilt: apply symmetry");
     656    dbprint(printlevel-voice+2,"//gaussman::vfiltration: apply symmetry");
    633657    while(j>=1)
    634658    {
    … …  
    655679
    656680      dbprint(printlevel-voice+2,
    657         "//gaussman::vfilt: compute V["+string(i)+"]");
     681        "//gaussman::vfiltration: compute V["+string(i)+"]");
    658682      V1=module(V1)+syz(Me);
    659683      V[i]=std(intersect(V1,V0));
    … …  
    665689          k++;
    666690          s[k]=eM[i]-1;
    667           dbprint(printlevel-voice+2,"//gaussman::vfilt: transform to V0");
     691          dbprint(printlevel-voice+2,
     692            "//gaussman::vfiltration: transform to V0");
    668693          v[k]=matrix(freemodule(ncols(V[i])),mu,mu*N)*division(V0,V[i])[1];
    669694        }
    … …  
    685710          s[j]=eM[i]-1;
    686711          v[k]=v[j];
    687           dbprint(printlevel-voice+2,"//gaussman::vfilt: transform to V0");
     712          dbprint(printlevel-voice+2,
     713            "//gaussman::vfiltration: transform to V0");
    688714          v[j]=matrix(freemodule(ncols(V[i])),mu,mu*N)*division(V0,V[i])[1];
    689715          j--;
    … …  
    692718    }
    693719
    694     dbprint(printlevel-voice+2,"//gaussman::vfilt: compute graded parts");
     720    dbprint(printlevel-voice+2,
     721      "//gaussman::vfiltration: compute graded parts");
    695722    option(redSB);
    696723    for(k=1;k<size(v);k++)
    … …  
    709736  ring R=0,(x,y),ds;
    710737  poly f=x5+x2y2+y5;
    711   list l=vfilt(f);
     738  list l=vfiltration(f);
    712739  print(l);
    713740}
    714741///////////////////////////////////////////////////////////////////////////////
    715742
    716 proc singspec(poly f)
    717 "USAGE:   <list> l=singspec(<poly> f);
    718 ASSUME:  f isolated singularity
    719 RETURN:  <ideal> l[1] : spectral numbers in increasing order
    720          <intvec> l[2] :
    721            <int> l[2][i] : multiplicity of spectral number l[1][i]
    722 EXAMPLE: example singspec; shows an example
    723 "
    724 {
    725   return(vfilt(f,0));
    726 }
    727 example
    728 { "EXAMPLE:"; echo=2;
    729   ring R=0,(x,y),ds;
    730   poly f=x5+x2y2+y5;
    731   list l=singspec(f);
    732   print(l);
    733 }
    734 ///////////////////////////////////////////////////////////////////////////////
    735 
    736 proc gamma(list l)
    737 "USAGE:   <number> g=gamma(singspec(<poly> f));
    738 ASSUME:  f isolated singularity
    739 RETURN:  Hertling's gamma invariant
    740 EXAMPLE: example gamma; shows an example
    741 "
    742 {
    743   ideal s=l[1];
    744   intvec d=l[2];
    745   int n=nvars(basering)-1;
    746   number g=0;
    747   int i,j;
    748   for(i=1;i<=ncols(s);i++)
    749   {
    750     for(j=1;j<=d[i];j++)
    751     {
    752       g=g+(number(s[i])-number(n-1)/2)^2;
    753     }
    754   }
    755   g=-g/4+sum(d)*number(s[ncols(s)]-s[1])/48;
    756   return(g);
    757 }
    758 example
    759 { "EXAMPLE:"; echo=2;
    760   ring R=0,(x,y),ds;
    761   poly f=x5+x2y2+y5;
    762   gamma(singspec(f));
    763 }
    764 ///////////////////////////////////////////////////////////////////////////////
    765 
    766 proc gamma4(list l)
    767 "USAGE:   <number> g4=gamma4(singspec(<poly> f));
    768 ASSUME:  f isolated singularity
    769 RETURN:  Hertling's gamma4 invariant
    770 EXAMPLE: example gamma4; shows an example
    771 "
    772 {
    773   ideal s=l[1];
    774   intvec d=l[2];
    775   int n=nvars(basering)-1;
    776   number g4=0;
    777   int i,j;
    778   for(i=1;i<=ncols(s);i++)
    779   {
    780     for(j=1;j<=d[i];j++)
    781     {
    782       g4=g4+(number(s[i])-number(n-1)/2)^4;
    783     }
    784   }
    785   g4=g4-(number(s[ncols(s)]-s[1])/12-1/30)*
    786     (sum(d)*number(s[ncols(s)]-s[1])/4-24*gamma(l));
    787  return(g4);
    788 }
    789 example
    790 { "EXAMPLE:"; echo=2;
    791   ring R=0,(x,y),ds;
    792   poly f=x5+x2y2+y5;
    793   gamma4(singspec(f));
    794 }
    795 ///////////////////////////////////////////////////////////////////////////////
    796 
    797 proc vjacob(list l)
    798 "USAGE:   <list> l=vjacob(vfilt(<poly> f));
    799 ASSUME:  f isolated singularity
    800 RETURN:  <ideal> l[1] : spectral numbers of the V-filtration on the
     743proc vfiltjacalg(list l)
     744"USAGE:   vfiltjacalg(vfiltration(f));
     745ASSUME:  local ordering, f isolated singularity at 0
     746RETURN:  list l :
     747           ideal l[1] : spectral numbers of the V-filtration on the
    801748                        Jacobian algebra in increasing order
    802          <intvec> l[2] :
    803            <int> l[2][i] : multiplicity of spectral number l[1][i]
    804          <list> l[3] :
    805            <module> l[3][i] : vector space basis of l[1][i]-th graded part
    806                               of the V-filtration on the Jaconian algebra
     749           intvec l[2] :
     750             int l[2][i] : multiplicity of spectral number l[1][i]
     751           list l[3] :
     752             module l[3][i] : vector space basis of l[1][i]-th graded part
     753                              of the V-filtration on the Jacobian algebra
    807754                              in terms of l[4]
    808          <ideal> l[4] : monomial vector space basis of the Jacobian algebra
    809          <ideal> l[5] : standard basis of Jacobian ideal
    810 EXAMPLE: example vjacob; shows an example
     755           ideal l[4] : monomial vector space basis of the Jacobian algebra
     756           ideal l[5] : standard basis of Jacobian ideal
     757EXAMPLE: example vfiltjacalg; shows an example
    811758"
    812759{
    … …  
    822769
    823770  dbprint(printlevel-voice+2,
    824     "//gaussman::vjacob: compute multiplication in Jacobian algebra");
     771    "//gaussman::vfiltjacalg: compute multiplication in Jacobian algebra");
    825772  list M;
    826773  for(i=ncols(m);i>=1;i--)
    … …  
    840787  {
    841788    dbprint(printlevel-voice+2,
    842       "//gaussman::vjacob: find next possible index");
     789      "//gaussman::vfiltjacalg: find next possible index");
    843790    r1=number(s[ncols(s)]-s[1]);
    844791    for(j=ncols(s);j>=1;j--)
    … …  
    869816
    870817    dbprint(printlevel-voice+2,
    871       "//gaussman::vjacob: collect conditions for V["+string(r0)+"]");
     818      "//gaussman::vfiltjacalg: collect conditions for V["+string(r0)+"]");
    872819    j=ncols(s);
    873820    j0=mu;
    … …  
    898845    }
    899846
    900     dbprint(printlevel-voice+2,"//gaussman::vjacob: compose condition matrix");
     847    dbprint(printlevel-voice+2,
     848      "//gaussman::vfiltjacalg: compose condition matrix");
    901849    L=transpose(module(l[1]));
    902850    for(k=2;k<=ncols(m);k++)
    … …  
    906854
    907855    dbprint(printlevel-voice+2,
    908       "//gaussman::vjacob: compute kernel of condition matrix");
     856      "//gaussman::vfiltjacalg: compute kernel of condition matrix");
    909857    v0=v0+list(syz(L));
    910858    s0=s0,r0;
    911859  }
    912860
    913   dbprint(printlevel-voice+2,"//gaussman::vjacob: compute graded parts");
     861  dbprint(printlevel-voice+2,"//gaussman::vfiltjacalg: compute graded parts");
    914862  option(redSB);
    915863  for(i=1;i<size(v0);i++)
    … …  
    920868
    921869  dbprint(printlevel-voice+2,
    922     "//gaussman::vjacob: remove trivial graded parts");
     870    "//gaussman::vfiltjacalg: remove trivial graded parts");
    923871  i=1;
    924872  while(size(v0[i])==0)
    … …  
    946894  ring R=0,(x,y),ds;
    947895  poly f=x5+x2y2+y5;
    948   vjacob(vfilt(f));
     896  vfiltjacalg(vfiltration(f));
     897}
     898///////////////////////////////////////////////////////////////////////////////
     899
     900proc gamma(list l)
     901"USAGE:   gamma(vfiltration(f,0)); poly f
     902ASSUME:  local ordering, f isolated singularity at 0
     903RETURN:  number g : Hertling's gamma invariant
     904EXAMPLE: example gamma; shows an example
     905"
     906{
     907  ideal s=l[1];
     908  intvec d=l[2];
     909  int n=nvars(basering)-1;
     910  number g=0;
     911  int i,j;
     912  for(i=1;i<=ncols(s);i++)
     913  {
     914    for(j=1;j<=d[i];j++)
     915    {
     916      g=g+(number(s[i])-number(n-1)/2)^2;
     917    }
     918  }
     919  g=-g/4+sum(d)*number(s[ncols(s)]-s[1])/48;
     920  return(g);
     921}
     922example
     923{ "EXAMPLE:"; echo=2;
     924  ring R=0,(x,y),ds;
     925  poly f=x5+x2y2+y5;
     926  gamma(vfiltration(f,0));
     927}
     928///////////////////////////////////////////////////////////////////////////////
     929
     930proc gamma4(list l)
     931"USAGE:   gamma4(vfiltration(f,0)); poly f
     932ASSUME:  local ordering, f isolated singularity at 0
     933RETURN:  number g4 : Hertling's gamma4 invariant
     934EXAMPLE: example gamma4; shows an example
     935"
     936{
     937  ideal s=l[1];
     938  intvec d=l[2];
     939  int n=nvars(basering)-1;
     940  number g4=0;
     941  int i,j;
     942  for(i=1;i<=ncols(s);i++)
     943  {
     944    for(j=1;j<=d[i];j++)
     945    {
     946      g4=g4+(number(s[i])-number(n-1)/2)^4;
     947    }
     948  }
     949  g4=g4-(number(s[ncols(s)]-s[1])/12-1/30)*
     950    (sum(d)*number(s[ncols(s)]-s[1])/4-24*gamma(l));
     951 return(g4);
     952}
     953example
     954{ "EXAMPLE:"; echo=2;
     955  ring R=0,(x,y),ds;
     956  poly f=x5+x2y2+y5;
     957  gamma4(vfiltration(f,0));
    949958}
    950959///////////////////////////////////////////////////////////////////////////////
    … …  
    955964  basering;
    956965  f;
    957   print(monomat(f));
    958   print(monospec(f));
    959   list l=vfilt(f);
     966  print(monodromy(f));
     967  list l=vfiltration(f);
    960968  l;
    961   vjacob(l);
    962   l=singspec(f);
    963   l;
     969  vfiltjacalg(l);
    964970  gamma(l);
    965971  gamma4(l);
Note: See TracChangeset for help on using the changeset viewer.