##### 7.5.4.0. SannfsBFCT

Procedure from library `dmod.lib` (see dmod_lib).

Usage:
  SannfsBFCT(f [,a,b,c]); f a poly, a,b,c optional ints

Return:
  ring

Purpose:
  compute a Groebner basis either of Ann(f^s)+<f> or of
  Ann(f^s)+<f,f_1,...,f_n> in D[s]

Note:
  Activate the output ring with the `setring` command.
  This procedure, unlike SannfsBM, returns the ring D[s] with an anti-
  elimination ordering for s.
  The output ring contains an ideal `LD`, being a Groebner basis
  either of Ann(f^s)+<f>, if a=0 (and by default), or of
  Ann(f^s)+<f,f_1,...,f_n>, otherwise.
  Here, f_i stands for the i-th partial derivative of f.
  If b<>0, `std` is used for Groebner basis computations,
  otherwise, and by default `slimgb` is used.
  If c<>0, `std` is used for Groebner basis computations of
  ideals <I+J> when I is already a Groebner basis of <I>.
  Otherwise, and by default the engine determined by the switch b is
  used. Note that in the case c<>0, the choice for b will be
  overwritten only for the types of ideals mentioned above.
  This means that if b<>0, specifying c has no effect.

Display:
  If printlevel=1, progress debug messages will be printed,
  if printlevel>=2, all the debug messages will be printed.

Example:

    LIB "dmod.lib";
    ring r = 0,(x,y,z,w),Dp;
    poly F = x^3+y^3+z^3*w;
    // compute Ann(F^s)+<F> using slimgb only
    def A = SannfsBFCT(F);
    setring A; A;
    ==> // coefficients: QQ considered as a field
    ==> // number of vars : 9
    ==> //        block   1 : ordering dp
    ==> //                  : names    s
    ==> //        block   2 : ordering dp
    ==> //                  : names    x y z w Dx Dy Dz Dw
    ==> //        block   3 : ordering C
    ==> // noncommutative relations:
    ==> //    Dxx=x*Dx+1
    ==> //    Dyy=y*Dy+1
    ==> //    Dzz=z*Dz+1
    ==> //    Dww=w*Dw+1
    LD;
    ==> LD[1]=z*Dz-3*w*Dw
    ==> LD[2]=3*s-x*Dx-y*Dy-3*w*Dw
    ==> LD[3]=y^2*Dx-x^2*Dy
    ==> LD[4]=z^2*w*Dy-y^2*Dz
    ==> LD[5]=z^3*Dy-3*y^2*Dw
    ==> LD[6]=z^2*w*Dx-x^2*Dz
    ==> LD[7]=z^3*Dx-3*x^2*Dw
    ==> LD[8]=z^3*w+x^3+y^3
    ==> LD[9]=x^3*Dy+y^3*Dy+3*y^2*w*Dw+3*y^2
    ==> LD[10]=x^3*Dx+x^2*y*Dy+3*x^2*w*Dw+3*x^2
    ==> LD[11]=3*z*w^2*Dy*Dw-y^2*Dz^2+2*z*w*Dy
    ==> LD[12]=3*z*w^2*Dx*Dw-x^2*Dz^2+2*z*w*Dx
    ==> LD[13]=3*z^2*w^2*Dw+x^3*Dz+y^3*Dz+3*z^2*w
    ==> LD[14]=9*w^3*Dy*Dw^2-y^2*Dz^3+18*w^2*Dy*Dw+2*w*Dy
    ==> LD[15]=9*w^3*Dx*Dw^2-x^2*Dz^3+18*w^2*Dx*Dw+2*w*Dx
    ==> LD[16]=9*z*w^3*Dw^2+x^3*Dz^2+y^3*Dz^2+24*z*w^2*Dw+6*z*w
    ==> LD[17]=27*w^4*Dw^3+x^3*Dz^3+y^3*Dz^3+135*w^3*Dw^2+114*w^2*Dw+6*w
    // the Bernstein-Sato poly of F:
    vec2poly(pIntersect(s,LD));
    ==> s^6+28/3*s^5+320/9*s^4+1910/27*s^3+2093/27*s^2+1198/27*s+280/27
    // a fancier example:
    def R = reiffen(4,5); setring R;
    RC; // the Reiffen curve in 4,5
    ==> xy4+y5+x4
    // compute Ann(RC^s)+<RC,diff(RC,x),diff(RC,y)>
    // using std for GB computations of ideals <I+J>
    // where I is already a GB of <I>
    // and slimgb for other ideals
    def B = SannfsBFCT(RC,1,0,1);
    setring B;
    // the Bernstein-Sato poly of RC:
    (s-1)*vec2poly(pIntersect(s,LD));
    ==> s^13+10*s^12+44*s^11+44099/400*s^10+13355001/80000*s^9+22138611/160000*s^\
       8+1747493/160000*s^7-7874303503/64000000*s^6-4244944536107/25600000000*s^\
       5-3066298289417/25600000000*s^4-2787777479229/51200000000*s^3-19980507461\
       787/1280000000000*s^2-663659243177931/256000000000000*s-48839201079669/25\
       6000000000000

User manual for Singular version 4.4.1, 2025, generated by texi2html.