# Changeset d41540 in git

Ignore:
Timestamp:
Apr 9, 2009, 2:04:42 PM (14 years ago)
Branches:
Children:
Parents:
Message:
removed some typos etc. prior to release 3-1-0

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

Unmodified
Removed
• ## Singular/LIB/dmod.lib

 rad711e6 ////////////////////////////////////////////////////////////////////////////// version="$Id: dmod.lib,v 1.38 2009-04-08 16:51:07 seelisch Exp$"; version="$Id: dmod.lib,v 1.39 2009-04-09 12:04:41 seelisch Exp$"; category="Noncommutative"; info=" convloc(L);         replace global orderings with local in the ringlist L minIntRoot(P,fact); minimal integer root among the roots of a maximal ideal P varnum(s);          the number of the variable with the name s varNum(s);          the number of the variable with the name s isRational(n);  check whether n is a rational number RETURN:  ring PURPOSE: compute the D-module structure of basering[1/f]*f^s NOTE:    activate this ring with the @code{setring} command. NOTE:    activate the output ring with the @code{setring} command. @*   In the output ring D[s], the ideal LD1 is generated by the elements @*   in Ann F^s in D[s], coming from logarithmic derivations. PURPOSE: compute the annihilator ideal of f^s in D[s], where D is the Weyl @*   algebra, according to the algorithm by Briancon and Maisonobe NOTE:  Activate this ring with the @code{setring} command. In this ring, NOTE:  activate the output ring with the @code{setring} command. In this ring, @*       - the ideal LD is the annihilator of f^s. @*       If eng <>0, @code{std} is used for Groebner basis computations, PURPOSE: compute the D-module structure of basering[1/f]*f^s, according @* to the algorithm by Briancon and Maisonobe NOTE:    activate this ring with the @code{setring} command. In this ring, NOTE:    activate the output ring with the @code{setring} command. In this ring, @*       - the ideal LD (which is a Groebner basis) is the needed D-module structure, @*         which is obtained by substituting the minimal integer root of a Bernstein RETURN:  ring PURPOSE: compute the annihilator ideal of f^s in the Weyl Algebra, @*           based on the output of Sannfs-like procedure NOTE: Activate this ring with the @code{setring} command. In this ring, @*       based on the output of Sannfs-like procedure @*       annfs2 uses shorter expressions in the variable s (the idea of Noro). NOTE: activate the output ring with the @code{setring} command. In this ring, @*      - the ideal LD (which is a Groebner basis) is the annihilator of f^s, @*      - the list BS contains the roots with multiplicities of the BS polynomial. @*    If eng <>0, @code{std} is used for Groebner basis computations, @*    otherwise and by default @code{slimgb} is used. @* annfs2 uses shorter expressions in the variable s (the idea of Noro). DISPLAY: If @code{printlevel}=1, progress debug messages will be printed, @*       if @code{printlevel}>=2, all the debug messages will be printed. PURPOSE: compute the annihilator ideal of f^s in the Weyl Algebra, @* based on the output of Sannfs like procedure NOTE:    activate this ring with the @code{setring} command. In this ring, NOTE:    activate the output ring with the @code{setring} command. In this ring, @*       - the ideal LD (which is a Groebner basis) is the annihilator of f^s, @*       - the list BS contains the roots with multiplicities of a Bernstein polynomial of f. PURPOSE: compute the generic Ann F^s and exceptional parametric constellations @* of a polynomial with parametric coefficients with the BM algorithm NOTE:    activate this ring with the @code{setring} command. In this ring, NOTE:    activate the output ring with the @code{setring} command. In this ring, @*       - the ideal LD is the D-module structure oa Ann F^s @*       - the ideal Param contains the list of the special parameters. @*       - the ideal Param contains special parameters as entries @*       If eng <>0, @code{std} is used for Groebner basis computations, @*       otherwise, and by default @code{slimgb} is used. PURPOSE: compute the D-module structure of basering[1/f]*f^s where @* f = F[1]*..*F[P], according to the algorithm by Briancon and Maisonobe. NOTE:    activate this ring with the @code{setring} command. In this ring, NOTE:    activate the output ring with the @code{setring} command. In this ring, @*       - the ideal LD is the needed D-mod structure, @*       - the list BS is the Bernstein ideal of a polynomial f = F[1]*..*F[P]. PURPOSE: compute the D-module structure of basering[1/f]*f^s, @* according to the algorithm by Oaku and Takayama NOTE:    activate this ring with the @code{setring} command. In this ring, NOTE:    activate the output ring with the @code{setring} command. In this ring, @*       - the ideal LD (which is a Groebner basis) is the needed D-module structure, @*         which is obtained by substituting the minimal integer root of a Bernstein PURPOSE: compute the D-module structure of basering[1/f]*f^s, according to the @* 1st step of the algorithm by Oaku and Takayama in the ring D[s] NOTE:    activate this ring with the @code{setring} command. NOTE:    activate the output ring with the @code{setring} command. @*  In the output ring D[s], the ideal LD (which is NOT a Groebner basis) @*  is the needed D-module structure. PURPOSE: compute the D-module structure of basering[1/f]*f^s, according to the @* 1st step of the algorithm by Briancon and Maisonobe in the ring D[s]. NOTE:  Activate this ring with the @code{setring} command. NOTE:  activate the output ring with the @code{setring} command. @*   In the output ring D[s], the ideal LD (which is NOT a Groebner basis) is @*   the needed D-module structure. RETURN:  ring PURPOSE: compute Ann f^s and Groebner basis of Ann f^s+f in D[s] NOTE:    activate this ring with the @code{setring} command. NOTE:    activate the output ring with the @code{setring} command. @*  This procedure, unlike SannfsBM, returns a ring with the degrevlex @*  ordering in all variables. @*  In the ring D[s], the ideal LD (which IS a Groebner basis) is the needed ideal. @*  In the ring D[s], the ideal LD is the ideal needed (which is returned as a Groebner basis). @*  If eng <>0, @code{std} is used for Groebner basis computations, @*  otherwise, and by default @code{slimgb} is used. // Are there polynomials, depending on @s only? nselect(LD,v); // It is not the case. Are there leading monomials in @s only? // It is not the case. Are there leading terms in @s only? nselect(lead(LD),v); } RETURN:  ring PURPOSE: compute Ann f^s and Groebner basis of Ann f^s+f in D[s] NOTE:    activate this ring with the @code{setring} command. NOTE:    activate the output ring with the @code{setring} command. @*    This procedure, unlike SannfsBM, returns a ring with the degrevlex @*    ordering in all variables. PURPOSE: compute the D-module structure of basering[1/f]*f^s, according to the @* Levandovskyy's modification of the algorithm by Oaku and Takayama in D[s] NOTE:    activate this ring with the @code{setring} command. NOTE:    activate the output ring with the @code{setring} command. @*    In the ring D[s], the ideal LD (which is NOT a Groebner basis) is @*    the needed D-module structure. RETURN:  ring PURPOSE: compute the D-module structure of basering[1/f]*f^s, according to the Levandovskyy's modification of the algorithm by Oaku and Takayama in the ring D[s], where D is the Weyl algebra NOTE:    activate this ring with the @code{setring} command. NOTE:    activate the output ring with the @code{setring} command. @*       In the ring D[s], the ideal LD (which is NOT a Groebner basis) is the needed D-module structure. @*       If eng <>0, @code{std} is used for Groebner basis computations, PURPOSE: compute the D-module structure of basering[1/f]*f^s, according to @* the Levandovskyy's modification of the algorithm by Oaku and Takayama NOTE:    activate this ring with the @code{setring} command. In this ring, NOTE:    activate the output ring with the @code{setring} command. In this ring, @*  - the ideal LD (which is a Groebner basis) is the needed D-module structure, @*    which is obtained by substituting the minimal integer root of a Bernstein PURPOSE: compute the annihilator ideal of f^s in the Weyl Algebra, based @* on the output of Sannfs-like procedure NOTE:    activate this ring with the @code{setring} command. In this ring, NOTE:    activate the output ring with the @code{setring} command. In this ring, @* - the ideal LD (which is a Groebner basis) is the annihilator of f^s, @* - the list BS contains the roots with multiplicities of BS polynomial of f. // RETURN:  ring // PURPOSE: compute the D-module structure of basering[1/f]*f^s // NOTE:    activate this ring with the @code{setring} command. In this ring, // NOTE:    activate the output ring with the @code{setring} command. In this ring, // @*       - the ideal LD is the needed D-mod structure, // @*       - the ideal BS is the list of roots of a Bernstein polynomial of f. RETURN:  list PURPOSE: convert a ringlist L into another ringlist, @* where all the 'p' orderings are replaced with the 's' orderings. @* where all the 'p' orderings are replaced with the 's' orderings, e.g. @code{dp} by @code{ds}. ASSUME: L is a result of a ringlist command EXAMPLE: example convloc; shows examples int ppl = printlevel-voice+2; //  int mir =  minIntRoot(L[1],0); int ns   = varnum("s"); int ns   = varNum("s"); if (!ns) { poly f1  = x*y*(x+y); ideal I1 = bernstein(f1)[1]; // a local Bernstein poly I1; minIntRoot(I1,0); poly  f2  = x2-y3; ideal I2  = bernstein(f2)[1]; I2; minIntRoot(I2,0); // now we illustrate the behaviour of factorize poly f3   = 9*(x+2/3)*(x+1)*(x+4/3); //global b-poly of f1=x*y*(x+y) ideal I3 = factorize(f3,1); I3; minIntRoot(I3,1); // and a more interesting situation poly  f  = x3 + y3 + z3; ideal I  = bernstein(f)[1]; I; minIntRoot(I,0); } proc isHolonomic(def M) "USAGE:  isHolonomic(M); M an ideal/module/matrix RETURN:  int, 1 if M is holonomic and 0 otherwise RETURN:  int, 1 if M is holonomic over the base ring, and 0 otherwise ASSUME: basering is a Weyl algebra in characteristic 0 PURPOSE: check the modules for the property of holonomy NOTE:    M is holonomic, if 2*dim(M) = dim(R), where R is a ground ring; dim stays for Gelfand-Kirillov dimension PURPOSE: check whether M is holonomic over the base ring NOTE:    M is holonomic if 2*dim(M) = dim(R), where R is the base ring; dim stays for Gelfand-Kirillov dimension EXAMPLE: example isHolonomic; shows examples " RETURN:  ring PURPOSE: set up the polynomial, describing a Reiffen curve NOTE:  activate this ring with the @code{setring} command and NOTE:  activate the output ring with the @code{setring} command and @*       find the curve as a polynomial RC. @*  A Reiffen curve is defined as F = x^p + y^q + xy^{q-1}, q >= p+1 >= 5 @*  A Reiffen curve is defined as RC = x^p + y^q + xy^{q-1}, q >= p+1 >= 5 EXAMPLE: example reiffen; shows examples "USAGE:  checkRoot(f,alpha [,S,eng]);  poly f, number alpha, string S, int eng RETURN:  int ASSUME: Basering is commutative ring, alpha is a rational number. ASSUME: Basering is a commutative ring, alpha is a rational number. PURPOSE: check whether a rational number alpha is a root of the global @* Bernstein-Sato polynomial of f and compute its multiplicity, @*       'alg1' (default) - for the algorithm 1 of [LM08] @*       'alg2' - for the algorithm 2 of [LM08] @*       The output of type int is: @*       Depending on the value of S, the output of type int is: @*       'alg1': 1 only if -alpha is a root of the global Bernstein-Sato polynomial @*       'alg2':  the multiplicity of -alpha as a root of the global Bernstein-Sato ASSUME:  Basering is D[s], I is the annihilator of f^s in D[s], @* that is basering and I are the output of Sannfs-like procedure, @* f is a polynomial in K[_x] and alpha is a rational number. @* f is a polynomial in K[x] and alpha is a rational number. RETURN:  int, 1 if -alpha is a root of the Bernstein-Sato polynomial of f PURPOSE: check, whether alpha is a root of the global Bernstein-Sato polynomial of f } proc varnum(string s) "USAGE:  varnum(s);  string s proc varNum(string s) "USAGE:  varNum(s);  string s RETURN:  int PURPOSE: returns the number of the variable with the name s @*  among the variables of basering or 0 if there is no such variable EXAMPLE: example varnum; shows examples EXAMPLE: example varNum; shows examples " { { "EXAMPLE:"; echo = 2; ring X = 0,(x,y1,z(0),tTa),dp; varnum("z(0)"); varnum("tTa"); varnum("xyz"); ring X = 0,(x,y1,t,z(0),z,tTa),dp; varNum("z"); varNum("t"); varNum("xyz"); }
