Changeset d41540 in git


Ignore:
Timestamp:
Apr 9, 2009, 2:04:42 PM (14 years ago)
Author:
Frank Seelisch <seelisch@…>
Branches:
(u'jengelh-datetime', 'ceac47cbc86fe4a15902392bdbb9bd2ae0ea02c6')(u'spielwiese', 'f875bbaccd0831e36aaed09ff6adeb3eb45aeb94')
Children:
360d44ebd8adf880d631138132cbbbbb75737c6a
Parents:
ad711e62aa4616b2021988701854eaa06e60a109
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

Legend:

Unmodified
Added
Removed

  • Singular/LIB/dmod.lib

    rad711e6 rd41540  
    11//////////////////////////////////////////////////////////////////////////////
    2 version="$Id: dmod.lib,v 1.38 2009-04-08 16:51:07 seelisch Exp $";
     2version="$Id: dmod.lib,v 1.39 2009-04-09 12:04:41 seelisch Exp $";
    33category="Noncommutative";
    44info="
    … …  
    8989convloc(L);         replace global orderings with local in the ringlist L
    9090minIntRoot(P,fact); minimal integer root among the roots of a maximal ideal P
    91 varnum(s);          the number of the variable with the name s
     91varNum(s);          the number of the variable with the name s
    9292isRational(n);  check whether n is a rational number
    9393
    … …  
    387387RETURN:  ring
    388388PURPOSE: compute the D-module structure of basering[1/f]*f^s
    389 NOTE:    activate this ring with the @code{setring} command.
     389NOTE:    activate the output ring with the @code{setring} command.
    390390@*   In the output ring D[s], the ideal LD1 is generated by the elements
    391391@*   in Ann F^s in D[s], coming from logarithmic derivations.
    … …  
    538538PURPOSE: compute the annihilator ideal of f^s in D[s], where D is the Weyl
    539539@*   algebra, according to the algorithm by Briancon and Maisonobe
    540 NOTE:  Activate this ring with the @code{setring} command. In this ring,
     540NOTE:  activate the output ring with the @code{setring} command. In this ring,
    541541@*       - the ideal LD is the annihilator of f^s.
    542542@*       If eng <>0, @code{std} is used for Groebner basis computations,
    … …  
    955955PURPOSE: compute the D-module structure of basering[1/f]*f^s, according
    956956@* to the algorithm by Briancon and Maisonobe
    957 NOTE:    activate this ring with the @code{setring} command. In this ring,
     957NOTE:    activate the output ring with the @code{setring} command. In this ring,
    958958@*       - the ideal LD (which is a Groebner basis) is the needed D-module structure,
    959959@*         which is obtained by substituting the minimal integer root of a Bernstein
    … …  
    12521252RETURN:  ring
    12531253PURPOSE: compute the annihilator ideal of f^s in the Weyl Algebra,
    1254 @*           based on the output of Sannfs-like procedure
    1255 NOTE: Activate this ring with the @code{setring} command. In this ring,
     1254@*       based on the output of Sannfs-like procedure
     1255@*       annfs2 uses shorter expressions in the variable s (the idea of Noro).
     1256NOTE: activate the output ring with the @code{setring} command. In this ring,
    12561257@*      - the ideal LD (which is a Groebner basis) is the annihilator of f^s,
    12571258@*      - the list BS contains the roots with multiplicities of the BS polynomial.
    12581259@*    If eng <>0, @code{std} is used for Groebner basis computations,
    12591260@*    otherwise and by default @code{slimgb} is used.
    1260 @* annfs2 uses shorter expressions in the variable s (the idea of Noro).
    12611261DISPLAY: If @code{printlevel}=1, progress debug messages will be printed,
    12621262@*       if @code{printlevel}>=2, all the debug messages will be printed.
    … …  
    14141414PURPOSE: compute the annihilator ideal of f^s in the Weyl Algebra,
    14151415@* based on the output of Sannfs like procedure
    1416 NOTE:    activate this ring with the @code{setring} command. In this ring,
     1416NOTE:    activate the output ring with the @code{setring} command. In this ring,
    14171417@*       - the ideal LD (which is a Groebner basis) is the annihilator of f^s,
    14181418@*       - the list BS contains the roots with multiplicities of a Bernstein polynomial of f.
    … …  
    19971997PURPOSE: compute the generic Ann F^s and exceptional parametric constellations
    19981998@* of a polynomial with parametric coefficients with the BM algorithm
    1999 NOTE:    activate this ring with the @code{setring} command. In this ring,
     1999NOTE:    activate the output ring with the @code{setring} command. In this ring,
    20002000@*       - the ideal LD is the D-module structure oa Ann F^s
    2001 @*       - the ideal Param contains the list of the special parameters.
     2001@*       - the ideal Param contains special parameters as entries
    20022002@*       If eng <>0, @code{std} is used for Groebner basis computations,
    20032003@*       otherwise, and by default @code{slimgb} is used.
    … …  
    22402240PURPOSE: compute the D-module structure of basering[1/f]*f^s where
    22412241@* f = F[1]*..*F[P], according to the algorithm by Briancon and Maisonobe.
    2242 NOTE:    activate this ring with the @code{setring} command. In this ring,
     2242NOTE:    activate the output ring with the @code{setring} command. In this ring,
    22432243@*       - the ideal LD is the needed D-mod structure,
    22442244@*       - the list BS is the Bernstein ideal of a polynomial f = F[1]*..*F[P].
    … …  
    25692569PURPOSE: compute the D-module structure of basering[1/f]*f^s,
    25702570@* according to the algorithm by Oaku and Takayama
    2571 NOTE:    activate this ring with the @code{setring} command. In this ring,
     2571NOTE:    activate the output ring with the @code{setring} command. In this ring,
    25722572@*       - the ideal LD (which is a Groebner basis) is the needed D-module structure,
    25732573@*         which is obtained by substituting the minimal integer root of a Bernstein
    … …  
    29512951PURPOSE: compute the D-module structure of basering[1/f]*f^s, according to the
    29522952@* 1st step of the algorithm by Oaku and Takayama in the ring D[s]
    2953 NOTE:    activate this ring with the @code{setring} command.
     2953NOTE:    activate the output ring with the @code{setring} command.
    29542954@*  In the output ring D[s], the ideal LD (which is NOT a Groebner basis)
    29552955@*  is the needed D-module structure.
    … …  
    32353235PURPOSE: compute the D-module structure of basering[1/f]*f^s, according to the
    32363236@* 1st step of the algorithm by Briancon and Maisonobe in the ring D[s].
    3237 NOTE:  Activate this ring with the @code{setring} command.
     3237NOTE:  activate the output ring with the @code{setring} command.
    32383238@*   In the output ring D[s], the ideal LD (which is NOT a Groebner basis) is
    32393239@*   the needed D-module structure.
    … …  
    34413441RETURN:  ring
    34423442PURPOSE: compute Ann f^s and Groebner basis of Ann f^s+f in D[s]
    3443 NOTE:    activate this ring with the @code{setring} command.
     3443NOTE:    activate the output ring with the @code{setring} command.
    34443444@*  This procedure, unlike SannfsBM, returns a ring with the degrevlex
    34453445@*  ordering in all variables.
    3446 @*  In the ring D[s], the ideal LD (which IS a Groebner basis) is the needed ideal.
     3446@*  In the ring D[s], the ideal LD is the ideal needed (which is returned as a Groebner basis).
    34473447@*  If eng <>0, @code{std} is used for Groebner basis computations,
    34483448@*  otherwise, and by default @code{slimgb} is used.
    … …  
    36383638  // Are there polynomials, depending on @s only?
    36393639  nselect(LD,v);
    3640   // It is not the case. Are there leading monomials in @s only?
     3640  // It is not the case. Are there leading terms in @s only?
    36413641  nselect(lead(LD),v);
    36423642}
    … …  
    36473647RETURN:  ring
    36483648PURPOSE: compute Ann f^s and Groebner basis of Ann f^s+f in D[s]
    3649 NOTE:    activate this ring with the @code{setring} command.
     3649NOTE:    activate the output ring with the @code{setring} command.
    36503650@*    This procedure, unlike SannfsBM, returns a ring with the degrevlex
    36513651@*    ordering in all variables.
    … …  
    38713871PURPOSE: compute the D-module structure of basering[1/f]*f^s, according to the
    38723872@* Levandovskyy's modification of the algorithm by Oaku and Takayama in D[s]
    3873 NOTE:    activate this ring with the @code{setring} command.
     3873NOTE:    activate the output ring with the @code{setring} command.
    38743874@*    In the ring D[s], the ideal LD (which is NOT a Groebner basis) is
    38753875@*    the needed D-module structure.
    … …  
    41024102RETURN:  ring
    41034103PURPOSE: 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
    4104 NOTE:    activate this ring with the @code{setring} command.
     4104NOTE:    activate the output ring with the @code{setring} command.
    41054105@*       In the ring D[s], the ideal LD (which is NOT a Groebner basis) is the needed D-module structure.
    41064106@*       If eng <>0, @code{std} is used for Groebner basis computations,
    … …  
    43284328PURPOSE: compute the D-module structure of basering[1/f]*f^s, according to
    43294329@* the Levandovskyy's modification of the algorithm by Oaku and Takayama
    4330 NOTE:    activate this ring with the @code{setring} command. In this ring,
     4330NOTE:    activate the output ring with the @code{setring} command. In this ring,
    43314331@*  - the ideal LD (which is a Groebner basis) is the needed D-module structure,
    43324332@*    which is obtained by substituting the minimal integer root of a Bernstein
    … …  
    43734373PURPOSE: compute the annihilator ideal of f^s in the Weyl Algebra, based
    43744374@* on the output of Sannfs-like procedure
    4375 NOTE:    activate this ring with the @code{setring} command. In this ring,
     4375NOTE:    activate the output ring with the @code{setring} command. In this ring,
    43764376@* - the ideal LD (which is a Groebner basis) is the annihilator of f^s,
    43774377@* - the list BS contains the roots with multiplicities of BS polynomial of f.
    … …  
    45274527// RETURN:  ring
    45284528// PURPOSE: compute the D-module structure of basering[1/f]*f^s
    4529 // NOTE:    activate this ring with the @code{setring} command. In this ring,
     4529// NOTE:    activate the output ring with the @code{setring} command. In this ring,
    45304530// @*       - the ideal LD is the needed D-mod structure,
    45314531// @*       - the ideal BS is the list of roots of a Bernstein polynomial of f.
    … …  
    48154815RETURN:  list
    48164816PURPOSE: convert a ringlist L into another ringlist,
    4817 @* where all the 'p' orderings are replaced with the 's' orderings.
     4817@* where all the 'p' orderings are replaced with the 's' orderings, e.g. @code{dp} by @code{ds}.
    48184818ASSUME: L is a result of a ringlist command
    48194819EXAMPLE: example convloc; shows examples
    … …  
    48814881  int ppl = printlevel-voice+2;
    48824882  //  int mir =  minIntRoot(L[1],0);
    4883   int ns   = varnum("s");
     4883  int ns   = varNum("s");
    48844884  if (!ns)
    48854885  {
    … …  
    50175017  poly f1  = x*y*(x+y);
    50185018  ideal I1 = bernstein(f1)[1]; // a local Bernstein poly
     5019  I1;
    50195020  minIntRoot(I1,0);
    50205021  poly  f2  = x2-y3;
    50215022  ideal I2  = bernstein(f2)[1];
     5023  I2;
    50225024  minIntRoot(I2,0);
    50235025  // now we illustrate the behaviour of factorize
    … …  
    50265028  poly f3   = 9*(x+2/3)*(x+1)*(x+4/3); //global b-poly of f1=x*y*(x+y)
    50275029  ideal I3 = factorize(f3,1);
     5030  I3;
    50285031  minIntRoot(I3,1);
    50295032  // and a more interesting situation
    … …  
    50315034  poly  f  = x3 + y3 + z3;
    50325035  ideal I  = bernstein(f)[1];
     5036  I;
    50335037  minIntRoot(I,0);
    50345038}
    … …  
    50365040proc isHolonomic(def M)
    50375041"USAGE:  isHolonomic(M); M an ideal/module/matrix
    5038 RETURN:  int, 1 if M is holonomic and 0 otherwise
     5042RETURN:  int, 1 if M is holonomic over the base ring, and 0 otherwise
    50395043ASSUME: basering is a Weyl algebra in characteristic 0
    5040 PURPOSE: check the modules for the property of holonomy
    5041 NOTE:    M is holonomic, if 2*dim(M) = dim(R), where R is a
    5042 ground ring; dim stays for Gelfand-Kirillov dimension
     5044PURPOSE: check whether M is holonomic over the base ring
     5045NOTE:    M is holonomic if 2*dim(M) = dim(R), where R is the
     5046base ring; dim stays for Gelfand-Kirillov dimension
    50435047EXAMPLE: example isHolonomic; shows examples
    50445048"
    … …  
    50845088RETURN:  ring
    50855089PURPOSE: set up the polynomial, describing a Reiffen curve
    5086 NOTE:  activate this ring with the @code{setring} command and
     5090NOTE:  activate the output ring with the @code{setring} command and
    50875091@*       find the curve as a polynomial RC.
    5088 @*  A Reiffen curve is defined as F = x^p + y^q + xy^{q-1}, q >= p+1 >= 5
     5092@*  A Reiffen curve is defined as RC = x^p + y^q + xy^{q-1}, q >= p+1 >= 5
    50895093
    50905094EXAMPLE: example reiffen; shows examples
    … …  
    51875191"USAGE:  checkRoot(f,alpha [,S,eng]);  poly f, number alpha, string S, int eng
    51885192RETURN:  int
    5189 ASSUME: Basering is commutative ring, alpha is a rational number.
     5193ASSUME: Basering is a commutative ring, alpha is a rational number.
    51905194PURPOSE: check whether a rational number alpha is a root of the global
    51915195@* Bernstein-Sato polynomial of f and compute its multiplicity,
    … …  
    51955199@*       'alg1' (default) - for the algorithm 1 of [LM08]
    51965200@*       'alg2' - for the algorithm 2 of [LM08]
    5197 @*       The output of type int is:
     5201@*       Depending on the value of S, the output of type int is:
    51985202@*       'alg1': 1 only if -alpha is a root of the global Bernstein-Sato polynomial
    51995203@*       'alg2':  the multiplicity of -alpha as a root of the global Bernstein-Sato
    … …  
    53045308ASSUME:  Basering is D[s], I is the annihilator of f^s in D[s],
    53055309@* that is basering and I are the output of Sannfs-like procedure,
    5306 @* f is a polynomial in K[_x] and alpha is a rational number.
     5310@* f is a polynomial in K[x] and alpha is a rational number.
    53075311RETURN:  int, 1 if -alpha is a root of the Bernstein-Sato polynomial of f
    53085312PURPOSE: check, whether alpha is a root of the global Bernstein-Sato polynomial of f
    … …  
    56595663}
    56605664
    5661 proc varnum(string s)
    5662 "USAGE:  varnum(s);  string s
     5665proc varNum(string s)
     5666"USAGE:  varNum(s);  string s
    56635667RETURN:  int
    56645668PURPOSE: returns the number of the variable with the name s
    56655669@*  among the variables of basering or 0 if there is no such variable
    5666 EXAMPLE: example varnum; shows examples
     5670EXAMPLE: example varNum; shows examples
    56675671"
    56685672{
    … …  
    56805684{
    56815685  "EXAMPLE:"; echo = 2;
    5682   ring X = 0,(x,y1,z(0),tTa),dp;
    5683   varnum("z(0)");
    5684   varnum("tTa");
    5685   varnum("xyz");
     5686  ring X = 0,(x,y1,t,z(0),z,tTa),dp;
     5687  varNum("z");
     5688  varNum("t");
     5689  varNum("xyz");
    56865690}
    56875691

  • Singular/LIB/dmodapp.lib

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

  • Singular/LIB/freegb.lib

    rad711e6 rd41540  
    11//////////////////////////////////////////////////////////////////////////////
    2 version="$Id: freegb.lib,v 1.20 2009-04-08 11:11:20 Singular Exp $";
     2version="$Id: freegb.lib,v 1.21 2009-04-09 12:04:41 seelisch Exp $";
    33category="Noncommutative";
    44info="
    5 LIBRARY: freegb.lib   Twosided Noncommutative Groebner bases in Free Algebras via Letterplace
     5LIBRARY: freegb.lib   Compute two-sided Groebner bases in free algebras via letterplace
    66AUTHOR: Viktor Levandovskyy,     levandov@math.rwth-aachen.de
    77
    … …  
    5858"USAGE: setLetterplaceAttributes(R, d, b); R a ring, b,d integers
    5959RETURN: ring with special attributes set
    60 PURPOSE: sets attributes for a letterplace ring: 
     60PURPOSE: sets attributes for a letterplace ring:
    6161@*      'isLetterplaceRing' = true, 'uptodeg' = d, 'lV' = b, where
    6262@*      'uptodeg' stands for the degree bound,
    6363@*      'lV' for the number of variables in the block 0.
     64NOTE: Activate the resulting ring by using @code{setring}
    6465"
    6566{
    … …  
    475476PURPOSE: compute the two-sided Groebner basis of an ideal, encoded by L in
    476477the free associative algebra, up to degree d
     478NOTE: Apply @code{lst2str} to the output in order to obtain a human-readable
     479representation
    477480EXAMPLE: example freeGBasis; shows examples
    478481"
    … …  
    22212224
    22222225proc lp2lstr(ideal K, def save)
    2223 "USAGE:  lp2lstr(K,s); K an ideal, s a ring
    2224 RETURN:  nothing (exports object @LN into s)
     2226"USAGE:  lp2lstr(K,s); K an ideal, s a ring name
     2227RETURN:  nothing (exports object @LN into the ring named s)
    22252228ASSUME: basering has a letterplace ring structure
    22262229PURPOSE: converts letterplace ideal to list of modules
    … …  
    25072510  "EXAMPLE:"; echo = 2;
    25082511  // define a ring in letterplace form as follows:
    2509   ring r = 0,(x(1),y(1),x(2),y(2),x(3),y(3),x(4),y(4)),dp;
    2510   poly a = x(1)*y(2); poly b = y(1);
     2512  ring r = 0,(x(1),y(1),x(2),y(2),x(3),y(3),x(4),y(4)),dp;
    25112513  def R = setLetterplaceAttributes(r,4,2); // supply R with letterplace structure
    25122514  setring R;
     2515  poly a = x(1)*y(2); poly b = y(1);
    25132516  lpMult(b,a);
    25142517  lpMult(a,b);

  • Singular/LIB/gkdim.lib

    rad711e6 rd41540  
    11///////////////////////////////////////////////////////////////////////////////
    2 version="$Id: gkdim.lib,v 1.11 2007-11-28 16:36:45 motsak Exp $";
     2version="$Id: gkdim.lib,v 1.12 2009-04-09 12:04:41 seelisch Exp $";
    33category="Noncommutative";
    44info="
    5 LIBRARY: GKdim.lib     Procedures for calculating the Gelfand-Kirillov dimension
     5LIBRARY: gkdim.lib     Procedures for calculating the Gelfand-Kirillov dimension
    66AUTHORS: Lobillo, F.J.,     jlobillo@ugr.es
    77@*         Rabelo, C.,        crabelo@ugr.es
    … …  
    1515///////////////////////////////////////////////////////////////////////////////////
    1616static proc idGKdim(ideal I)
    17 "USAGE:   GKdim(I), I is a left ideal
     17"USAGE:   idGKdim(I), I is a left ideal
    1818RETURN:  int, the Gelfand-Kirillov dimension of the R/I
    1919NOTE: uses the dim procedure, if the factor-module is zero, -1 is returned
    … …  
    4848"USAGE:   GKdim(L);   L is a left ideal/module/matrix
    4949RETURN:  int
    50 PURPOSE: compute the Gelfand-Kirillov dimension of the factor-module, whose presentation is given by L
     50PURPOSE: compute the Gelfand-Kirillov dimension of the factor-module, whose presentation is given by L, e.g. R^r/L
    5151NOTE:  if the factor-module is zero, -1 is returned
    5252EXAMPLE: example GKdim; shows examples
    … …  
    118118  ideal B = 1;
    119119  GKdim(B);
     120  GKdim(0) == nvars(basering);  // should be true, i.e., evaluated to 1
    120121}
    121122///////////////////////////////////////////////////////////////////////////////

  • Singular/LIB/involut.lib

    rad711e6 rd41540  
    1 version="$Id: involut.lib,v 1.15 2007-12-18 11:18:36 Singular Exp $";
     1version="$Id: involut.lib,v 1.16 2009-04-09 12:04:41 seelisch Exp $";
    22category="Noncommutative";
    33info="
    4 LIBRARY:  involut.lib  Procedures for Computations and Operations with Involutions
     4LIBRARY:  involut.lib  Computations and operations with involutions
    55AUTHORS:  Oleksandr Iena,       yena@mathematik.uni-kl.de,
    66@*        Markus Becker,        mbecker@mathematik.uni-kl.de,
    77@*        Viktor Levandovskyy,  levandov@mathematik.uni-kl.de
    88
    9 THEORY: Involution is an antiisomorphism of a noncommutative algebra with the
     9THEORY: Involution is an anti-isomorphism of a noncommutative algebra with the
    1010 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.
    1111
    … …  
    1414
    1515NOTE: This library provides algebraic tools for computations and operations
    16 with algebraic involutions and linear automorphisms of noncommutative algebras
     16with algebraic involutions and linear automorphisms of non-commutative algebras
    1717
    1818PROCEDURES:
    … …  
    3232RETURN:  ideal, representing an involution map
    3333PURPOSE: compute classical involutions (i.e. acting rather on operators than on variables) for some particular noncommutative algebras
    34 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.
     34ASSUME: the procedure is aimed at non-commutative algebras with differential, shift or advance operators arising in Control Theory.
     35It has to be executed in a ring.
    3536EXAMPLE: example ncdetection; shows an example
    3637"{
    … …  
    165166  D[1,4]=1; D[2,5]=1;  D[3,6]=1;
    166167  def r = nc_algebra(1,D); setring r;
     168  map F = r;
    167169  ncdetection();
     170  F;  // F(F) should be maxideal(1)
    168171  kill r, R;
    169172  //----------------------------------------
    170173  ring R=0,(x,S),dp;
    171174  def r = nc_algebra(1,-S); setring r;
     175  map F = r;
    172176  ncdetection();
     177  F;  // F(F) should be maxideal(1)
    173178  kill r, R;
    174179  //----------------------------------------
    … …  
    177182  D[1,2]=1;  D[1,3]=-S;
    178183  def r = nc_algebra(1,D); setring r;
     184  map F = r;
    179185  ncdetection();
     186  F;  // F(F) should be maxideal(1)
    180187}
    181188
    … …  
    280287PURPOSE: applies the involution, presented by theta to the object m
    281288THEORY: 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
     289NOTE: This is generalized ''theta(m)'' for data types unsupported by ''map''.
    282290EXAMPLE: example involution; shows an example
    283291"{
    … …  
    342350  def r = nc_algebra(1,1); setring r; // Weyl-Algebra
    343351  map F = r,x,-d;
     352  F(F);  // should be maxideal(1) for an involution
    344353  poly f =  x*d^2+d;
    345354  poly If = involution(f,F);
    … …  
    420429"USAGE: findInvo();
    421430RETURN: a ring containing a list L of pairs, where
    422 @*        L[i][1]  =  Groebner Basis of an i-th associated prime,
     431@*        L[i][1]  =  ideal; a Groebner Basis of an i-th associated prime,
    423432@*        L[i][2]  =  matrix, defining a linear map, with entries, reduced with respect to L[i][1]
    424433PURPOSE: computed the ideal of linear involutions of the basering
    … …  
    537546  def a = makeWeyl(1);
    538547  setring a; // this algebra is a first Weyl algebra
     548  a;
    539549  def X = findInvo();
    540550  setring X; // ring with new variables, corr. to unknown coefficients
     551  X;
    541552  L;
    542553  // look at the matrix in the new variables, defining the linear involution
    543554  print(L[1][2]);
    544555  L[1][1];  // where new variables obey these relations
     556  idJ;
    545557}
    546558///////////////////////////////////////////////////////////////////////////
    … …  
    548560"USAGE: findInvoDiag();
    549561RETURN: a ring together with a list of pairs L, where
    550 @*        L[i][1]  =  Groebner Basis of an i-th associated prime,
     562@*        L[i][1]  =  ideal; a Groebner Basis of an i-th associated prime,
    551563@*        L[i][2]  =  matrix, defining a linear map, with entries, reduced with respect to L[i][1]
    552 PURPOSE: compute the ideal of homothetic (diagonal) involutions of the basering
     564PURPOSE: compute homothetic (diagonal) involutions of the basering
    553565NOTE: for convenience, the full ideal of relations @code{idJ}
    554566and the initial matrix with indeterminates @code{matD} are exported in the output ring
    … …  
    665677  def a = makeWeyl(1);
    666678  setring a; // this algebra is a first Weyl algebra
     679  a;
    667680  def X = findInvoDiag();
    668681  setring X; // ring with new variables, corresponding to unknown coefficients
     682  X;
    669683  // print matrices, defining linear involutions
    670684  print(L[1][2]);  // a first matrix: we see it is constant
    671685  print(L[2][2]);  // and a second possible matrix; it is constant too
    672686  L; // let us take a look on the whole list
     687  idJ;
    673688}
    674689/////////////////////////////////////////////////////////////////////
    … …  
    676691"USAGE: findAuto(n); n an integer
    677692RETURN: a ring together with a list of pairs L, where
    678 @*        L[i][1]  =  Groebner Basis of an i-th associated prime,
     693@*        L[i][1]  =  ideal; a Groebner Basis of an i-th associated prime,
    679694@*        L[i][2]  =  matrix, defining a linear map, with entries, reduced with respect to L[i][1]
    680 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)
     695PURPOSE: compute the ideal of linear automorphisms of the basering, given by a matrix, n-th power of which gives identity (i.e. unipotent matrix)
    681696NOTE: 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.
    682697@* For convenience, the full ideal of relations @code{idJ} and the initial matrix with indeterminates @code{matD} are mutually exported in the output ring
    … …  
    810825  def a = makeWeyl(1);
    811826  setring a; // this algebra is a first Weyl algebra
    812   def X = findAuto(2);
     827  a;
     828  def X = findAuto(2);  // in contrast to findInvo look for automorphisms
    813829  setring X; // ring with new variables - unknown coefficients
     830  X;
    814831  size(L); // we have (size(L)) families in the answer
    815832  // look at matrices, defining linear automorphisms:
    … …  
    817834  print(L[2][2]);  // and a second possible matrix; it is diagonal
    818835  // L; // we can take a look on the whole list, too
     836  idJ;
    819837  kill X; kill a;
    820838  //----------- find all the linear automorphisms --------------------
    … …  
    827845  size(L); // here, we have 1 parametrized family
    828846  print(L[1][2]); // here, @p is a nonzero parameter
    829 }
     847  det(L[1][2]-@p);  // check whether determinante is zero
     848}

  • Singular/LIB/ncalg.lib

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

  • Singular/LIB/ncdecomp.lib

    rad711e6 rd41540  
    11///////////////////////////////////////////////////////////////////////////////
    2 version="$Id: ncdecomp.lib,v 1.13 2007-11-28 16:36:46 motsak Exp $";
     2version="$Id: ncdecomp.lib,v 1.14 2009-04-09 12:04:42 seelisch Exp $";
    33category="Noncommutative";
    44info="
    … …  
    103103proc CentralQuot(module I, ideal G)
    104104"USAGE:  CentralQuot(M, G), M a module, G an ideal
    105 ASSUME: G is an ideal in the center
     105ASSUME: G is an ideal in the center of the base ring
    106106RETURN:  module
    107107PURPOSE: compute the central quotient M:G
    … …  
    132132   ideal I = e3,f3,h3-4*h;
    133133   I = std(I);
    134    poly C=4*e*f+h^2-2*h;
    135    ideal G = (C-8)*(C-24);
    136    ideal R = CentralQuot(I,G);
     134   poly C=4*e*f+h^2-2*h;  // C in Z(U(sl2)), the central element
     135   ideal G = (C-8)*(C-24);  // G normal factor in Z(U(sl2)), subideal in the center
     136   ideal R = CentralQuot(I,G);  // same as I:G
    137137   R;
    138138}
    … …  
    140140proc CentralSaturation(module M, ideal T)
    141141"USAGE:  CentralSaturation(M, T), for a module M and an ideal T
    142 ASSUME: T is an ideal in the center
     142ASSUME: T is an ideal in the center of the base ring
    143143RETURN:  module
    144144PURPOSE: compute the central saturation of M by T, that is M:T^{\infty}, by repititive application of @code{CentralQuot}
    … …  
    181181proc CenCharDec(module I, def #)
    182182"USAGE:  CenCharDec(I, C);  I a module, C an ideal
    183 ASSUME: C consists of generators of the center
     183ASSUME: C consists of generators of the center of the base ring
    184184RETURN:  a list L, where each entry consists of three records (if a finite decomposition exists)
    185 @*       L[*][1] ('ideal' type), the central character as the maximal ideal in the center,
     185@*       L[*][1] ('ideal' type), the central character as a maximal ideal in the center,
    186186@*       L[*][2] ('module' type), the Groebner basis of the weight module, corresponding to the character in  L[*][1],
    187187@*       L[*][3] ('int' type) is the vector space dimension of the weight module (-1 in case of infinite dimension);
    188188PURPOSE: compute a finite decomposition of C into central characters or determine that there is no finite decomposition
    189 NOTE:     actual decomposition is a sum of L[i][2] above;
     189NOTE:     actual decomposition is the sum of L[i][2] above;
    190190@*        some modules have no finite decomposition (in such case one gets warning message)
     191@*        The function @code{central} in @code{central.lib} may be used to obtain C, when needed.
    191192SEE ALSO: CentralQuot, CentralSaturation
    192193EXAMPLE: example CenCharDec; shows examples
    … …  
    335336ASSUME: Z consists of pairwise commutative elements
    336337RETURN:  ideal, of two-sided generators, not a Groebner basis
    337 PURPOSE: computes an intersection of M with the subalgebra, generated by Z
     338PURPOSE: computes the intersection of M with the subalgebra, generated by Z
    338339NOTE:    usually Z consists of generators of the center
     340@* The function @code{central} from @code{central.lib} may be used to obtain the center Z, if needed.
    339341EXAMPLE: example IntersectWithSub; shows an example
    340342"

  • Singular/LIB/perron.lib

    rad711e6 rd41540  
    11///////////////////////////////////////////////////////////////////////////////
    2 version="$Id: perron.lib,v 1.13 2009-03-30 18:41:56 motsak Exp $";
     2version="$Id: perron.lib,v 1.14 2009-04-09 12:04:42 seelisch Exp $";
    33category="Noncommutative";
    44info="
    … …  
    195195  setring RB;
    196196  Relations;
     197  // one more test:
     198  setring A;
     199  map T=RA,I;
     200  T(Relations);  // should be zero
    197201}
    198202

  • Singular/LIB/qmatrix.lib

    rad711e6 rd41540  
    1 version="$Id: qmatrix.lib,v 1.15 2007-10-31 17:23:49 Singular Exp $";
     1version="$Id: qmatrix.lib,v 1.16 2009-04-09 12:04:42 seelisch Exp $";
    22category="Noncommutative";
    33info="
    … …  
    8181"USAGE:  LengthSymElement(v); v intvec
    8282RETURN:  int
    83 PURPOSE: determine the length of v
     83PURPOSE: determine the length of the permutation given by v in some S(n)
    8484ASSUME:  v represents an element of S(n); otherwise the output may have no sense
    8585SEE ALSO: SymGroup, LengthSym
    … …  
    110110"USAGE:   LengthSym(M); M an intmat
    111111RETURN:  intvec
    112 PURPOSE: determine a vector, where the i-th element is the length of the i-th row of M
     112PURPOSE: 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
    113113ASSUME: M represents a subset of S(n) (each row must be an element of S(n)); otherwise, the output may have no sense
    114114SEE ALSO: SymGroup, LengthSymElement
    … …  
    144144@*       algebra is not used because double indexes are not allowed
    145145@*       in the variables. Instead the variables are listed by reading
    146 @*       the rows of the usual matrix representation.
     146@*       the rows of the usual matrix representation, that is, there
     147@*       will be n*n variables (one for each entry an n*N generic matrix),
     148@*       listed row-wise
    147149SEE ALSO: qminor
    148150EXAMPLE: example quantMat; shows examples
    … …  
    217219proc qminor(intvec I, intvec J, int nr)
    218220"USAGE:        qminor(I,J,n); I,J intvec, n int
    219 RETURN: poly, the quantum minor
     221RETURN: poly, the quantum minor of a generic n*n quantum matrix
    220222ASSUME: I is the ordered list of the rows to consider in the minor,
    221223@*      J is the ordered list of the columns to consider in the minor,
    222224@*      I and J must have the same number of elements,
    223225@*      n is the order of the quantum matrix algebra you are working with (quantMat(n)).
     226@*      The base ring should be constructed using @code{quantMat}.
    224227SEE ALSO: quantMat
    225228EXAMPLE: example qminor; shows examples
Note: See TracChangeset for help on using the changeset viewer.