Changeset 565e866 in git for Singular/LIB/dmod.lib


Ignore:
Timestamp:
Dec 23, 2008, 10:39:31 PM (15 years ago)
Author:
Viktor Levandovskyy <levandov@…>
Branches:
(u'spielwiese', '5b153614cbc72bfa198d75b1e9e33dab2645d9fe')
Children:
199ae72040d35b09813089e33464df761b5aad78
Parents:
6045c31371ebacbf1acfc2f082225f05016f06b2
Message:
*levandov: numerous changes, docu fixes, exchange of procs between libs etc


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

Legend:

Unmodified
Added
Removed
  • Singular/LIB/dmod.lib

    r6045c3 r565e866  
    11//////////////////////////////////////////////////////////////////////////////
    2 version="$Id: dmod.lib,v 1.32 2008-12-09 16:50:21 levandov Exp $";
     2version="$Id: dmod.lib,v 1.33 2008-12-23 21:39:31 levandov Exp $";
    33category="Noncommutative";
    44info="
     
    2727@* OT) the classical Ann F^s algorithm from Oaku and Takayama (J. Pure
    2828        Applied Math., 1999),
    29 @* LOT) Levandovskyy's modification of the Oaku-Takayama algorithm (unpublished)
     29@* LOT) Levandovskyy's modification of the Oaku-Takayama algorithm (ISSAC 2007)
    3030@* BM) the Ann F^s algorithm by Briancon and Maisonobe (Remarques sur
    3131        l'ideal de Bernstein associe a des polynomes, preprint, 2002)
    3232
    3333GUIDE:
    34 @* - Ann F^s = I = I(F^s) = LD in D(R)[s] can be computed by SannfsBM SannfsOT, SannfsLOT
     34@* - Ann F^s = I = I(F^s) = LD in D(R)[s] can be computed by SannfsBM, SannfsOT, SannfsLOT
    3535@* - Ann^(1) F^s in D(R)[s] can be computed by Sannfslog
    3636@* - global Bernstein polynomial bs resp. BS in K[s] can be computed by bernsteinBM
    37 @* - Ann F^s0 = I(F^s0) = LD0 in D(R) can be computed by annfs0, annfsBM, annfsOT, annfsLOT
     37@* - Ann F^s0 = I(F^s0) = LD0 in D(R) can be computed by annfs0, annfsBM, annfsOT, annfsLOT, annfs2
    3838@* - all the relevant data (LD, LD0, bs, PS) are computed by operatorBM
    3939
     
    4949annfsBMI(F[,eng]);      compute Ann F^s and Bernstein ideal for a poly F=f1*..*fP (multivariate algorithm of Briancon-Maisonobe)
    5050checkRoot(F,a[,S,eng]); check if a given rational is a root of the global Bernstein polynomial of F and compute its multiplicity
    51 
    52 SECONDARY PROCEDURES FOR D-MODULES:
    53 
    5451annfsBM(F[,eng]);          compute Ann F^s0 in D and Bernstein poly for a poly F (algorithm of Briancon-Maisonobe)
    5552annfsLOT(F[,eng]);         compute Ann F^s0 in D and Bernstein poly for a poly F (Levandovskyy modification of the Oaku-Takayama algorithm)
    5653annfsOT(F[,eng]);          compute Ann F^s0 in D and Bernstein poly for a poly F (algorithm of Oaku-Takayama)
    5754SannfsBM(F[,eng]);         compute Ann F^s in D[s] for a poly F (algorithm of Briancon-Maisonobe)
    58 SannfsBFCT(F[,eng]);      compute Ann F^s in D[s] for a poly F (algorithm of Briancon-Maisonobe)
     55SannfsBFCT(F[,eng]);      compute Ann F^s in D[s] for a poly F (algorithm of Briancon-Maisonobe, other output ordering)
    5956SannfsLOT(F[,eng]);        compute Ann F^s in D[s] for a poly F (Levandovskyy modification of the Oaku-Takayama algorithm)
    6057SannfsOT(F[,eng]);         compute Ann F^s in D[s] for a poly F (algorithm of Oaku-Takayama)
    61 annfs0(I,F [,eng]);           compute Ann F^s0 in D and Bernstein poly from the known Ann F^s in D[s]
     58annfs0(I,F [,eng]);          compute Ann F^s0 in D and Bernstein poly from the known Ann F^s in D[s]
     59annfs2(I,F [,eng]);           compute Ann F^s0 in D and Bernstein poly from the known Ann F^s in D[s] by using a trick of Noro
     60annfsRB(I,F [,eng]);          compute Ann F^s0 in D and Bernstein poly from the known Ann F^s in D[s] by reduceB strategy of Macaulay
    6261checkRoot1(I,F,a[,eng]);   check whether a rational is a root of the global Bernstein polynomial of F from the known Ann F^s in D[s]
    6362checkRoot2(I,F,a[,eng]);   check whether a rational is a root of the global Bernstein polynomial of F and compute its multiplicity from the known Ann F^s in D[s]
    64 checkFactor(I,F,qs[,eng]); check whether a polynomial qs in K[s] is a factor of the global Bernstein polynomial of F from the known Ann F^s in D[s]
     63checkFactor(I,F,q[,eng]); check whether a polynomial q in K[s] is a factor of the global Bernstein polynomial of F from the known Ann F^s in D[s]
    6564
    6665AUXILIARY PROCEDURES:
     
    7271minIntRoot(P,fact); minimal integer root among the roots of a maximal ideal P
    7372varnum(s);          the number of the variable with the name s
     73
    7474
    7575SEE ALSO: gmssing_lib, bfct_lib, dmodapp_lib
     
    9292  "MAIN PROCEDURES:";
    9393  example annfs;
    94   example annfs0;
    9594  example Sannfs;
    9695  example Sannfslog;
     
    101100  example annfsBMI;
    102101  example checkRoot;
     102  example annfs0;
     103  example annfs2;
     104  example annfsRB;
     105  example annfs2;
    103106  "SECONDARY D-MOD PROCEDURES:";
    104107  example annfsBM;
     
    108111  example SannfsLOT;
    109112  example SannfsOT;
     113  example SannfsBFCT;
    110114  example checkRoot1;
    111115  example checkRoot2;
     
    130134@*       - the ideal LD (which is a Groebner basis) is the needed D-module structure,
    131135@*       - the list  BS is the list of roots and multiplicities of a Bernstein polynomial of f.
    132 @*      If @code{printlevel}=1, progress debug messages will be printed,
    133 @*       if @code{printlevel}>=2, all the debug messages will be printed.
     136DISPLAY: If @code{printlevel}=1, progress debug messages will be printed,
     137@*          if @code{printlevel}>=2, all the debug messages will be printed.
    134138EXAMPLE: example annfs; shows examples
    135139"
     
    252256@*       In the output ring:
    253257@*       - the ideal LD is the needed D-module structure.
    254 @*      If @code{printlevel}=1, progress debug messages will be printed,
    255 @*       if @code{printlevel}>=2, all the debug messages will be printed.
     258DISPLAY: If @code{printlevel}=1, progress debug messages will be printed,
     259@*          if @code{printlevel}>=2, all the debug messages will be printed.
    256260EXAMPLE: example Sannfs; shows examples
    257261"
     
    365369@*       If eng <>0, @code{std} is used for Groebner basis computations,
    366370@*       otherwise, and by default @code{slimgb} is used.
    367 @*       If printlevel=1, progress debug messages will be printed,
    368 @*       if printlevel>=2, all the debug messages will be printed.
     371DISPLAY: If @code{printlevel}=1, progress debug messages will be printed,
     372@*          if @code{printlevel}>=2, all the debug messages will be printed.
    369373EXAMPLE: example Sannfslog; shows examples
    370374"
     
    506510// alternative code for SannfsBM, renamed from annfsBM to ALTannfsBM
    507511// is superfluos - will not be included in the official documentation
    508 proc ALTannfsBM (poly F, list #)
     512static proc ALTannfsBM (poly F, list #)
    509513"USAGE:  ALTannfsBM(f [,eng]);  f a poly, eng an optional int
    510514RETURN:  ring
     
    514518@*       If eng <>0, @code{std} is used for Groebner basis computations,
    515519@*       otherwise, and by default @code{slimgb} is used.
    516 @*       If printlevel=1, progress debug messages will be printed,
    517 @*       if printlevel>=2, all the debug messages will be printed.
     520DISPLAY: If @code{printlevel}=1, progress debug messages will be printed,
     521@*          if @code{printlevel}>=2, all the debug messages will be printed.
    518522EXAMPLE: example ALTannfsBM; shows examples
    519523"
     
    703707NOTE:    If eng <>0, @code{std} is used for Groebner basis computations,
    704708@*       otherwise, and by default @code{slimgb} is used.
    705 @*       If printlevel=1, progress debug messages will be printed,
    706 @*       if printlevel>=2, all the debug messages will be printed.
     709DISPLAY: If @code{printlevel}=1, progress debug messages will be printed,
     710@*          if @code{printlevel}>=2, all the debug messages will be printed.
    707711EXAMPLE: example bernsteinBM; shows examples
    708712"
     
    933937@*       If eng <>0, @code{std} is used for Groebner basis computations,
    934938@*       otherwise, and by default @code{slimgb} is used.
    935 @*       If printlevel=1, progress debug messages will be printed,
    936 @*       if printlevel>=2, all the debug messages will be printed.
     939DISPLAY: If @code{printlevel}=1, progress debug messages will be printed,
     940@*          if @code{printlevel}>=2, all the debug messages will be printed.
    937941EXAMPLE: example annfsBM; shows examples
    938942"
     
    12171221
    12181222
    1219 // try to replace s with -s-1 => data is shorter
     1223// replacing s with -s-1 => data is shorter
    12201224// analogue of annfs0
    12211225proc annfs2(ideal I, poly F, list #)
     
    12231227RETURN:  ring
    12241228PURPOSE: compute the annihilator ideal of f^s in the Weyl Algebra, based on the
    1225 output of procedures SannfsBM, SannfsOT or SannfsLOT
     1229output of Sannfs-like procedure
    12261230NOTE:    activate this ring with the @code{setring} command. In this ring,
    12271231@*       - the ideal LD (which is a Groebner basis) is the annihilator of f^s,
     
    12291233@*       If eng <>0, @code{std} is used for Groebner basis computations,
    12301234@*       otherwise and by default @code{slimgb} is used.
    1231 @*       Uses the shorter form of expressions in the variable s (the idea of Noro).
    1232 @*       If printlevel=1, progress debug messages will be printed,
    1233 @*       if printlevel>=2, all the debug messages will be printed.
     1235@*       annfs2 uses the shorter form of expressions in the variable s (the idea of Noro).
     1236DISPLAY: If @code{printlevel}=1, progress debug messages will be printed,
     1237@*       if @code{printlevel}>=2, all the debug messages will be printed.
    12341238EXAMPLE: example annfs2; shows examples
    12351239"
     
    13901394@*       If eng <>0, @code{std} is used for Groebner basis computations,
    13911395@*       otherwise and by default @code{slimgb} is used.
    1392 @*       Uses the shorter form of expressions in the variable s (the idea of Noro).
    1393 @*       If printlevel=1, progress debug messages will be printed,
    1394 @*       if printlevel>=2, all the debug messages will be printed.
     1396@*       This procedure follows the 'reduceB' strategy, used in Macaulay2.
     1397DISPLAY: If @code{printlevel}=1, progress debug messages will be printed,
     1398@*       if @code{printlevel}>=2, all the debug messages will be printed.
    13951399EXAMPLE: example annfsRB; shows examples
    13961400"
     
    15611565  poly F = x^3+y^3+z^3;
    15621566  printlevel = 0;
    1563   def A = SannfsBM(F);
    1564   setring A;
    1565   LD;
     1567  def A = SannfsBM(F); setring A;
     1568  LD; // s-parametric ahhinilator
    15661569  poly F = imap(r,F);
    1567   def B  = annfsRB(LD,F);
    1568   setring B;
     1570  def B  = annfsRB(LD,F); setring B;
    15691571  LD;
    15701572  BS;
     
    15841586@*       If eng <>0, @code{std} is used for Groebner basis computations,
    15851587@*       otherwise and by default @code{slimgb} is used.
    1586 @*       If printlevel=1, progress debug messages will be printed,
    1587 @*       if printlevel>=2, all the debug messages will be printed.
     1588DISPLAY: If @code{printlevel}=1, progress debug messages will be printed,
     1589@*       if @code{printlevel}>=2, all the debug messages will be printed.
    15881590EXAMPLE: example operatorBM; shows examples
    15891591"
     
    18891891// for this, do special modulo with emphasis on the 2comp
    18901892// of the transp matrix, there must appear 1 in the GB
     1893// then use lift to get the expression...
    18911894// need: (c,<) ordering for such comp's
    18921895
    1893 // proc operatorModulo(poly F, ideal I, poly b)
    1894 // "USAGE:  operatorModulo(f,I,b);  f a poly, I an ideal, b a poly
    1895 // RETURN:  poly
    1896 // PURPOSE: compute the B-operator from the poly F, ideal I = Ann f^s and Bernstein-Sato
    1897 // polynomial b using modulo
    1898 // NOTE:  The computations take place in the ring, similar to the one returned by Sannfs procedure.
    1899 // @*       If printlevel=1, progress debug messages will be printed,
    1900 // @*       if printlevel>=2, all the debug messages will be printed.
    1901 // EXAMPLE: example operatorModulo; shows examples
    1902 // "
    1903 // {
    1904 //   // with hom_kernel;
    1905 //   matrix AA[1][2] = F,-b;
    1906 //   //  matrix M = matrix(subst(I,s,s+1)*freemodule(2)); // ann f^{s+1}
    1907 //   matrix N = matrix(I); // ann f^s
    1908 //   //  matrix K = hom_kernel(AA,M,N);
    1909 //   matrix K = modulo(AA,N);
    1910 //   K = transpose(K);
    1911 //   print(K);
    1912 //   ideal J;
    1913 //   int i;
    1914 //   poly t; number n;
    1915 //   for(i=1; i<=nrows(K); i++)
    1916 //   {
    1917 //     if (K[i,2]!=0)
    1918 //     {
    1919 //       if ( leadmonom(K[i,2]) == 1)
    1920 //       {
    1921 //      t = K[i,1];
    1922 //      n = leadcoef(K[i,2]);
    1923 //      t = t/n;
    1924 //      //        J = J, K[i][2];
    1925 //      break;
    1926 //       }
    1927 //     }
    1928 //   }
    1929 //   ideal J = groebner(subst(I,s,s+1)); // for NF
    1930 //   t = NF(t,J);
    1931 //   "candidate:"; t;
    1932 //   J = subst(J,s,s-1);
    1933 //   // test:
    1934 //   if ( NF(t*F-b,J) !=0)
    1935 //   {
    1936 //     "Problem: PS does not work on F";
    1937 //   }
    1938 //   return(t);
    1939 // }
    1940 // example
    1941 // {
    1942 //   "EXAMPLE:"; echo = 2;
    1943 //   //  ring r = 0,(x,y,z),Dp;
    1944 //   //   poly F = x^3+y^3+z^3;
    1945 //   LIB "dmod.lib"; option(prot); option(mem);
    1946 //   ring r = 0,(x,y),Dp;
    1947 //   //  poly F = x^3+y^3+x*y^2;
    1948 //   poly F = x^4 + y^4 + x*y^4;
    1949 //   def A = Sannfs(F); // here we get LD = ann f^s
    1950 //   setring A;
    1951 //   poly F = imap(r,F);
    1952 //   def B = annfs0(LD,F); // to obtain BS polynomial
    1953 //   list BS = imap(B,BS);
    1954 //   poly b = fl2poly(BS,"s");
    1955 //   LD = groebner(LD);
    1956 //   poly PS = operatorModulo(F,LD,b);
    1957 //   PS; // the operator, s.t. PS*F^{s+1} = bs*F^s mod LD
    1958 //   reduce(PS*F-bs,LD); // check the property of PS
    1959 // }
    1960 
    1961 proc fl2poly(list L, string s)
    1962 "USAGE:  fl2poly(L,s); L a list, s a string
     1896/*
     1897proc operatorModulo(poly F, ideal I, poly b)
     1898"USAGE:  operatorModulo(f,I,b);  f a poly, I an ideal, b a poly
    19631899RETURN:  poly
    1964 PURPOSE: reconstruct a monic polynomial in one variable from its factorization
    1965 ASSUME:  s is a string with the name of some variable and L is supposed to consist of two entries:
    1966 @*         L[1] of the type ideal with the roots of a polynomial
    1967 @*         L[2] of the type intvec with the multiplicities of corr. roots
    1968 EXAMPLE: example fl2poly; shows examples
     1900PURPOSE: compute the B-operator from the poly F, ideal I = Ann f^s and Bernstein-Sato
     1901polynomial b using modulo
     1902NOTE:  The computations take place in the ring, similar to the one returned by Sannfs procedure.
     1903@*       If printlevel=1, progress debug messages will be printed,
     1904@*       if printlevel>=2, all the debug messages will be printed.
     1905EXAMPLE: example operatorModulo; shows examples
    19691906"
    19701907{
    1971   if (varnum(s)==0)
    1972   {
    1973     ERROR("no such variable found"); return(0);
    1974   }
    1975   poly x = var(varnum(s));
    1976   poly P = 1;
    1977   int sl = size(L[1]);
    1978   ideal RR = L[1];
    1979   intvec IV = L[2];
    1980   for(int i=1; i<= sl; i++)
    1981   {
    1982     P = P*((x-RR[i])^IV[i]);
    1983   }
    1984   return(P);
     1908  // with hom_kernel;
     1909  matrix AA[1][2] = F,-b;
     1910  //  matrix M = matrix(subst(I,s,s+1)*freemodule(2)); // ann f^{s+1}
     1911  matrix N = matrix(I); // ann f^s
     1912  //  matrix K = hom_kernel(AA,M,N);
     1913  matrix K = modulo(AA,N);
     1914  K = transpose(K);
     1915  print(K);
     1916  ideal J;
     1917  int i;
     1918  poly t; number n;
     1919  for(i=1; i<=nrows(K); i++)
     1920  {
     1921    if (K[i,2]!=0)
     1922    {
     1923      if ( leadmonom(K[i,2]) == 1)
     1924      {
     1925        t = K[i,1];
     1926        n = leadcoef(K[i,2]);
     1927        t = t/n;
     1928        //        J = J, K[i][2];
     1929        break;
     1930      }
     1931    }
     1932  }
     1933  ideal J = groebner(subst(I,s,s+1)); // for NF
     1934  t = NF(t,J);
     1935  "candidate:"; t;
     1936  J = subst(J,s,s-1);
     1937  // test:
     1938  if ( NF(t*F-b,J) !=0)
     1939  {
     1940    "Problem: PS does not work on F";
     1941  }
     1942  return(t);
    19851943}
    19861944example
    19871945{
    19881946  "EXAMPLE:"; echo = 2;
    1989   ring r = 0,(x,y,z,s),Dp;
    1990   ideal I = -1,-4/3,-5/3,-2;
    1991   intvec mI = 2,1,1,1;
    1992   list BS = I,mI;
    1993   poly p = fl2poly(BS,"s");
    1994   p;
    1995   factorize(p,2);
    1996 }
     1947  //  ring r = 0,(x,y,z),Dp;
     1948  //   poly F = x^3+y^3+z^3;
     1949  LIB "dmod.lib"; option(prot); option(mem);
     1950  ring r = 0,(x,y),Dp;
     1951  //  poly F = x^3+y^3+x*y^2;
     1952  poly F = x^4 + y^4 + x*y^4;
     1953  def A = Sannfs(F); // here we get LD = ann f^s
     1954  setring A;
     1955  poly F = imap(r,F);
     1956  def B = annfs0(LD,F); // to obtain BS polynomial
     1957  list BS = imap(B,BS);
     1958  poly b = fl2poly(BS,"s");
     1959  LD = groebner(LD);
     1960  poly PS = operatorModulo(F,LD,b);
     1961  PS; // the operator, s.t. PS*F^{s+1} = bs*F^s mod LD
     1962  reduce(PS*F-bs,LD); // check the property of PS
     1963}
     1964*/
     1965
     1966
    19971967
    19981968proc annfsParamBM (poly F, list #)
     
    20051975@*       If eng <>0, @code{std} is used for Groebner basis computations,
    20061976@*       otherwise, and by default @code{slimgb} is used.
    2007 @*       If printlevel=1, progress debug messages will be printed,
    2008 @*       if printlevel>=2, all the debug messages will be printed.
     1977DISPLAY: If @code{printlevel}=1, progress debug messages will be printed,
     1978@*          if @code{printlevel}>=2, all the debug messages will be printed.
    20091979EXAMPLE: example annfsParamBM; shows examples
    20101980"
     
    34453415@*       If eng <>0, @code{std} is used for Groebner basis computations,
    34463416@*       otherwise, and by default @code{slimgb} is used.
    3447 @*      If printlevel=1, progress debug messages will be printed,
     3417DISPLAY: If printlevel=1, progress debug messages will be printed,
    34483418@*       if printlevel>=2, all the debug messages will be printed.
    34493419EXAMPLE: example SannfsBFCT; shows examples
     
    36373607  poly F = x^3+y^3+z^3*w;
    36383608  printlevel = 0;
    3639   def A = SannfsBFCT(F);
    3640   setring A;
     3609  def A = SannfsBFCT(F); setring A;
    36413610  intvec v = 1,2,3,4,5,6,7,8;
    36423611  // are there polynomials, depending on s only?
    36433612  nselect(LD,v);
    36443613  // a fancier example:
    3645   def R = reiffen(4,5);
    3646   setring R;
     3614  def R = reiffen(4,5); setring R;
    36473615  v = 1,2,3,4;
     3616  RC; // the Reiffen curve in 4,5
    36483617  def B = SannfsBFCT(RC);
    36493618  setring B;
     
    38853854}
    38863855
    3887 
     3856/*
    38883857proc SannfsLOTold(poly F, list #)
    38893858"USAGE:  SannfsLOT(f [,eng]);  f a poly, eng an optional int
     
    41094078}
    41104079
     4080*/
    41114081
    41124082proc annfsLOT(poly F, list #)
     
    41584128RETURN:  ring
    41594129PURPOSE: compute the annihilator ideal of f^s in the Weyl Algebra, based on the
    4160 output of procedures SannfsBM, SannfsOT or SannfsLOT
     4130output of Sannfs-like procedure
    41614131NOTE:    activate this ring with the @code{setring} command. In this ring,
    41624132@*       - the ideal LD (which is a Groebner basis) is the annihilator of f^s,
     
    42994269  poly F = x^3+y^3+z^3;
    43004270  printlevel = 0;
    4301   def A = SannfsBM(F);
     4271  def A = SannfsBM(F);   setring A;
    43024272  // alternatively, one can use SannfsOT or SannfsLOT
    4303   setring A;
    43044273  LD;
    43054274  poly F = imap(r,F);
    4306   def B  = annfs0(LD,F);
    4307   setring B;
     4275  def B  = annfs0(LD,F);  setring B;
    43084276  LD;
    43094277  BS;
     
    46564624@*       We compute the real annihilator for any rational value of n (both generic and exceptional).
    46574625@*       The implementation goes along the lines of Saito-Sturmfels-Takayama, Alg. 5.3.15
    4658 @*      If printlevel=1, progress debug messages will be printed,
     4626DISPLAY: If printlevel=1, progress debug messages will be printed,
    46594627@*       if printlevel>=2, all the debug messages will be printed.
    46604628EXAMPLE: example annfspecial; shows examples
     
    47244692}
    47254693
    4726 static proc new_ex_annfspecial()
     4694/*
     4695//static proc new_ex_annfspecial()
    47274696{
    47284697  //another example for annfspecial: x3+y3+z3
     
    47404709  annfspecial(LD,F,-1,1);   // exceptional root
    47414710}
     4711*/
    47424712
    47434713proc minIntRoot(ideal P, int fact)
     
    48174787"USAGE:  isHolonomic(M); M an ideal/module/matrix
    48184788RETURN:  int, 1 if M is holonomic and 0 otherwise
     4789ASSUME: basering is a Weyl algebra
    48194790PURPOSE: check the modules for the property of holonomy
    48204791NOTE:    M is holonomic, if 2*dim(M) = dim(R), where R is a
     
    49564927@*       'alg1' (default) - for the algorithm 1 of J. Martin-Morales (unpublished)
    49574928@*       'alg2' - for the algorithm 2 of J. Martin-Morales (unpublished)
    4958 @*       The output int is:
    4959 @*       - if the algorithm 1 is chosen: 1 if -alpha is a root of the global Bernstein polynomial and 0 otherwise
    4960 @*       - if the algorithm 2 is chosen: the multiplicity of -alpha as a root of the global Bernstein polynomial of f.
    4961 @*                                       (If -alpha is not a root, the output is 0)
     4929@*       The output of type int is:
     4930@*       'alg1': 1 if -alpha is a root of the global Bernstein polynomial and 0 otherwise
     4931@*       'alg2': the multiplicity of -alpha as a root of the global Bernstein polynomial of f.
     4932@*                (If -alpha is not a root, the output is 0)
    49624933@*       If eng <>0, @code{std} is used for Groebner basis computations,
    49634934@*       otherwise (and by default) @code{slimgb} is used.
    4964 @*      If printlevel=1, progress debug messages will be printed,
    4965 @*       if printlevel>=2, all the debug messages will be printed.
     4935DISPLAY: If printlevel=1, progress debug messages will be printed,
     4936@*          if printlevel>=2, all the debug messages will be printed.
    49664937EXAMPLE: example checkRoot; shows examples
    49674938"
     
    50685039NOTE:    If eng <>0, @code{std} is used for Groebner basis computations,
    50695040@*       otherwise (and by default) @code{slimgb} is used.
    5070 @*      If printlevel=1, progress debug messages will be printed,
    5071 @*       if printlevel>=2, all the debug messages will be printed.
     5041DISPLAY: If printlevel=1, progress debug messages will be printed,
     5042@*          if printlevel>=2, all the debug messages will be printed.
    50725043EXAMPLE: example checkRoot1; shows examples
    50735044"
     
    51925163NOTE:    If eng <>0, @code{std} is used for Groebner basis computations,
    51935164@*       otherwise (and by default) @code{slimgb} is used.
    5194 @*      If printlevel=1, progress debug messages will be printed,
    5195 @*       if printlevel>=2, all the debug messages will be printed.
     5165DISPLAY: If printlevel=1, progress debug messages will be printed,
     5166@*          if printlevel>=2, all the debug messages will be printed.
    51965167EXAMPLE: example checkRoot2; shows examples
    51975168"
     
    53245295NOTE:    If eng <>0, @code{std} is used for Groebner basis computations,
    53255296@*       otherwise (and by default) @code{slimgb} is used.
    5326 @*      If printlevel=1, progress debug messages will be printed,
    5327 @*       if printlevel>=2, all the debug messages will be printed.
     5297DISPLAY: If printlevel=1, progress debug messages will be printed,
     5298@*          if printlevel>=2, all the debug messages will be printed.
    53285299EXAMPLE: example checkFactor; shows examples
    53295300"
     
    54615432}
    54625433
    5463 
    5464 static proc exCheckGenericity()
     5434/// ****** EXAMPLES ************
     5435
     5436/*
     5437
     5438//static proc exCheckGenericity()
    54655439{
    54665440  LIB "control.lib";
     
    54845458}
    54855459
    5486 static proc exOT_17()
     5460//static proc exOT_17()
    54875461{
    54885462  // Oaku-Takayama, p.208
     
    54995473}
    55005474
    5501 static proc exOT_16()
     5475//static proc exOT_16()
    55025476{
    55035477  // Oaku-Takayama, p.208
     
    55135487}
    55145488
    5515 static proc ex_bcheck()
     5489//static proc ex_bcheck()
    55165490{
    55175491  ring R = 0,(x,y),dp;
     
    55265500}
    55275501
    5528 static proc ex_bcheck2()
     5502//static proc ex_bcheck2()
    55295503{
    55305504  ring R = 0,(x,y),dp;
     
    55365510}
    55375511
    5538 static proc ex_BMI()
     5512//static proc ex_BMI()
    55395513{
    55405514  // a hard example
     
    55495523}
    55505524
    5551 static proc ex2_BMI()
     5525//static proc ex2_BMI()
    55525526{
    55535527  // this example was believed to be intractable in 2005 by Gago-Vargas, Castro and Ucha
     
    55635537}
    55645538
    5565 static proc ex_operatorBM()
     5539//static proc ex_operatorBM()
    55665540{
    55675541  ring r = 0,(x,y,z,w),Dp;
     
    55785552  reduce(PS*F-bs,LD); // check the property of PS
    55795553}
     5554
     5555*/
Note: See TracChangeset for help on using the changeset viewer.