• ## Singular/LIB/dmodapp.lib

 rad711e6 ////////////////////////////////////////////////////////////////////////////// version="$Id: dmodapp.lib,v 1.25 2009-03-11 09:43:29 Singular Exp$"; version="$Id: dmodapp.lib,v 1.26 2009-04-09 12:04:41 seelisch Exp$"; category="Noncommutative"; info=" @* cyclic modules. The procedures for the localization are DLoc,SDLoc and DLoc0. @* @* - annihilator in Weyl algebra of a given polynomial F from R as well as @* - annihilator in D of a given polynomial F from R as well as @* of a given rational function G/F from Quot(R). These can be computed via @* procedures annPoly resp. annRat. "USAGE:  annRat(g,f);  f, g polynomials RETURN:  ring PURPOSE: compute the annihilator of the rational function g/f in Weyl algebra PURPOSE: compute the annihilator of the rational function g/f in the Weyl algebra D NOTE: activate the output ring with the @code{setring} command. @*      In the output ring, the ideal LD (in Groebner basis) is the annihilator. "USAGE:  annPoly(f);  f a poly RETURN:  ring PURPOSE: compute the complete annihilator ideal of f in Weyl algebra PURPOSE: compute the complete annihilator ideal of f in the Weyl algebra D NOTE:  activate the output ring with the @code{setring} command. @*   In the output ring, the ideal LD (in Groebner basis) is the annihilator. "USAGE:  insertGenerator(id,p[,k]);  id an ideal/module, p a poly/vector, k an optional int RETURN:  same as id PURPOSE: insert an element into an ideal or a module PURPOSE: inserts p into the first argument at k-th index position and returns the enlarged object NOTE:    If k is given, p is inserted at position k, otherwise (and by default), @*       p is inserted at the beginning. "USAGE:  deleteGenerator(id,k);  id an ideal/module, k an int RETURN:  same as id PURPOSE: deletes the k-th element from an ideal or a module PURPOSE: deletes the k-th generator from the first argument and returns the altered object EXAMPLE: example insertGenerator; shows examples " "USAGE:  bFactor(f);  f poly RETURN:  list PURPOSE: computes the roots of irreducible factors of an univariate poly PURPOSE: tries to compute the roots of a univariate poly f NOTE:    The output list consists of two or three entries: @*       the roots of f as ideal, their multiplicities as intvec, and, @*       roots of f as an ideal, their multiplicities as intvec, and, @*       if present, a third one being the product of all irreducible factors @*       of degree greater than one, given as string.
