Changeset 2653d3 in git


Ignore:
Timestamp:
Jan 15, 2009, 8:19:09 PM (14 years ago)
Author:
Viktor Levandovskyy <levandov@…>
Branches:
(u'spielwiese', '0d6b7fcd9813a1ca1ed4220cfa2b104b97a0a003')
Children:
3ab3910724146bbcc35aa79fd9d30888ef6226e6
Parents:
a0350e9a597a2d719cdc7e27752cc38d0a6147b8
Message:
*levandov: debug + docu enhancements


git-svn-id: file:///usr/local/Singular/svn/trunk@11322 2c84dea3-7e68-4137-9b89-c4e89433aadc
Location:
Singular/LIB
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • Singular/LIB/bfct.lib

    ra0350e9 r2653d3  
    11//////////////////////////////////////////////////////////////////////////////
    2 version="$Id: bfct.lib,v 1.11 2009-01-14 16:07:03 Singular Exp $";
     2version="$Id: bfct.lib,v 1.12 2009-01-15 19:19:09 levandov Exp $";
    33category="Noncommutative";
    44info="
    … …  
    1616@*      - the list of its roots, which are known to be rational
    1717@*      - the multiplicities of the roots.
    18 @*      References: Saito, Strurmfels, Takayama: Groebner Deformations of Hypergeometric
     18@*      References: Saito, Sturmfels, Takayama: Groebner Deformations of Hypergeometric
    1919@*      Differential Equations (2000), Noro: An Efficient Modular Algorithm for Computing
    2020@*      the Global b-function, (2002).
    … …  
    2929bfctIdeal(I,w[,s,t]);       computes the global b-function of ideal I w.r.t. the weight w
    3030pIntersect(f,I);            intersection of the ideal I with the subalgebra K[f] for a poly f
    31 pIntersectSyz(f,I[,p,s,t]);  intersection of the ideal I with the subalgebra K[f] for a poly f
     31pIntersectSyz(f,I[,p,s,t]); intersection of the ideal I with the subalgebra K[f] for a poly f
    3232linReduce(f,I[,s]);         reduces a poly by linear reductions only
     33linReduceIdeal(I,[s,t]);    reduces generators of ideal by linear reductions only
    3334linSyzSolve(I[,s]);         computes a linear dependency of the elements of ideal I
    3435
    3536AUXILIARY PROCEDURES:
    3637
    37 allPositive(v);  checks whether all entries of an intvec are positive
     38allPositive(v);  checks whether all entries of an intvec are positive 
    3839scalarProd(v,w); computes the standard scalar product of two intvecs
    3940vec2poly(v[,i]); constructs an univariate poly with given coefficients
    … …  
    7980EXAMPLE: example gradedWeyl; shows examples
    8081NOTE:    u[i] is the weight of x(i), v[i] the weight of D(i).
    81 @*       u+v has to be a non-negative intvec.
     82@*       u+v has to be a non-negative intvec. 
    8283"
    8384{
    … …  
    8889  {
    8990    ERROR("weight vectors have wrong dimension");
    90   }
     91  } 
    9192  intvec uv,gr;
    9293  uv = u+v;
    … …  
    9798      if (uv[i]==0)
    9899      {
    99         gr[i] = 0;
     100        gr[i] = 0;
    100101      }
    101102      else
    102103      {
    103         gr[i] = 1;
     104        gr[i] = 1;
    104105      }
    105106    }
    … …  
    114115  for (i=1; i<=n; i++)
    115116  {
    116     if (gr[i] == 1)
     117    if (gr[i] == 1) 
    117118    {
    118119       l2[n+i] = "xi("+string(i)+")";
    … …  
    229230proc linReduceIdeal(ideal I, list #)
    230231"USAGE:  linReduceIdeal(I [,s,t]); I an ideal, s,t optional ints
    231 RETURN:  ideal/list, linear reductum (over field) of f by elements from I
    232 PURPOSE: reduce a poly only by linear reductions (no monomial multiplications)
    233 NOTE:    If s<>0, a list consisting of the reduced ideal and the coefficient
     232RETURN:  ideal/list, linear reductum (over field) of I by its elements
     233PURPOSE: reduce a list of polys only by linear reductions (no monomial multiplications)
     234NOTE:    If s<>0, a list consisting of the reduced ideal and the coefficient 
    234235@*       vectors of the used reductions given as module is returned.
    235236@*       Otherwise (and by default), only the reduced ideal is returned.
    … …  
    255256      if (typeof(#[2])=="int" || typeof(#[2])=="number")
    256257      {
    257         redtail = #[2];
     258        redtail = #[2];
    258259      }
    259260    }
    … …  
    273274      for (i=1; i<=sI; i++)
    274275      {
    275         if (I[i] == 0)
    276         {
    277           j++;
    278           J[j] = 0;
    279           ordJ[j] = -1;
    280           M[j] = gen(i);
    281         }
    282         else
    283         {
    284           M[i+sZeros-j] = gen(lJ[2][i-j]+j);
    285         }
     276        if (I[i] == 0)
     277        {
     278          j++;
     279          J[j] = 0;
     280          ordJ[j] = -1;
     281          M[j] = gen(i);
     282        }
     283        else
     284        {
     285          M[i+sZeros-j] = gen(lJ[2][i-j]+j);
     286        }
    286287      }
    287288    }
    … …  
    290291      for (i=1; i<=sZeros; i++)
    291292      {
    292         J[i] = 0;
    293         ordJ[i] = -1;
     293        J[i] = 0;
     294        ordJ[i] = -1;
    294295      }
    295296    }
    … …  
    327328      for (j=sZeros+1; j<i; j++)
    328329      {
    329         if (lm == 0) { break; }
    330         if (ordlm > maxordJ) { break; }
    331         if (ordlm == ordJ[j])
    332         {
    333           if (lm > maxlmJ) { break; }
    334           if (lm == lmJ[j])
    335           {
    336             dbprint(ppl,"reducing " + string(redpoly));
    337             dbprint(ppl," with " + string(J[j]));
    338             c = leadcoef(redpoly)/leadcoef(J[j]);
    339             redpoly = redpoly - c*J[j];
    340             dbprint(ppl," to " + string(redpoly));
    341             lm = leadmonom(redpoly);
    342             ordlm = ord(lm);
    343             if (remembercoeffs <> 0) { M[i] = M[i] - c * M[j]; }
    344             reduction = 1;
    345           }
    346         }
     330        if (lm == 0) { break; }
     331        if (ordlm > maxordJ) { break; }
     332        if (ordlm == ordJ[j])
     333        {           
     334          if (lm > maxlmJ) { break; }
     335          if (lm == lmJ[j])
     336          {
     337            dbprint(ppl,"reducing " + string(redpoly));
     338            dbprint(ppl," with " + string(J[j]));
     339            c = leadcoef(redpoly)/leadcoef(J[j]);
     340            redpoly = redpoly - c*J[j];
     341            dbprint(ppl," to " + string(redpoly));
     342            lm = leadmonom(redpoly);
     343            ordlm = ord(lm);
     344            if (remembercoeffs <> 0) { M[i] = M[i] - c * M[j]; }
     345            reduction = 1;
     346          }
     347        }
    347348      }
    348349    }
    … …  
    354355    lmJ = insertGenerator(lmJ,lm,j);
    355356    ordJ = insertGenerator(ordJ,poly(ordlm),j);
    356     if (remembercoeffs <> 0)
     357    if (remembercoeffs <> 0) 
    357358    {
    358359      v = M[i];
    … …  
    373374      for (j=i+1; j<=sI; j++)
    374375      {
    375         for (k=2; k<=size(J[j]); k++) // run over all terms in J[j]
    376         {
    377           if (ordJ[i] == ord(J[j][k]))
    378           {
    379             if (lm == normalize(J[j][k]))
    380             {
    381               c = leadcoef(J[j][k])/leadcoef(J[i]);
    382               dbprint(ppl,"reducing " + string(J[j]));
    383               dbprint(ppl," with " + string(J[i]));
    384               J[j] = J[j] - c*J[i];
    385               dbprint(ppl," to " + string(J[j]));
    386               if (remembercoeffs <> 0) { M[j] = M[j] - c * M[i]; }
    387             }
    388           }
    389         }
     376        for (k=2; k<=size(J[j]); k++) // run over all terms in J[j]
     377        {
     378          if (ordJ[i] == ord(J[j][k]))
     379          {   
     380            if (lm == normalize(J[j][k]))
     381            {
     382              c = leadcoef(J[j][k])/leadcoef(J[i]);
     383              dbprint(ppl,"reducing " + string(J[j]));
     384              dbprint(ppl," with " + string(J[i]));
     385              J[j] = J[j] - c*J[i];
     386              dbprint(ppl," to " + string(J[j]));
     387              if (remembercoeffs <> 0) { M[j] = M[j] - c * M[i]; }
     388            }
     389          }
     390        }
    390391      }
    391392    }
    … …  
    410411RETURN:  poly/list, linear reductum (over field) of f by elements from I
    411412PURPOSE: reduce a poly only by linear reductions (no monomial multiplications)
    412 NOTE:    If s<>0, a list consisting of the reduced poly and the coefficient
     413NOTE:    If s<>0, a list consisting of the reduced poly and the coefficient 
    413414@*       vector of the used reductions is returned, otherwise (and by default)
    414415@*       only reduced poly is returned.
    … …  
    433434      if (typeof(#[2])=="int" || typeof(#[2])=="number")
    434435      {
    435         redtail = #[2];
     436        redtail = #[2];
    436437      }
    437438      if (size(#)>2)
    438439      {
    439         if (typeof(#[3])=="int" || typeof(#[3])=="number")
     440        if (typeof(#[3])=="int" || typeof(#[3])=="number")
    440441        {
    441           prepareideal = #[3];
    442         }
     442          prepareideal = #[3];
     443        }
    443444      }
    444445    }
    … …  
    469470      for (i=1; i<=sI; i++)
    470471      {
    471         M[i] = gen(i);
     472        M[i] = gen(i);
    472473      }
    473474    }
    … …  
    495496      if (ordf == ordI[i])
    496497      {
    497         if (lm == lmI[i])
    498         {
    499           c = leadcoef(f)/lcI[i];
    500           f = f - c*I[i];
    501           lm = leadmonom(f);
    502           ordf = ord(lm);
    503           if (remembercoeffs <> 0)
    504           {
    505             v = v - c * M[i];
    506           }
    507         }
     498        if (lm == lmI[i])
     499        {
     500          c = leadcoef(f)/lcI[i];
     501          f = f - c*I[i];
     502          lm = leadmonom(f);
     503          ordf = ord(lm);
     504          if (remembercoeffs <> 0)
     505          {
     506            v = v - c * M[i];
     507          }
     508        }
    508509      }
    509510    }
    … …  
    518519      for (j=1; j<=size(f); j++)
    519520      {
    520         if (ord(f[j]) == ordI[i])
    521         {
    522           if (normalize(f[j]) == lmI[i])
    523           {
    524             c = leadcoef(f[j])/lcI[i];
    525             f = f - c*I[i];
    526             dbprint(ppl,"reducing poly to ",f);
    527             if (remembercoeffs <> 0)
    528             {
    529               v = v - c * M[i];
    530             }
    531           }
    532         }
     521        if (ord(f[j]) == ordI[i])
     522        {
     523          if (normalize(f[j]) == lmI[i])
     524          {
     525            c = leadcoef(f[j])/lcI[i];
     526            f = f - c*I[i];
     527            dbprint(ppl,"reducing poly to ",f);
     528            if (remembercoeffs <> 0)
     529            {
     530              v = v - c * M[i];
     531            }
     532          }
     533        }
    533534      }
    534535    }
    … …  
    556557  f = x3 + y2 + x2 + y + x;
    557558  I = x3 - y3, y3 - x2, x3 - y2, x2 - y, y2-x;
    558   list l = linReduce(f, I, 1);
     559  list l = linReduce(f, I, 1); 
    559560  l;
    560561  module M = I;
    … …  
    601602      if (p <> 0)
    602603      {
    603         whichengine = 1;
     604        whichengine = 1;
    604605      }
    605606    }
    … …  
    668669proc pIntersect (poly s, ideal I)
    669670"USAGE:  pIntersect(f, I);  f a poly, I an ideal
    670 RETURN:  vector, coefficient vector of the monic polynomial
     671RETURN:  vector, coefficient vector of the monic polynomial 
    671672PURPOSE: compute the intersection of ideal I with the subalgebra K[f]
    672673ASSUME:  I is given as Groebner basis.
    … …  
    684685    attrib(I,"isSB",1); // set attribute for suppressing NF messages
    685686  }
    686   int ppl = printlevel-voice+2;
     687  int ppl = printlevel-voice+1;
    687688  // ---case 1: I = basering---
    688689  if (size(I) == 1)
    … …  
    712713      if (degs[j] == 0)
    713714      {
    714         if (degI[i][j] <> 0)
    715         {
    716           break;
    717         }
     715        if (degI[i][j] <> 0)
     716        {
     717          break;
     718        }
    718719      }
    719720      if (j == n)
    720721      {
    721         k++;
    722         possdegbounds[k] = Max(degI[i]);
     722        k++;
     723        possdegbounds[k] = Max(degI[i]);
    723724      }
    724725    }
    … …  
    749750      if (tobracket==0) // todo bug in bracket?
    750751      {
    751         toNF = 0;
     752        toNF = 0;
    752753      }
    753754      else
    754755      {
    755         toNF = bracket(tobracket,secNF);
     756        toNF = bracket(tobracket,secNF);
    756757      }
    757758      newNF = NF(toNF+oldNF*secNF,I);  // = NF(s^i,I)
    … …  
    802803    v = v + m[j,1]*gen(j);
    803804  }
    804   setring save;
     805  setring save; 
    805806  v = imap(@R,v);
    806807  kill @R;
    … …  
    864865      if (size(#)>2)
    865866      {
    866         if (typeof(#[3])=="int" || typeof(#[3])=="number")
    867         {
    868           modengine = int(#[3]);
    869         }
     867        if (typeof(#[3])=="int" || typeof(#[3])=="number")
     868        {
     869          modengine = int(#[3]);
     870        }
    870871      }
    871872    }
    … …  
    909910      if (tobracket!=0)
    910911      {
    911         toNF = bracket(tobracket,NI[2]) + NI[i]*NI[2];
     912        toNF = bracket(tobracket,NI[2]) + NI[i]*NI[2];
    912913      }
    913914      else
    914915      {
    915         toNF = NI[i]*NI[2];
     916        toNF = NI[i]*NI[2];
    916917      }
    917918      newNF =  NF(toNF,I);
    … …  
    927928      if (v!=0) // there is a modular solution
    928929      {
    929         dbprint(ppl,"got solution in char ",solveincharp," of degree " ,i);
    930         setring save;
    931         v = linSyzSolve(NI,whichengine);
    932         if (v==0)
    933         {
    934           break;
    935         }
     930        dbprint(ppl,"got solution in char ",solveincharp," of degree " ,i);
     931        setring save;
     932        v = linSyzSolve(NI,whichengine);
     933        if (v==0)
     934        {
     935          break;
     936        }
    936937      }
    937938      else // no modular solution
    938939      {
    939         setring save;
    940         v = 0;
     940        setring save;
     941        v = 0;
    941942      }
    942943    }
    … …  
    965966      {
    966967        dbprint(ppl,"linSyzSolve: got solution!");
    967         // "got solution!";
     968        // "got solution!";
    968969        break;
    969970      }
    … …  
    10151016      if (typeof(#[2])=="int" || typeof(#[2])=="number")
    10161017      {
    1017         ringvar = int(#[2]);
     1018        ringvar = int(#[2]);
    10181019      }
    10191020    }
    … …  
    10941095  def save = basering;
    10951096  int n = nvars(save);
     1097  if (size(variables(f)) == 0) // f is constant
     1098  {
     1099    return(list(ideal(0),intvec(0)));
     1100  } 
    10961101  if (inorann == 0) // bfct using initial ideal
    10971102  {
    … …  
    11211126      while (b == 0)
    11221127      {
    1123         dbprint(ppl,"number of run in the loop: "+string(i));
    1124         int q = prime(random(lb,ub));
    1125         if (findFirst(usedprimes,q)==0) // if q was not already used
     1128        dbprint(ppl,"number of run in the loop: "+string(i));
     1129        int q = prime(random(lb,ub));
     1130        if (findFirst(usedprimes,q)==0) // if q was not already used
    11261131        {
    1127           usedprimes = usedprimes,q;
    1128           dbprint(ppl,"used prime is: "+string(q));
    1129           b = pIntersectSyz(s,J,q,whichengine,modengine);
    1130         }
    1131         i++;
    1132       }
    1133     }
    1134     else // pIntersectSyz::non-modular
     1132          usedprimes = usedprimes,q;
     1133          dbprint(ppl,"used prime is: "+string(q));
     1134          b = pIntersectSyz(s,J,q,whichengine,modengine);
     1135        }
     1136        i++;
     1137      }
     1138    }
     1139    else // pIntersectSyz::non-modular 
    11351140    {
    11361141      b = pIntersectSyz(s,J,0,whichengine);
    … …  
    11581163RETURN:  list of ideal and intvec
    11591164PURPOSE: computes the roots of the Bernstein-Sato polynomial b(s)
    1160 @*       for the hypersurface defined by f.
     1165@*       for the hypersurface defined by f. 
    11611166ASSUME:  The basering is a commutative polynomial ring in char 0.
    1162 BACKGROUND: In this proc, the initial Malgrange ideal is computed according to the algorithm
     1167BACKGROUND: In this proc, the initial Malgrange ideal is computed according to the algorithm 
    11631168@*       by Masayuki Noro and then a system of linear equations is solved by linear reductions.
    1164 NOTE:    In the output list, the ideal contains all the roots
     1169NOTE:    In the output list, the ideal contains all the roots 
    11651170@*       and the intvec their multiplicities.
    11661171@*       If s<>0, @code{std} is used for GB computations,
    1167 @*       otherwise, and by default, @code{slimgb} is used.
     1172@*       otherwise, and by default, @code{slimgb} is used. 
    11681173@*       If t<>0, a matrix ordering is used for Groebner basis computations,
    11691174@*       otherwise, and by default, a block ordering is used.
    1170 @*       If v is a positive weight vector, v is used for homogenization computations,
     1175@*       If v is a positive weight vector, v is used for homogenization computations, 
    11711176@*       otherwise and by default, no weights are used.
    11721177DISPLAY: If printlevel=1, progress debug messages will be printed,
    … …  
    11991204      if (size(#)>2)
    12001205      {
    1201         if (typeof(#[3])=="intvec" && size(#[3])==n && allPositive(#[3])==1)
     1206        if (typeof(#[3])=="intvec" && size(#[3])==n && allPositive(#[3])==1)
    12021207        {
    1203           u0 = #[3];
    1204         }
     1208          u0 = #[3];
     1209        }
    12051210      }
    12061211    }
    … …  
    12221227"USAGE:  bfctSyz(f [,r,s,t,u,v]);  f a poly, r,s,t,u optional ints, v an optional intvec
    12231228RETURN:  list of ideal and intvec
    1224 PURPOSE: computes the roots of the Bernstein-Sato polynomial b(s)
     1229PURPOSE: computes the roots of the Bernstein-Sato polynomial b(s) 
    12251230@*       for the hypersurface defined by f
    12261231ASSUME:  The basering is a commutative polynomial ring in char 0.
    1227 BACKGROUND: In this proc, the initial Malgrange ideal is computed according to the algorithm
     1232BACKGROUND: In this proc, the initial Malgrange ideal is computed according to the algorithm 
    12281233@*       by Masayuki Noro and then a system of linear equations is solved by computing syzygies.
    1229 NOTE:    In the output list, the ideal contains all the roots
     1234NOTE:    In the output list, the ideal contains all the roots 
    12301235@*       and the intvec their multiplicities.
    1231 @*       If r<>0, @code{std} is used for GB computations in characteristic 0,
    1232 @*       otherwise, and by default, @code{slimgb} is used.
    1233 @*       If s<>0, a matrix ordering is used for GB computations, otherwise,
     1236@*       If r<>0, @code{std} is used for GB computations in characteristic 0, 
     1237@*       otherwise, and by default, @code{slimgb} is used. 
     1238@*       If s<>0, a matrix ordering is used for GB computations, otherwise, 
    12341239@*       and by default, a block ordering is used.
    1235 @*       If t<>0, the computation of the intersection is solely performed over
     1240@*       If t<>0, the computation of the intersection is solely performed over 
    12361241@*       charasteristic 0, otherwise and by default, a modular method is used.
    1237 @*       If u<>0 and by default, @code{std} is used for GB computations in
    1238 @*       characteristic >0, otherwise, @code{slimgb} is used.
    1239 @*       If v is a positive weight vector, v is used for homogenization
     1242@*       If u<>0 and by default, @code{std} is used for GB computations in 
     1243@*       characteristic >0, otherwise, @code{slimgb} is used. 
     1244@*       If v is a positive weight vector, v is used for homogenization 
    12401245@*       computations, otherwise and by default, no weights are used.
    12411246DISPLAY: If printlevel=1, progress debug messages will be printed,
    12421247@*       if printlevel>=2, all the debug messages will be printed.
    1243 EXAMPLE: example bfct; shows examples
     1248EXAMPLE: example bfctSyz; shows examples
    12441249"
    12451250{
    … …  
    12751280        if (typeof(#[3])=="int" || typeof(#[3])=="number")
    12761281        {
    1277           pIntersectchar = int(#[3]);
    1278         }
    1279         if (size(#)>3)
     1282          pIntersectchar = int(#[3]);
     1283        }
     1284        if (size(#)>3)
    12801285        {
    1281           if (typeof(#[4])=="int" || typeof(#[4])=="number")
     1286          if (typeof(#[4])=="int" || typeof(#[4])=="number")
    12821287          {
    1283             modengine = int(#[4]);
    1284           }
    1285           if (size(#)>4)
    1286           {
    1287             if (typeof(#[5])=="intvec" && size(#[5])==n && allPositive(#[5])==1)
    1288             {
    1289               u0 = #[5];
    1290             }
    1291           }
    1292         }
     1288            modengine = int(#[4]);
     1289          }
     1290          if (size(#)>4)
     1291          {
     1292            if (typeof(#[5])=="intvec" && size(#[5])==n && allPositive(#[5])==1)
     1293            {
     1294              u0 = #[5];
     1295            }
     1296          }
     1297        }
    12931298      }
    12941299    }
    … …  
    13151320BACKGROUND:  In this proc, the initial ideal of I is computed according to the algorithm by
    13161321@*       Masayuki Noro and then a system of linear equations is solved by linear reductions.
    1317 NOTE:    In the output list, the ideal contains all the roots
     1322NOTE:    In the output list, the ideal contains all the roots 
    13181323@*       and the intvec their multiplicities.
    13191324@*       If s<>0, @code{std} is used for GB computations in characteristic 0,
    1320 @*       otherwise, and by default, @code{slimgb} is used.
     1325@*       otherwise, and by default, @code{slimgb} is used. 
    13211326@*       If t<>0, a matrix ordering is used for GB computations, otherwise,
    13221327@*       and by default, a block ordering is used.
    13231328DISPLAY: If printlevel=1, progress debug messages will be printed,
    13241329@*       if printlevel>=2, all the debug messages will be printed.
    1325 EXAMPLE: example bfctideal; shows examples
     1330EXAMPLE: example bfctIdeal; shows examples
    13261331"
    13271332{
    … …  
    13741379"USAGE:  bfctOneGB(f [,s,t]);  f a poly, s,t optional ints
    13751380RETURN:  list of ideal and intvec
    1376 PURPOSE: computes the roots of the Bernstein-Sato polynomial b(s) for the
     1381PURPOSE: computes the roots of the Bernstein-Sato polynomial b(s) for the 
    13771382@*       hypersurface defined by f, using only one GB computation
    13781383ASSUME:  The basering is a commutative polynomial ring in char 0.
    1379 BACKGROUND: In this proc, the initial Malgrange ideal is computed based on the
     1384BACKGROUND: In this proc, the initial Malgrange ideal is computed based on the 
    13801385@*       algorithm by Masayuki Noro and combined with an elimination ordering.
    1381 NOTE:    In the output list, the ideal contains all the roots
     1386NOTE:    In the output list, the ideal contains all the roots 
    13821387@*       and the intvec their multiplicities.
    13831388@*       If s<>0, @code{std} is used for the GB computation, otherwise,
    1384 @*       and by default, @code{slimgb} is used.
     1389@*       and by default, @code{slimgb} is used. 
    13851390@*       If t<>0, a matrix ordering is used for GB computations,
    13861391@*       otherwise, and by default, a block ordering is used.
    … …  
    14921497"USAGE:  bfctAnn(f [,r]);  f a poly, r an optional int
    14931498RETURN:  list of ideal and intvec
    1494 PURPOSE: computes the roots of the Bernstein-Sato polynomial b(s)
     1499PURPOSE: computes the roots of the Bernstein-Sato polynomial b(s) 
    14951500@*       for the hypersurface defined by f
    14961501ASSUME:  The basering is a commutative polynomial ring in char 0.
    14971502BACKGROUND: In this proc, ann(f^s) is computed and then a system of linear
    14981503@*       equations is solved by linear reductions.
    1499 NOTE:    In the output list, the ideal contains all the roots
     1504NOTE:    In the output list, the ideal contains all the roots 
    15001505@*       and the intvec their multiplicities.
    15011506@*       If r<>0, @code{std} is used for GB computations,
    1502 @*       otherwise, and by default, @code{slimgb} is used.
     1507@*       otherwise, and by default, @code{slimgb} is used. 
    15031508DISPLAY: If printlevel=1, progress debug messages will be printed,
    15041509@*       if printlevel>=2, all the debug messages will be printed.
    1505 EXAMPLE: example bfctann; shows examples
     1510EXAMPLE: example bfctAnn; shows examples
    15061511"
    15071512{

  • Singular/LIB/dmodapp.lib

    ra0350e9 r2653d3  
    11//////////////////////////////////////////////////////////////////////////////
    2 version="$Id: dmodapp.lib,v 1.16 2009-01-14 16:07:04 Singular Exp $";
     2version="$Id: dmodapp.lib,v 1.17 2009-01-15 19:19:08 levandov Exp $";
    33category="Noncommutative";
    44info="
    … …  
    8989"USAGE:  initialIdealW(I,u,v [,s,t]);  I ideal, u,v intvecs, s,t optional ints
    9090RETURN:  ideal, GB of initial ideal of the input ideal wrt the weights u and v
    91 PURPOSE: computes the initial ideal
    92 NOTE:    Assume, I is an ideal in the n-th Weyl algebra D, where the sequence
    93 @*       of the indeterminates is x(1),...,x(n),D(1),...,D(n).
    94 @*       Further assume that u is the weight for the x(i) and v the weight for
    95 @*       the D(i).
    96 @*       Note that the returned ideal is not a D-ideal but an ideal in the associated
     91ASSUME: basering is the n-th Weyl algebra and the sequence of the indeterminates is x(1),...,x(n),D(1),...,D(n).
     92PURPOSE: computes the initial ideal with respect to given weights.
     93NOTE:    Let I be an ideal in the n-th Weyl algebra D, then
     94@*       u and v understood as intvecs of weights for x(i) and D(i) respectively.
     95@*       Note that the returned ideal is not an ideal in D, but an ideal in the associated
    9796@*       graded ring while the Groebner basis is a subset of D.
    9897@*       If s<>0, @code{std} is used for Groebner basis computations, otherwise,
Note: See TracChangeset for help on using the changeset viewer.