Changeset 8c66fb in git


Ignore:
Timestamp:
Dec 1, 2008, 9:51:16 PM (15 years ago)
Author:
Viktor Levandovskyy <levandov@…>
Branches:
(u'spielwiese', '828514cf6e480e4bafc26df99217bf2a1ed1ef45')
Children:
6cd69834c769d788a587c7eaf4413e443e32151d
Parents:
4e803e313f457e20c95ef5350e02ebdfe4a1e3a0
Message:
*levandov: docu changes, help added, static marked


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

Legend:

Unmodified
Added
Removed

  • Singular/LIB/dmodapp.lib

    r4e803e r8c66fb  
    11//////////////////////////////////////////////////////////////////////////////
    2 version="$Id: dmodapp.lib,v 1.10 2008-10-09 09:31:57 Singular Exp $";
     2version="$Id: dmodapp.lib,v 1.11 2008-12-01 20:51:16 levandov Exp $";
    33category="Noncommutative";
    44info="
    … …  
    77@*             Daniel Andres, daniel.andres@math.rwth-aachen.de
    88
    9 GUIDE:
    10 @* - Ann F^s = I = I(F^s) = LD in D(R)[s] can be computed by SannfsBM, SannfsOT, SannfsLOT
    11 @* - global Bernstein polynomial bs resp. BS in K[s] can be computed by bernsteinBM
    12 @* see also dmod.lib
     9GUIDE: Let R = K[x1,..xN] and D be the Weyl algebra in variables x1,..xN,d1,..dN.
     10In this library there are the following procedures for algebraic D-modules:
     11@* - localization of a holonomic module D/I with respect to a mult. closed set
     12of all powers of a given polynomial F from R. Our aim is to compute an ideal L
     13in D, such that D/L is a presentation of a localized module. Such L always exists, since
     14such localizations are known to be holonomic and thus cyclic modules.
     15The procedures for the localization are DLoc, SDLoc and DLoc0.
     16
     17@* - annihilator in Weyl algebra of a given polynomial F from R as well as of a given
     18rational function G/F from Quot(R). These can be computed via annPoly resp. annRat.
     19
     20@* - initial form and initial ideals in Weyl algebras with respect to a given weight vector can be computed with the help of inForm, initialmalgrange, initialideal.
     21
     22@* - appelF1, appelF2 and appelF4 return ideals in parametric Weyl algebra, which
     23annihilate corresponding Appel hypergeometric functions.
     24
    1325
    1426MAIN PROCEDURES:
    15 DLoc(I,F); compute the presentation of the localization of D/I w.r.t. f^s
    16 annRat(f,g); compute the annihilator of a rational function f/g in the corr. Weyl algebra
    17 annPoly(f);  compute the annihilator of a polynomial f in the corr. Weyl algebra
    18 initialmalgrange(f[,s,t,u,v]); compute a Groebner basis of the initial Malgrange ideal for a given poly
    19 initialideal(I,u,v[,s,t]); compute the initial ideal of a given ideal w.r.t. given weights
    20 
    21 SECONDARY PROCEDURES FOR D-MODULES: //todo: no seperate paragraph on web page
    22 isFsat(I, F);            check whether the ideal I is F-saturated
    23 SDLoc(I, F); compute a generic presentation of the localization of D/I w.r.t. f^s, for D a Weyl algebra
    24 DLoc0(I, F); compute the localization of D/I w.r.t. f^s, based on the procedure SDLoc
    25 InForm(f,w);     compute the initial form of a poly/ideal w.r.t. a given weight
    26 
     27
     28annPoly(f);   annihilator of a polynomial f in the corr. Weyl algebra
     29annRat(f,g);  annihilator of a rational function f/g in the corr. Weyl algebra
     30DLoc(I,F);     presentation of the localization of D/I w.r.t. f^s
     31SDLoc(I, F);  a generic presentation of the localization of D/I w.r.t. f^s, for D a Weyl algebra
     32DLoc0(I, F);  presentation of the localization of D/I w.r.t. f^s, based on the procedure SDLoc
     33
     34initialmalgrange(f[,s,t,u,v]); Groebner basis of the initial Malgrange ideal for a given poly
     35initialideal(I,u,v[,s,t]); initial ideal of a given ideal w.r.t. given weights
     36inForm(f,w);     initial form of a poly/ideal w.r.t. a given weight
     37isFsat(I, F);       check whether the ideal I is F-saturated
    2738
    2839AUXILIARY PROCEDURES:
    2940
    30 AppelF1();      create an ideal annihilating Appel F1 function
    31 AppelF2();      create an ideal annihilating Appel F2 function
    32 AppelF4();      create an ideal annihilating Appel F4 function
    33 engine(I,i);   computes a Groebner basis with the algorithm given by i
    34 poly2list(f);    decompose a poly to a list of terms and exponents
     41appelF1();      create an ideal annihilating Appel F1 function
     42appelF2();      create an ideal annihilating Appel F2 function
     43appelF4();      create an ideal annihilating Appel F4 function
     44engine(I,i);     computes a Groebner basis with the algorithm given by i
     45poly2list(f);   decompose a poly to a list of terms and exponents
    3546
    3647SEE ALSO: dmod_lib, gmssing_lib, bfct_lib
    … …  
    5465  example DLoc0;
    5566  example SDLoc;
    56   example InForm;
     67  example inForm;
    5768  example isFsat;
    5869  example annRat;
    5970  example annPoly;
    60   example AppelF1;
    61   example AppelF2;
    62   example AppelF4;
     71  example appelF1;
     72  example appelF2;
     73  example appelF4;
    6374  example poly2list;
    6475}
    … …  
    195206}
    196207
    197 proc initialidealengine(string calledfrom, int whichengine, int blockord, list #)
     208static proc initialidealengine(string calledfrom, int whichengine, int blockord, list #)
    198209{
    199210  //#[1] = f or I
    … …  
    368379  I = subst(I,h,1); // dehomogenization
    369380  dbprint(ppl, "I after dehomogenization is" ,I);
    370   I = InForm(I,uv); // we are only interested in the initial form w.r.t. uv
     381  I = inForm(I,uv); // we are only interested in the initial form w.r.t. uv
    371382  if (calledfrom == "initialmalgrange")
    372383  {
    … …  
    437448}
    438449
    439 proc InForm (list #)
    440 "USAGE:  InForm(f,w) or InForm(I,w);  f a poly, I an ideal, w an intvec
    441 RETURN:  the initial form of f or I w.r.t. the weight vector w
    442 PURPOSE: compute the initial form of a poly or an  ideal w.r.t a given weight
    443 NOTE:    the size of the weight vector must be equal to the number of variables of the basering
    444 EXAMPLE: example InForm; shows examples
     450proc inForm (list #)
     451"USAGE:  inForm(I,w); I an ideal, w an intvec
     452RETURN:  the initial form of I w.r.t. the weight vector w
     453PURPOSE: compute the initial form of an  ideal w.r.t a given weight vector
     454NOTE:  the size of the weight vector must be equal to the number of variables of the basering
     455EXAMPLE: example inForm; shows examples
    445456"
    446457{
    447458  if (size(#)<2)
    448459  {
    449     ERROR("InForm needs two arguments of type poly/ideal,intvec");
     460    ERROR("inForm needs two arguments of type poly/ideal,intvec");
    450461  }
    451462  if (typeof(#[1])=="poly" || typeof(#[1])=="ideal")
    … …  
    513524  intvec w2 = -1,-2,1,2;
    514525  intvec w3 = -2,-3,2,3;
    515   InForm(I,w1);
    516   InForm(I,w2);
    517   InForm(I,w3);
    518   InForm(F,w1);
     526  inForm(I,w1);
     527  inForm(I,w2);
     528  inForm(I,w3);
     529  inForm(F,w1);
    519530}
    520531
    … …  
    629640
    630641
    631 proc AppelF1() //todo: create help string
    632 //(number a,b,c,d)
     642proc appelF1()
     643"USAGE:  appelF1();
     644RETURN:  ring
     645PURPOSE: define the ideal in a parametric Weyl algebra, which annihilates Appel F1 hypergeometric function
     646NOTE: the ideal called  IAppel1 is exported to the output ring
     647EXAMPLE: example appelF1; shows examples
     648"
    633649{
    634650  // Appel F1, d = b', SST p.48
    … …  
    650666  "EXAMPLE:"; echo = 2;
    651667  ring r = 0,x,dp;
    652   def A = AppelF1(); //(1,2,3,4);
     668  def A = appelF1(); //(1,2,3,4);
    653669  setring A;
    654670  IAppel1;
    655671}
    656672
    657 proc AppelF2() //todo: create help string
    658 //(number a,b,c)
     673proc appelF2() //(number a,b,c)
     674"USAGE:  appelF2();
     675RETURN:  ring
     676PURPOSE: define the ideal in a parametric Weyl algebra, which annihilates Appel F2 hypergeometric function
     677NOTE: the ideal called  IAppel2 is exported to the output ring
     678EXAMPLE: example appelF2; shows examples
     679"
    659680{
    660681  // Appel F2, c = b', SST p.85
    … …  
    675696  "EXAMPLE:"; echo = 2;
    676697  ring r = 0,x,dp;
    677   def A = AppelF2(); //(1,2,3,4);
     698  def A = appelF2(); //(1,2,3,4);
    678699  setring A;
    679700  IAppel2;
    680701}
    681702
    682 proc AppelF4() //todo: create help string
    683 //number a,b,c,d - ?
     703proc appelF4()
     704"USAGE:  appelF4();
     705RETURN:  ring
     706PURPOSE: define the ideal in a parametric Weyl algebra, which annihilates Appel F4 hypergeometric function
     707NOTE: the ideal called  IAppel4 is exported to the output ring
     708EXAMPLE: example appelF4; shows examples
     709"
    684710{
    685711  // Appel F4, d = c', SST, p. 39
    … …  
    700726  "EXAMPLE:"; echo = 2;
    701727  ring r = 0,x,dp;
    702   def A = AppelF4(); //(1,2,3,4);
     728  def A = appelF4(); //(1,2,3,4);
    703729  setring A;
    704730  IAppel4;
    … …  
    737763}
    738764
    739 
    740765proc isFsat(ideal I, poly F)
    741766"USAGE:  isFsat(I, F);  I an ideal, F a poly
    742767RETURN: int
    743768PURPOSE: check whether the ideal I is F-saturated
    744 NOTE:    1 is returned if I is F-saturated, otherwise 0 is returned
    745 *   we check indeed that  Ker(D --F--> D/I) is (0) //todo: * or @* ??
     769NOTE:    1 is returned if I is F-saturated, otherwise 0 is returned.
     770@*   we check indeed that Ker(D --F--> D/I) is (0)
    746771EXAMPLE: example isFsat; shows examples
    747772"
    … …  
    13591384  RLD;
    13601385  // Now, compare with the output of Macaulay2:
    1361   ideal tst = 3*x*Dx + 2*y*Dy + 1, y^3*Dy^2 - x^2*Dy^2 + 6*y^2*Dy + 6*y, 9*y^2*Dx^2*Dy - 4*y*Dy^3 + 27*y*Dx^2 + 2*Dy^2, 9*y^3*Dx^2 - 4*y^2*Dy^2 + 10*y*Dy -10; //todo: maybe a bit too long
    1362  option(redSB);
    1363  option(redTail);
     1386  ideal tst = 3*x*Dx + 2*y*Dy + 1, y^3*Dy^2 - x^2*Dy^2 + 6*y^2*Dy + 6*y,
     13879*y^2*Dx^2*Dy - 4*y*Dy^3 + 27*y*Dx^2 + 2*Dy^2, 9*y^3*Dx^2 - 4*y^2*Dy^2 + 10*y*Dy -10;
     1388 option(redSB); option(redTail);
    13641389 RLD = groebner(RLD);
    13651390 tst = groebner(tst);
    13661391 print(matrix(NF(RLD,tst)));  print(matrix(NF(tst,RLD)));
     1392 // So, these two answers are the same
    13671393}
    13681394
    … …  
    15241550}
    15251551
    1526 proc engine(ideal I, int i) //todo: create help string
     1552proc engine(ideal I, int i)
     1553"USAGE:  engine(I,i);  I an ideal, i an int
     1554RETURN:  ideal
     1555PURPOSE: compute the Groebner basis of I with the algorithm, chosen via i
     1556NOTE: By default and if i=0, slimgb is used; otherwise std does the job.
     1557EXAMPLE: example engine; shows examples
     1558"
    15271559{
    15281560  /* std - slimgb mix */
    … …  
    15411573  return(J);
    15421574}
    1543 example //todo: strange: example not showing on web page
     1575example
    15441576{
    15451577  "EXAMPLE:"; echo = 2;

  • Singular/LIB/jacobson.lib

    r4e803e r8c66fb  
    11//////////////////////////////////////////////////////////////////////////////
    2 version="$Id: jacobson.lib,v 1.3 2008-10-10 14:33:54 Singular Exp $";
     2version="$Id: jacobson.lib,v 1.4 2008-12-01 20:51:16 levandov Exp $";
    33category="System and Control Theory";
    44info="
    … …  
    105105  print(s[1]*m*s[3]);
    106106}
    107 proc diagonal_with_trafo( R, matrix MA, int B)
     107
     108static proc diagonal_with_trafo( R, matrix MA, int B)
    108109{
    109110
    … …  
    329330
    330331
    331 proc divisibility(matrix M)
     332static proc divisibility(matrix M)
    332333   {
    333334    matrix STDM=M;
    … …  
    397398}
    398399
    399 proc diagonal_without_trafo( R, matrix MA, int B)
     400static proc diagonal_without_trafo( R, matrix MA, int B)
    400401{
    401402  int ppl = printlevel-voice+2; 
    … …  
    624625
    625626
    626 proc triangle( matrix MA, int B)
     627static proc triangle( matrix MA, int B)
    627628{
    628629 int ppl = printlevel-voice+2;
Note: See TracChangeset for help on using the changeset viewer.