• ## Singular/LIB/freegb.lib

 rad711e6 ////////////////////////////////////////////////////////////////////////////// version="$Id: freegb.lib,v 1.20 2009-04-08 11:11:20 Singular Exp$"; version="$Id: freegb.lib,v 1.21 2009-04-09 12:04:41 seelisch Exp$"; category="Noncommutative"; info=" LIBRARY: freegb.lib   Twosided Noncommutative Groebner bases in Free Algebras via Letterplace LIBRARY: freegb.lib   Compute two-sided Groebner bases in free algebras via letterplace AUTHOR: Viktor Levandovskyy,     levandov@math.rwth-aachen.de "USAGE: setLetterplaceAttributes(R, d, b); R a ring, b,d integers RETURN: ring with special attributes set PURPOSE: sets attributes for a letterplace ring: PURPOSE: sets attributes for a letterplace ring: @*      'isLetterplaceRing' = true, 'uptodeg' = d, 'lV' = b, where @*      'uptodeg' stands for the degree bound, @*      'lV' for the number of variables in the block 0. NOTE: Activate the resulting ring by using @code{setring} " { PURPOSE: compute the two-sided Groebner basis of an ideal, encoded by L in the free associative algebra, up to degree d NOTE: Apply @code{lst2str} to the output in order to obtain a human-readable representation EXAMPLE: example freeGBasis; shows examples " proc lp2lstr(ideal K, def save) "USAGE:  lp2lstr(K,s); K an ideal, s a ring RETURN:  nothing (exports object @LN into s) "USAGE:  lp2lstr(K,s); K an ideal, s a ring name RETURN:  nothing (exports object @LN into the ring named s) ASSUME: basering has a letterplace ring structure PURPOSE: converts letterplace ideal to list of modules "EXAMPLE:"; echo = 2; // define a ring in letterplace form as follows: ring r = 0,(x(1),y(1),x(2),y(2),x(3),y(3),x(4),y(4)),dp; poly a = x(1)*y(2); poly b = y(1); ring r = 0,(x(1),y(1),x(2),y(2),x(3),y(3),x(4),y(4)),dp; def R = setLetterplaceAttributes(r,4,2); // supply R with letterplace structure setring R; poly a = x(1)*y(2); poly b = y(1); lpMult(b,a); lpMult(a,b);
• ## Singular/LIB/gkdim.lib

 rad711e6 /////////////////////////////////////////////////////////////////////////////// version="$Id: gkdim.lib,v 1.11 2007-11-28 16:36:45 motsak Exp$"; version="$Id: gkdim.lib,v 1.12 2009-04-09 12:04:41 seelisch Exp$"; category="Noncommutative"; info=" LIBRARY: GKdim.lib     Procedures for calculating the Gelfand-Kirillov dimension LIBRARY: gkdim.lib     Procedures for calculating the Gelfand-Kirillov dimension AUTHORS: Lobillo, F.J.,     jlobillo@ugr.es @*         Rabelo, C.,        crabelo@ugr.es /////////////////////////////////////////////////////////////////////////////////// static proc idGKdim(ideal I) "USAGE:   GKdim(I), I is a left ideal "USAGE:   idGKdim(I), I is a left ideal RETURN:  int, the Gelfand-Kirillov dimension of the R/I NOTE: uses the dim procedure, if the factor-module is zero, -1 is returned "USAGE:   GKdim(L);   L is a left ideal/module/matrix RETURN:  int PURPOSE: compute the Gelfand-Kirillov dimension of the factor-module, whose presentation is given by L PURPOSE: compute the Gelfand-Kirillov dimension of the factor-module, whose presentation is given by L, e.g. R^r/L NOTE:  if the factor-module is zero, -1 is returned EXAMPLE: example GKdim; shows examples ideal B = 1; GKdim(B); GKdim(0) == nvars(basering);  // should be true, i.e., evaluated to 1 } ///////////////////////////////////////////////////////////////////////////////
• ## Singular/LIB/involut.lib

 rad711e6 version="$Id: involut.lib,v 1.15 2007-12-18 11:18:36 Singular Exp$"; version="$Id: involut.lib,v 1.16 2009-04-09 12:04:41 seelisch Exp$"; category="Noncommutative"; info=" LIBRARY:  involut.lib  Procedures for Computations and Operations with Involutions LIBRARY:  involut.lib  Computations and operations with involutions AUTHORS:  Oleksandr Iena,       yena@mathematik.uni-kl.de, @*        Markus Becker,        mbecker@mathematik.uni-kl.de, @*        Viktor Levandovskyy,  levandov@mathematik.uni-kl.de THEORY: Involution is an antiisomorphism of a noncommutative algebra with the THEORY: Involution is an anti-isomorphism of a noncommutative algebra with the property that applied an involution twice, one gets an identity. Involution is linear with respect to the ground field. In this library we compute linear involutions, distinguishing the case of a diagonal matrix (such involutions are called homothetic) and a general one. NOTE: This library provides algebraic tools for computations and operations with algebraic involutions and linear automorphisms of noncommutative algebras with algebraic involutions and linear automorphisms of non-commutative algebras PROCEDURES: RETURN:  ideal, representing an involution map PURPOSE: compute classical involutions (i.e. acting rather on operators than on variables) for some particular noncommutative algebras ASSUME: the procedure is aimed at noncommutative algebras with differential, shift or advance operators arising in Control Theory. It has to be executed in the ring. ASSUME: the procedure is aimed at non-commutative algebras with differential, shift or advance operators arising in Control Theory. It has to be executed in a ring. EXAMPLE: example ncdetection; shows an example "{ D[1,4]=1; D[2,5]=1;  D[3,6]=1; def r = nc_algebra(1,D); setring r; map F = r; ncdetection(); F;  // F(F) should be maxideal(1) kill r, R; //---------------------------------------- ring R=0,(x,S),dp; def r = nc_algebra(1,-S); setring r; map F = r; ncdetection(); F;  // F(F) should be maxideal(1) kill r, R; //---------------------------------------- D[1,2]=1;  D[1,3]=-S; def r = nc_algebra(1,D); setring r; map F = r; ncdetection(); F;  // F(F) should be maxideal(1) } PURPOSE: applies the involution, presented by theta to the object m THEORY: for an involution theta and two polynomials a,b from the algebra, theta(ab) = theta(b) theta(a); theta is linear with respect to the ground field NOTE: This is generalized ''theta(m)'' for data types unsupported by ''map''. EXAMPLE: example involution; shows an example "{ def r = nc_algebra(1,1); setring r; // Weyl-Algebra map F = r,x,-d; F(F);  // should be maxideal(1) for an involution poly f =  x*d^2+d; poly If = involution(f,F); "USAGE: findInvo(); RETURN: a ring containing a list L of pairs, where @*        L[i][1]  =  Groebner Basis of an i-th associated prime, @*        L[i][1]  =  ideal; a Groebner Basis of an i-th associated prime, @*        L[i][2]  =  matrix, defining a linear map, with entries, reduced with respect to L[i][1] PURPOSE: computed the ideal of linear involutions of the basering def a = makeWeyl(1); setring a; // this algebra is a first Weyl algebra a; def X = findInvo(); setring X; // ring with new variables, corr. to unknown coefficients X; L; // look at the matrix in the new variables, defining the linear involution print(L[1][2]); L[1][1];  // where new variables obey these relations idJ; } /////////////////////////////////////////////////////////////////////////// "USAGE: findInvoDiag(); RETURN: a ring together with a list of pairs L, where @*        L[i][1]  =  Groebner Basis of an i-th associated prime, @*        L[i][1]  =  ideal; a Groebner Basis of an i-th associated prime, @*        L[i][2]  =  matrix, defining a linear map, with entries, reduced with respect to L[i][1] PURPOSE: compute the ideal of homothetic (diagonal) involutions of the basering PURPOSE: compute homothetic (diagonal) involutions of the basering NOTE: for convenience, the full ideal of relations @code{idJ} and the initial matrix with indeterminates @code{matD} are exported in the output ring def a = makeWeyl(1); setring a; // this algebra is a first Weyl algebra a; def X = findInvoDiag(); setring X; // ring with new variables, corresponding to unknown coefficients X; // print matrices, defining linear involutions print(L[1][2]);  // a first matrix: we see it is constant print(L[2][2]);  // and a second possible matrix; it is constant too L; // let us take a look on the whole list idJ; } ///////////////////////////////////////////////////////////////////// "USAGE: findAuto(n); n an integer RETURN: a ring together with a list of pairs L, where @*        L[i][1]  =  Groebner Basis of an i-th associated prime, @*        L[i][1]  =  ideal; a Groebner Basis of an i-th associated prime, @*        L[i][2]  =  matrix, defining a linear map, with entries, reduced with respect to L[i][1] PURPOSE: computes the ideal of linear automorphisms of the basering, given by a matrix, n-th power of which gives identity (i.e. unipotent matrix) PURPOSE: compute the ideal of linear automorphisms of the basering, given by a matrix, n-th power of which gives identity (i.e. unipotent matrix) NOTE: if n=0, a matrix, defining an automorphism is not assumed to be unipotent but just non-degenerate. A nonzero parameter @code{@@p} is introduced as the value of the determinant of the matrix above. @* For convenience, the full ideal of relations @code{idJ} and the initial matrix with indeterminates @code{matD} are mutually exported in the output ring def a = makeWeyl(1); setring a; // this algebra is a first Weyl algebra def X = findAuto(2); a; def X = findAuto(2);  // in contrast to findInvo look for automorphisms setring X; // ring with new variables - unknown coefficients X; size(L); // we have (size(L)) families in the answer // look at matrices, defining linear automorphisms: print(L[2][2]);  // and a second possible matrix; it is diagonal // L; // we can take a look on the whole list, too idJ; kill X; kill a; //----------- find all the linear automorphisms -------------------- size(L); // here, we have 1 parametrized family print(L[1][2]); // here, @p is a nonzero parameter } det(L[1][2]-@p);  // check whether determinante is zero }
• ## Singular/LIB/ncalg.lib

 rad711e6 /////////////////////////////////////////////////////////////////////////////// version="$Id: ncalg.lib,v 1.31 2009-03-30 18:11:39 motsak Exp$"; version="$Id: ncalg.lib,v 1.32 2009-04-09 12:04:42 seelisch Exp$"; category="Noncommutative"; info=" LIBRARY:  ncalg.lib      Definitions of important GR-algebras LIBRARY:  ncalg.lib      Definitions of important G- and GR-algebras AUTHORS:  Viktor Levandovskyy,     levandov@mathematik.uni-kl.de, @*        Oleksandr Motsak,        U@D, where U={motsak}, D={mathematik.uni-kl.de} @* For universal enveloping algebras of finite dimensional Lie algebras sl_n, gl_n, g_2 etc. there are functions @code{makeUsl}, @code{makeUgl}, @code{makeUg2} etc. @* There are quantized enveloping algebras U_q(sl_2) and U_q(sl_3) (via functions @code{makeQsl2}, @code{makeQsl3}) and non-standard quantum deformation of so_3, accessible via @code{makeQso3} function. @* For quantized enveloping algebras U_q(sl_2) and U_q(sl_3), there are functions @code{makeQsl2}, @code{makeQsl3}) and for non-standard quantum deformation of so_3, there is the function @code{makeQso3}. @* For bigger algebras we suppress the output of the (lengthy) list of non-commutative relations and provide only the number of these relations instead. @*        @code{v}    is an optional intvec. @* In addition, the ideal called @code{GKZid} containing actual equations is calculated and exported to the ring. NOTE:    activate the ring with the @code{setring} command. This procedure is elaborated by Oleksandr Iena NOTE:    activate the output ring with the @code{setring} command. This procedure is elaborated by Oleksandr Iena ASSUME: This procedure uses toric_lib and therefore inherits its input requirements: @*        possible values for input variable @code{alg} are: \"ect\",\"pt\",\"blr\", \"hs\", \"du\".
• ## Singular/LIB/ncdecomp.lib

 rad711e6 /////////////////////////////////////////////////////////////////////////////// version="$Id: ncdecomp.lib,v 1.13 2007-11-28 16:36:46 motsak Exp$"; version="$Id: ncdecomp.lib,v 1.14 2009-04-09 12:04:42 seelisch Exp$"; category="Noncommutative"; info=" proc CentralQuot(module I, ideal G) "USAGE:  CentralQuot(M, G), M a module, G an ideal ASSUME: G is an ideal in the center ASSUME: G is an ideal in the center of the base ring RETURN:  module PURPOSE: compute the central quotient M:G ideal I = e3,f3,h3-4*h; I = std(I); poly C=4*e*f+h^2-2*h; ideal G = (C-8)*(C-24); ideal R = CentralQuot(I,G); poly C=4*e*f+h^2-2*h;  // C in Z(U(sl2)), the central element ideal G = (C-8)*(C-24);  // G normal factor in Z(U(sl2)), subideal in the center ideal R = CentralQuot(I,G);  // same as I:G R; } proc CentralSaturation(module M, ideal T) "USAGE:  CentralSaturation(M, T), for a module M and an ideal T ASSUME: T is an ideal in the center ASSUME: T is an ideal in the center of the base ring RETURN:  module PURPOSE: compute the central saturation of M by T, that is M:T^{\infty}, by repititive application of @code{CentralQuot} proc CenCharDec(module I, def #) "USAGE:  CenCharDec(I, C);  I a module, C an ideal ASSUME: C consists of generators of the center ASSUME: C consists of generators of the center of the base ring RETURN:  a list L, where each entry consists of three records (if a finite decomposition exists) @*       L[*][1] ('ideal' type), the central character as the maximal ideal in the center, @*       L[*][1] ('ideal' type), the central character as a maximal ideal in the center, @*       L[*][2] ('module' type), the Groebner basis of the weight module, corresponding to the character in  L[*][1], @*       L[*][3] ('int' type) is the vector space dimension of the weight module (-1 in case of infinite dimension); PURPOSE: compute a finite decomposition of C into central characters or determine that there is no finite decomposition NOTE:     actual decomposition is a sum of L[i][2] above; NOTE:     actual decomposition is the sum of L[i][2] above; @*        some modules have no finite decomposition (in such case one gets warning message) @*        The function @code{central} in @code{central.lib} may be used to obtain C, when needed. SEE ALSO: CentralQuot, CentralSaturation EXAMPLE: example CenCharDec; shows examples ASSUME: Z consists of pairwise commutative elements RETURN:  ideal, of two-sided generators, not a Groebner basis PURPOSE: computes an intersection of M with the subalgebra, generated by Z PURPOSE: computes the intersection of M with the subalgebra, generated by Z NOTE:    usually Z consists of generators of the center @* The function @code{central} from @code{central.lib} may be used to obtain the center Z, if needed. EXAMPLE: example IntersectWithSub; shows an example "
• ## Singular/LIB/perron.lib

 rad711e6 /////////////////////////////////////////////////////////////////////////////// version="$Id: perron.lib,v 1.13 2009-03-30 18:41:56 motsak Exp$"; version="$Id: perron.lib,v 1.14 2009-04-09 12:04:42 seelisch Exp$"; category="Noncommutative"; info=" setring RB; Relations; // one more test: setring A; map T=RA,I; T(Relations);  // should be zero }
• ## Singular/LIB/qmatrix.lib

 rad711e6 version="$Id: qmatrix.lib,v 1.15 2007-10-31 17:23:49 Singular Exp$"; version="$Id: qmatrix.lib,v 1.16 2009-04-09 12:04:42 seelisch Exp$"; category="Noncommutative"; info=" "USAGE:  LengthSymElement(v); v intvec RETURN:  int PURPOSE: determine the length of v PURPOSE: determine the length of the permutation given by v in some S(n) ASSUME:  v represents an element of S(n); otherwise the output may have no sense SEE ALSO: SymGroup, LengthSym "USAGE:   LengthSym(M); M an intmat RETURN:  intvec PURPOSE: determine a vector, where the i-th element is the length of the i-th row of M PURPOSE: determine a vector, where the i-th element is the length of the permutation of S(n) given by the i-th row of M ASSUME: M represents a subset of S(n) (each row must be an element of S(n)); otherwise, the output may have no sense SEE ALSO: SymGroup, LengthSymElement @*       algebra is not used because double indexes are not allowed @*       in the variables. Instead the variables are listed by reading @*       the rows of the usual matrix representation. @*       the rows of the usual matrix representation, that is, there @*       will be n*n variables (one for each entry an n*N generic matrix), @*       listed row-wise SEE ALSO: qminor EXAMPLE: example quantMat; shows examples proc qminor(intvec I, intvec J, int nr) "USAGE:        qminor(I,J,n); I,J intvec, n int RETURN: poly, the quantum minor RETURN: poly, the quantum minor of a generic n*n quantum matrix ASSUME: I is the ordered list of the rows to consider in the minor, @*      J is the ordered list of the columns to consider in the minor, @*      I and J must have the same number of elements, @*      n is the order of the quantum matrix algebra you are working with (quantMat(n)). @*      The base ring should be constructed using @code{quantMat}. SEE ALSO: quantMat EXAMPLE: example qminor; shows examples
Note: See TracChangeset for help on using the changeset viewer.