Changeset 91c978 in git


Ignore:
Timestamp:
Feb 23, 2005, 7:10:46 PM (19 years ago)
Author:
Viktor Levandovskyy <levandov@…>
Branches:
(u'fieker-DuVal', '117eb8c30fc9e991c4decca4832b1d19036c4c65')(u'spielwiese', '38077648e7239f98078663eb941c3c979511150a')
Children:
5f1374dd0a531f7a0e58a69c0d23b8de965ccd09
Parents:
9268cefce47b7dbc575d68e82b7dbd80b07cc8a8
Message:
*levandov: makeup things for the documentation together with minor fixes in code and English


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

Legend:

Unmodified
Added
Removed

  • Singular/LIB/center.lib

    r9268ce r91c978  
    11///////////////////////////////////////////////////////////////////////////////
    2 version="$Id: center.lib,v 1.12 2004-12-15 19:02:33 plural Exp $";
     2version="$Id: center.lib,v 1.13 2005-02-23 18:10:44 levandov Exp $";
    33category="Noncommutative";
    44info="
    … …  
    66AUTHOR:  Oleksandr Motsak,        motsak@mathematik.uni-kl.de.
    77OVERVIEW:
    8  This is a library for computing the central elements and centralisators of elements in various noncommutative algebras.
    9  Implementation is mainly based on algorithms, written in the frame of the diploma thesis by Oleksandr Motsak (advisor: Prof. S.A. Ovsienko, using the definitions from diploma thesis by V.Levandovskyy), at Kyiv Taras Shevchenko University:  'An algorithm for the computation of the center of noncommutative polynomial algebra'.
    10  @* The last version of this library can be found via internet at author's home page.
     8 This is a library for computing the central elements and centralizers of elements in various noncommutative algebras.
     9 Implementation is based on algorithms, written in the frame of the diploma thesis by O. Motsak (advisor: Prof. S.A. Ovsienko, support: V. Levandovskyy), at Kyiv Taras Shevchenko University (Ukraine) with the title 'An algorithm for the computation of the center of noncommutative polynomial algebra'.
    1110
    1211SUPPORT: Forschungsschwerpunkt 'Mathematik und Praxis'
    1312
    1413PROCEDURES:
    15         center(MaxDeg[,N]);             returns the center of basering,
    16         centralizer(f, MaxDeg[,N]);     returns the centralizer of f in basering,
     14        center(MaxDeg[,N]);             computes the generators of the center of a basering,
     15        centralizer(f, MaxDeg[,N]);     computes the generators of the centralizer of f in a basering,
    1716        inCenter(l);                    checks the centrality of elements of list/ideal/poly l
    18         inCentralizer(l, f);            checks the commutativity wrt polynomialf of polynomials of list/ideal/poly l
    19 
    20 SEE ALSO:  ncalg_lib, nctools_lib
     17        inCentralizer(l, f);            checks the commutativity wrt polynomial f of polynomials of list/ideal/poly l
     18
    2119KEYWORDS:  inCenter; inCentralizer; center; centralizer
    2220";
    … …  
    156154
    157155/******************************************************/
    158 // some bisiness for my_var
     156// some business for my_var
    159157
    160158/******************************************************/
    … …  
    813811static proc checkPolyUniq( list l, poly p )
    814812  "
    815         check wheather p sits already in l, assume l to be size-sorted <
     813        check whether p sits already in l, assume l to be size-sorted <
    816814        return: -1 if present
    817815                 1 if we need to add
    … …  
    10921090static proc init_bads(int @deg)
    10931091"
    1094     initialistion of an empty 'badleads' list
     1092    initialization of an empty 'badleads' list
    10951093"
    10961094{
    … …  
    11191117                                        {
    11201118                                                [1] - leadexp.
    1121                                                 [2] - loeadmonom([1])
     1119                                                [2] - leadmonom([1])
    11221120                                        if kind != 0 (for zReduce) =>
    11231121                                                [3] - !list! of all possible products which give this leadexp
    … …  
    15981596"
    15991597    Gauss with computation of kernel v.s basis
    1600     to be optimizes
     1598    to be optimized
    16011599"
    16021600{
    … …  
    22542252       
    22552253  list @z = list ();                                    // center list
    2256   list @l = init_bads( MaxDeg );        // verbotten loeadexps...
     2254  list @l = init_bads( MaxDeg );        // verbotten leadexps...
    22572255       
    22582256  @q = PBW[ index(0) ];
    … …  
    23202318static proc center_vectorspace( int MaxDeg )
    23212319  "
    2322         pure calculation of center as a finitely dimmensional Vector Space (deg <= MaxDeg )
     2320        pure calculation of center as a finitely dimensional Vector Space (deg <= MaxDeg )
    23232321"
    23242322{
    … …  
    24722470proc inCenter( def a )
    24732471  "USAGE:   inCenter(a); a poly/list/ideal
    2474 RETURN:  integer (1 if a in center, 0 otherwise)
     2472RETURN:  integer (1 if a in the center, 0 otherwise)
    24752473EXAMPLE: example inCenter; shows examples"
    24762474{
    … …  
    25172515/******************************************************************************/
    25182516proc inCentralizer( def a, poly f )
    2519   "USAGE:   inCentralizer(a, f); a poly/list/ideal, f poly
    2520 RETURN:  integer (1 if a in centralizer(f), 0 otherwise)
     2517"USAGE:   inCentralizer(a, f); a poly/list/ideal, f poly
     2518RETURN:  integer (1 if a in the centralizer(f), 0 otherwise)
    25212519EXAMPLE: example inCentralizer; shows examples"
    25222520{
    … …  
    25472545  matrix D[3][3]=0;
    25482546  D[1,2]=-z;
    2549   D[1,3]=0;
    2550   D[2,3]=0;
    2551   ncalgebra(1,D); // this is U(sl_2)
     2547  ncalgebra(1,D); // the Heisenberg algebra
    25522548  poly f = x^2;
    25532549  poly a = z; // lies in center
    … …  
    25612557};
    25622558
    2563 
    2564 
    25652559/******************************************************/
    25662560proc center(int MaxDeg, list # )
    2567   "USAGE:      center(MaxDeg[, N]); int MaxDeg, int N
     2561"USAGE:      center(MaxDeg[, N]); int MaxDeg, int N
    25682562RETURN:     ideal generated by found elements
    25692563NOTE:       computes the 'minimal' set of central elements.
    … …  
    25732567            2. n - the minimal number of desired elements to find.
    25742568SEE ALSO:   centralizer; inCenter
    2575 EXAMPLE:    example center; shows an example"
    2576 {
    2577 
     2569EXAMPLE:    example center; shows an example
     2570"
     2571{
    25782572  if ( myInt(#) > 0 ) // given a number of central elements to compute
    25792573    {
    … …  
    26102604/******************************************************/
    26112605proc centralizer( poly p, int MaxDeg, list # )
    2612   "USAGE:      centralizer(F, MaxDeg[, N]); poly F, int MaxDeg, int N
     2606"USAGE:      centralizer(F, MaxDeg[, N]); poly F, int MaxDeg, int N
    26132607RETURN:     ideal generated by found elements
    26142608NOTE:       computes the 'minimal' set of elements of centralizer(F).

  • Singular/LIB/gkdim.lib

    r9268ce r91c978  
    11///////////////////////////////////////////////////////////////////////////////
    2 version="$Id: gkdim.lib,v 1.5 2004-12-14 21:00:06 levandov Exp $";
     2version="$Id: gkdim.lib,v 1.6 2005-02-23 18:10:45 levandov Exp $";
    33category="Noncommutative";
    44info="
    … …  
    77@*       Rabelo, C.,        crabelo@ugr.es
    88
    9 SUPPORT: Metodos algebraicos y efectivos en grupos cuanticos, BFM2001-3141, MCYT, Jose Gomez-Torrecillas (Main researcher).
    10 
     9SUPPORT: 'Metodos algebraicos y efectivos en grupos cuanticos', BFM2001-3141, MCYT, Jose Gomez-Torrecillas (Main researcher).
    1110
    1211PROCEDURES:
    13 GKdim(M);       Gelfand-Kirillov dimension computation of the factor module basering^n/M where M is a left submodule of basering^n
     12GKdim(M);       Gelfand-Kirillov dimension computation of the factor-module, whose presentation is given by the matrix M
    1413";
    1514
    16 ///////////////////////////////////////////////////////////////////////////////
    17 
     15///////////////////////////////////////////////////////////////////////////////////
    1816static proc idGKdim(ideal I)
    19 // This procedure computes the Gelfand-Kirillov dimension of R/I using
    20 // the dim procedure.
     17"USAGE:   GKdim(I), I is a left ideal
     18RETURN:  int, the Gelfand-Kirillov dimension of the R/I
     19NOTE: uses the dim procedure, if the factor-module is zero, -1 is returned
     20"
    2121{
    2222  if (attrib(I,"isSB")<>1)
    … …  
    3131 
    3232  def oldring=basering;
    33   string newringstring="ring newring=("+charstr(basering)+"),("+varstr(basering)+"),("+ordstr(basering)+")";
     33  string newringstring="ring newring=("+charstr(basering)+"),("+varstr(basering)+"),("+ordstr(basering)+");";
    3434  execute (newringstring);
    3535  setring newring;
    … …  
    4545
    4646///////////////////////////////////////////////////////////////////////////////
    47 
    4847proc GKdim(list L)
    49 "USAGE:   GKdim(L); L is an ideal or a module
    50 RETURN:  int, the Gelfand-Kirillov dimension of R^n/L
     48"USAGE:   GKdim(L);   L is a left ideal/module/matrix
     49RETURN:  int, the Gelfand-Kirillov dimension of the factor-module, whose presentation is given by L
     50NOTE:  if the factor-module is zero, -1 is returned
    5151EXAMPLE: example GKdim; shows examples
    52 "{
     52"
     53{
    5354  def M = L[1];
    5455  if (typeof(M)=="ideal")
    … …  
    9394    else
    9495    {
    95       string d="Error: The input must be an ideal or a module.";
     96      string d="Error: The input must be an ideal, a module or a matrix.";
    9697    }
    9798 }
    … …  
    117118  GKdim(B);
    118119}
    119 
    120120///////////////////////////////////////////////////////////////////////////////

  • Singular/LIB/involut.lib

    r9268ce r91c978  
    1 version="$Id: involut.lib,v 1.1 2004-12-22 21:15:20 levandov Exp $";
     1version="$Id: involut.lib,v 1.2 2005-02-23 18:10:45 levandov Exp $";
    22category="Noncommutative";
    33info="
    44LIBRARY:  involution.lib  Procedures for Computations and Operations with Involutions
    5 AUTHORS:  Oleksandr Iena       yena@mathematik.uni-kl.de
    6 @*        Markus Becker        mbecker@mathematik.uni-kl.de
    7 @*        Viktor Levandovskyy  levandov@mathematik.uni-kl.de
     5AUTHORS:  Oleksandr Iena,       yena@mathematik.uni-kl.de,
     6@*        Markus Becker,        mbecker@mathematik.uni-kl.de,
     7@*        Viktor Levandovskyy,  levandov@mathematik.uni-kl.de
    88
    99SUPPORT: Forschungsschwerpunkt 'Mathematik und Praxis' (Project of Dr. E. Zerz
    … …  
    1111
    1212NOTE: This library provides algebraic tools for computations and operations
    13 with algebraic involutions
     13with algebraic involutions and linear automorphisms of noncommutative algebras
    1414
    1515PROCEDURES:
    16 find_invo();          describes a variety of involutions on a basering;
     16find_invo();          describes a variety of linear involutions on a basering;
    1717find_invo_diag();     describes a variety of homothetic (diagonal) involutions on a basering;
    18 find_auto();          describes a variety of automorphisms of a basering;
     18find_auto();          describes a variety of linear automorphisms of a basering;
    1919ncdetection(ring r);  computes an ideal, presenting an involution map on some classical noncommutative algebras;
    20 involution(m, map theta);  applies the involution, presented by theta to m of type poly, vector, ideal, module, matrix;
    21 
     20involution(m, map theta);  applies the involution, presented by theta, to the object m =
    2221";
    2322
    … …  
    2524LIB "poly.lib";
    2625LIB "primdec.lib";
    27 
     26///////////////////////////////////////////////////////////////////////////////
    2827proc ncdetection(def r)
    29 "USAGE:  ncdetection(r); r a ring
     28"USAGE:  ncdetection(r), r a ring
    3029RETURN:  ideal, presenting an involution map on a noncommutative algebra r
    3130NOTE:    returns optimized involutions for some classical noncomm algebras,
    … …  
    156155  ring r=0,(x,y,z,D(1..3)),dp;
    157156  matrix D[6][6];
    158   D[1,4]=1;
    159   D[2,5]=1;
    160   D[3,6]=1;
     157  D[1,4]=1; D[2,5]=1;  D[3,6]=1;
    161158  ncalgebra(1,D);
    162159  ncdetection(r);
    … …  
    170167  ring r=0,(x,D(1),S),dp;
    171168  matrix D[3][3];
    172   D[1,2]=1;
    173   D[1,3]=-S;
     169  D[1,2]=1;  D[1,3]=-S;
    174170  ncalgebra(1,D);
    175171  ncdetection(r);
    … …  
    270266//   return(n);
    271267}
    272 
     268///////////////////////////////////////////////////////////////////////////////////
    273269proc involution(m, map theta)
    274270"USAGE:  involution(m, theta); m is a poly/vector/ideal/matrix/module, theta is a map
    275 RETURN:  object of the same type as m, involuted under theta
     271PURPOSE: applies the involution, presented by theta to the input m
     272RETURN:  object of the same type as m
    276273EXAMPLE: example involution; shows an example
    277274"
    … …  
    353350  print(M - involution(IM,F)); 
    354351}
    355 
     352///////////////////////////////////////////////////////////////////////////////////
    356353static proc new_var()
    357354//generates a string of new variables
    … …  
    378375  return("@_"+string(i)+"_"+string(j));
    379376};
    380 
     377///////////////////////////////////////////////////////////////////////////////////
    381378static proc new_var_special()
    382379//generates a string of new variables
    … …  
    391388  return(s);
    392389};
    393 
    394 
     390///////////////////////////////////////////////////////////////////////////////////
    395391static proc RelMatr()
    396392// returns the matrix of relations
    … …  
    409405  return(Rel);
    410406};
    411 
    412 
     407/////////////////////////////////////////////////////////////////
    413408proc find_invo()
    414409"USAGE: find_invo();
     410PURPOSE: describes a variety of linear involutions on a basering
    415411RETURN: a ring together with a list of pairs L, where
    416 L[i][1] = GB of an i-th component of ass.primes.
    417 L[i][2] = multiplication matrix, reduced wrt L[i][1].
    418 NOTE: for convenience, the full ideal of relation @@J
    419 and the matrix @@D are returned.
     412@*        L[i][1]  =  Groebner Basis of an i-th associated prime,
     413@*        L[i][2]  =  multiplication matrix, reduced wrt L[i][1]
     414NOTE: for convenience, the full ideal of relations 'idJ'
     415and the matrix with indeterminates 'matD' are exported in the output ring.
    420416"
    421417{
    … …  
    516512  }
    517513  export(L); // main export
    518   ideal @@J = J; // debug-comfortable exports
    519   export(@@J);
    520   export(@@D);
     514  ideal idJ = J; // debug-comfortable exports
     515  matrix matD = @@D;
     516  export(idJ);
     517  export(matD);
    521518  return(@@KK);
    522519}
    … …  
    529526 L;
    530527}
    531 
     528///////////////////////////////////////////////////////////////////////////
    532529proc find_invo_diag()
    533530"USAGE: find_invo_diag();
     531PURPOSE: describes a variety of homothetic (diagonal) involutions on a basering
    534532RETURN: a ring together with a list of pairs L, where
    535 L[i][1] = GB of an i-th component of prim.dec.
    536 L[i][2] = multiplication matrix, reduced wrt L[i][1].
    537 NOTE: for convenience, the full ideal of relation @@J
    538 and the matrix @@D are returned.
     533@*        L[i][1]  =  Groebner Basis of an i-th associated prime,
     534@*        L[i][2]  =  multiplication matrix, reduced wrt L[i][1]
     535NOTE: for convenience, the full ideal of relations 'idJ'
     536and the matrix with indeterminates 'matD' are exported in the output ring.
    539537"
    540538{
    … …  
    636634  } 
    637635  export(L);
    638   ideal @@J = J;
    639   export(@@J);
    640   export(@@D);
     636  ideal idJ = J; // debug-comfortable exports
     637  matrix matD = @@D;
     638  export(idJ);
     639  export(matD);
    641640  return(@@KK);
    642641}
    … …  
    649648 L;
    650649}
    651 
     650/////////////////////////////////////////////////////////////////////
    652651proc find_auto()
    653652"USAGE: find_auto();
     653PURPOSE: describes a variety of linear automorphisms of a basering
    654654RETURN: a ring together with a list of pairs L, where
    655 L[i][1] = GB of an i-th component of prim.dec.
    656 L[i][2] = multiplication matrix, reduced wrt L[i][1].
    657 NOTE: for convenience, the full ideal of relations @@J
    658 and the matrix @@D are returned.
     655@*           L[i][1]  =  Groebner Basis of an i-th associated prime,
     656@*           L[i][2] = multiplication matrix, reduced wrt L[i][1]
     657NOTE: for convenience, the full ideal of relations 'idJ'
     658and the matrix with indeterminates 'matD' are exported in the output ring.
    659659"
    660660{
    … …  
    755755  }
    756756  export(L);
    757   ideal @@J = J;
    758   export(@@J);
    759   export(@@D);
     757  ideal idJ = J; // debug-comfortable exports
     758  matrix matD = @@D;
     759  export(idJ);
     760  export(matD);
    760761  return(@@KK);
    761762}

  • Singular/LIB/ncalg.lib

    r9268ce r91c978  
    11///////////////////////////////////////////////////////////////////////////////
    2 version="$Id: ncalg.lib,v 1.10 2004-12-14 20:59:10 levandov Exp $";
     2version="$Id: ncalg.lib,v 1.11 2005-02-23 18:10:46 levandov Exp $";
    33category="Noncommutative";
    44info="
    55LIBRARY:  ncalg.lib      Definitions of important GR-algebras
    66AUTHORS:  Viktor Levandovskyy,     levandov@mathematik.uni-kl.de,
    7 @*        Oleksandr Motsak,        motsak@mathematik.uni-kl.de.
     7          Oleksandr Motsak,        motsak@mathematik.uni-kl.de.
    88
    99PROCEDURES:
    … …  
    4242proc sl2(list #)
    4343"USAGE:   sl2([p]), p an optional integer (field characteristic)
    44 RETURN:  ring, corresponding to the U(sl_2) in (e,f,h) presentation
    45 NOTE:    you have to activate this ring with the "setring" command
     44PURPOSE: set up the U(sl_2) in the (e,f,h) presentation over the field of char p
     45RETURN:  ring
     46NOTE:    you have to activate this ring with the 'setring' command
    4647SEE ALSO: sl, g2, gl
    4748EXAMPLE: example sl2; shows examples
    … …  
    6667proc sl(int n, list #)
    6768"USAGE:   sl(n,[p]); n an integer, n>1; p an optional integer (field characteristic)
    68 RETURN:  a ring, describing U(sl_n)
    69 NOTE:    You have to activate this ring with the "setring" command. The presentation of U(sl_n) is derived from the standard representation of sl_n, positive resp. negative roots are denoted by x(i) resp. y(i); Cartan elements are denoted by h(i).
     69PURPOSE: set up the U(sl_n) in x(i),y(i),h(i) presentation over the field of char p
     70RETURN:  ring, describing
     71NOTE:    You have to activate this ring with the 'setring' command.
     72@*       The presentation of U(sl_n) is derived from the standard presentation of sl_n,
     73@*       where positive resp. negative roots are denoted by x(i) resp. y(i) and
     74@*       Cartan elements are denoted by h(i).
    7075SEE ALSO: sl2, g2, gl, Qsl3, Qso3
    7176EXAMPLE: example sl; shows examples
    … …  
    162167proc g2(list #)
    163168"USAGE:  g2([p]), p an optional integer (field characteristic)
    164 RETURN:  ring, corresponding to the U(g_2) in (x(i),y(i),Ha,Hb) presentation
    165 NOTE:    you have to activate this ring with the "setring" command
     169PURPOSE: set up the U(g_2) in (x(i),y(i),Ha,Hb) presentation over the field of char p
     170RETURN:  ring
     171NOTE:    you have to activate this ring with the 'setring' command
    166172SEE ALSO: sl, gl
    167173EXAMPLE: example g2; shows examples
    … …  
    232238example
    233239{ "EXAMPLE:"; echo = 2;
    234    def a=g2();
    235    setring a;
    236    a;
     240   def a = g2();
     241   setring a;  a;
    237242}
    238243
    … …  
    241246"
    242247USAGE:   gl(n,[p]); n an integer, n>1;  p an optional integer (field characteristic)
    243 RETURN:  ring, corresponding to the U(gl_n) in the (e_ij (1<i,j<n)) presentation (all matrices)
    244 NOTE:    You have to activate this ring with the "setring" command.
     248PURPOSE: set up the U(gl_n) in the (e_ij (1<i,j<n)) presentation over the field of char p
     249RETURN:  ring
     250NOTE:    You have to activate this ring with the 'setring' command.
    245251SEE ALSO: sl, g2
    246252EXAMPLE: example gl; shows examples
    … …  
    299305{ "EXAMPLE:"; echo = 2;
    300306   def a=gl(3);
    301    setring a;
    302    a;
     307   setring a; a;
    303308};
    304309
    … …  
    306311proc Qso3(list #)
    307312"USAGE:   Qso3([n]), n an optional integers
    308 RETURN:  ring, corresponding to the U_q(so_3) in the presentation of Klimyk; if n is specified, the quantum parameter Q will be specialized at the (2*n)-th root of unity
    309 NOTE:    you have to activate this ring with the "setring" command
     313PURPOSE: set up the U_q(so_3) in the presentation of Klimyk; if n is specified, the quantum parameter Q will be specialized at the (2*n)-th root of unity
     314RETURN:  ring
     315NOTE:    you have to activate this ring with the 'setring' command
    310316SEE ALSO: sl, g2, gl, Qsl2, Qsl3, Qso3Casimir
    311317EXAMPLE: example Qso3; shows examples
    … …  
    335341proc Qso3Casimir(int n, list #)
    336342"USAGE:   Qso3Casimir(n [,m]), n an integer, m an optional integer
    337 RETURN:  list with the Casimir elements of U_q(so_3) for the quantum parameter specialized at the n-th root of unity; if m!=0 is given, polynomials will be normalized
    338 NOTE:    the result of the procedure makes sense only in U_q(so_3)
     343PURPOSE: compute the Casimir elements of U_q(so_3) for the quantum parameter specialized at the n-th root of unity; if m!=0 is given, polynomials will be normalized
     344RETURN:  list (of polynomials)
     345NOTE:    the result of the procedure makes sense only when the basering is U_q(so_3)
    339346SEE ALSO: Qso3
    340347EXAMPLE: example Qso3Casimir; shows examples
    … …  
    393400proc Qsl2(list #)
    394401"USAGE:   Qsl2([n]), n an optional integer
    395 RETURN:  ring, corresponding to the V_q(sl_2) and the ideal Qideal in it. U_q(sl_2) = V_q(sl_2) / Qideal; if n is specified, the quantum parameter q will be specialized at the n-th root of unity
    396 NOTE:    you have to activate this ring with the "setring" command. If you wish to set the U_q(sl_2), you have to call the command "qring Usl2q = Qideal;"
     402PURPOSE: set up the U_q(sl_2) = V_q(sl_2) / Qideal via the ring V_q(sl_2) and the ideal 'Qideal' in it;
     403@*       if n is specified, the quantum parameter q will be specialized at the n-th root of unity
     404RETURN:  ring (V_q(sl_2))
     405NOTE:    you have to activate this ring with the 'setring' command.
     406@*       In order to create the U_q(sl_2) from the output, you have to call the command like 'qring Usl2q = Qideal;'
    397407SEE ALSO: sl, Qsl3, Qso3
    398408EXAMPLE: example Qsl2; shows examples
    … …  
    430440proc Qsl3(list #)
    431441"USAGE:   Qsl3([n]), n an optional integer
    432 RETURN:  ring, corresponding to the V_q(sl_3) and the ideal Qideal in it. U_q(sl_3) = V_q(sl_3) / Qideal; if n is specified, the quantum parameter q will be specialized at the n-th root of unity
    433 NOTE:    you have to activate this ring with the "setring" command. If you wish to set the U_q(sl_3), you have to call the command "qring Usl3q = Qideal;"
     442PURPOSE: set up the U_q(sl_3) = V_q(sl_3) / Qideal via the ring V_q(sl_3) and the ideal 'Qideal' in it;
     443@*       if n is specified, the quantum parameter q will be specialized at the n-th root of unity
     444RETURN:  ring (V_q(sl_3))
     445NOTE:    you have to activate this ring with the 'setring' command.
     446@*       In order to create the U_q(sl_3) from the output, you have to call the command like 'qring Usl3q = Qideal;'
    434447SEE ALSO: sl, Qsl2, Qso3
    435448EXAMPLE: example Qsl3; shows examples
    … …  
    510523   def B = Qsl3(5);
    511524   setring B;
    512    Qideal;
    513525   qring Usl3q = Qideal;
    514526   Usl3q;
    … …  
    516528
    517529proc GKZsystem(intmat A, string sord, string alg, list #)
    518 "USAGE:   GKZsystem(A, sord, alg, [,v]), where A is intmat, defining the system; sord is a string with desired term ordering; alg is string, saying which algorithm
    519 to use (like in toric_lib), v is an optional intvec
    520 RETURN:  ring, over which a system is defined; moreover, the ideal GKZid with equations will be exported
    521 NOTE:    you have to activate the ring with the "setring" command;
     530"USAGE:   GKZsystem(A, sord, alg, [,v]), where
     531@*        A    is an intmat, defining the system,
     532@*        sord is a string with desired term ordering,
     533@*        alg  is a string, saying which algorithm to use (exactly like in toric_lib),
     534@*        v    is an optional intvec.
     535PURPOSE: compute the ring and the GKZ system of equations in it
     536RETURN:  ring (moreover, the ideal GKZid with equations is exported in it)
     537NOTE:    you have to activate the ring with the 'setring' command;
    522538the procedure is elaborated by Oleksandr Yena
    523 OVERVIEW: this procedure uses toric_lib and therefore inherits its input
    524 requirements: possible values for input variable alg are: \"ect\",\"pt\",\"blr\", \"hs\", \"du\". As for term ordering, it should be a string in Singular format like \"lp\",\"dp\", etc. Consult with toric_lib for allowed orderings.
     539OVERVIEW: this procedure uses toric_lib and therefore inherits its input requirements:
     540@*        possible values for input variable 'alg' are: \"ect\",\"pt\",\"blr\", \"hs\", \"du\".
     541@*        As for the term ordering, it should be a string in Singular format like \"lp\",\"dp\", etc. @*        Please consult with the toric_lib for allowed orderings and more details.
    525542SEE ALSO: toric_lib
    526543EXAMPLE: example GKZsystem; shows examples
    … …  
    543560    else
    544561    {
    545       "Wrong type of an optional argument. Intvec expected.";
     562      "Wrong type of the optional argument. Intvec expected.";
    546563      return();
    547564    }

  • Singular/LIB/ncdecomp.lib

    r9268ce r91c978  
    11///////////////////////////////////////////////////////////////////////////////
    2 version="$Id: ncdecomp.lib,v 1.5 2005-02-21 19:14:47 levandov Exp $";
     2version="$Id: ncdecomp.lib,v 1.6 2005-02-23 18:10:46 levandov Exp $";
    33category="Noncommutative";
    44info="
    … …  
    1414PROCEDURES:
    1515CentralQuot(I,G);       central quotient I:G,
    16 CentralSaturation(M,T); central saturation M:T:...:T ( = M:T^{\infty}),
     16CentralSaturation(M,T); central saturation ((M:T):...):T) ( = M:T^{\infty}),
    1717CenCharDec(I,C);        central character decomposition of I w.r.t. C
    1818IntersectWithSub(M,Z);  intersection of M with the subalgebra, generated
    … …  
    176176}
    177177///////////////////////////////////////////////////////////////////////////////
    178 proc CenCharDec(module I, list L)
    179 "USAGE:  CenCharDec(I, L);  I a module, L a list of generators of the center;
     178proc CenCharDec(module I, list Center)
     179"USAGE:  CenCharDec(I, C);  I a module, C a list of generators of the center;
    180180RETURN:  a list L, where each entry consists of three records:
    181            L[*][1] is the character in terms of central elements,
    182            L[*][2] is the Groebner basis of the corresponding weight module,
    183            L[*][3] is the K-dimension of the weight module;
    184 NOTE:     some modules have no finite decomposition (in such a case one
     181@*           L[*][1] is the central character in terms of central elements,
     182@*           L[*][2] is the Groebner basis of the corresponding weight module,
     183@*           L[*][3] is the K-dimension of the weight module;
     184NOTE:     some modules have no finite decomposition (in such case one
    185185          gets warning message)
    186186SEE ALSO: CentralQuot, CentralSaturation
    … …  
    310310proc IntersectWithSub (ideal M, ideal Z)
    311311"USAGE:  IntersectWithSub(M,Z),  M an ideal, Z an ideal of pairwise commutative elements
    312 RETURN:  an intersection of M with the subalgebra, generated by Z
     312PURPOSE: computes an intersection of M with the subalgebra, generated by Z
     313RETURN:  ideal (of two--sided generators, not a Groebner basis!)
    313314NOTE:    usually one puts generators of the center into Z
    314315EXAMPLE: example IntersectWithSub; shows an example

  • Singular/LIB/nctools.lib

    r9268ce r91c978  
    11///////////////////////////////////////////////////////////////////////////////
    2 version="$Id: nctools.lib,v 1.9 2004-12-14 20:50:49 levandov Exp $";
     2version="$Id: nctools.lib,v 1.10 2005-02-23 18:10:46 levandov Exp $";
    33category="Noncommutative";
    44info="
    … …  
    1111
    1212PROCEDURES:
    13 Gweights(r);            Computes weights for a compatible ordering in a G-algebra,
    14 weightedRing(r);        Changes the ordering of a ring to a weighted one,
    15 
    16 ndc([v]);               Computes the ideal of non-degeneracy conditions in G-algebra,
    17 RootOfUnity(n);         Computes the minimal polynomial for the n-th primitive root of unity,
    18 Weyl([p]);              Creates Weyl algebra structure in a basering (two different realizations),
    19 CreateWeyl(n, [p]);      Returns n-th Weyl algebra in x(i),D(i) presentation; in char p, if an integer p is given
    20 Heisenberg(N, [p,d]);     Returns N-th  Heisenberg algebra in x(i),y(i),h realization,
    21 Exterior();             Returns qring, the exterior algebra of a basering,
    22 Fin_dim_algebra(matrix M, list #); Creates finite dimensional algebra structure from basering and the multiplication matrix M,
     13Gweights(r);            computes weights for a compatible ordering in a G-algebra,
     14weightedRing(r);        changes the ordering of a ring to a weighted one,
     15ndc([v]);               the ideal of non-degeneracy conditions in G-algebra,
     16RootOfUnity(n);         the minimal polynomial for the n-th primitive root of unity,
     17Weyl([p]);              creates Weyl algebra structure in a basering (two different realizations),
     18CreateWeyl(n, [p]);     returns n-th Weyl algebra in (x(i),D(i)) presentation; in char p, if an integer p is given,
     19Heisenberg(N, [p,d]);   returns N-th  Heisenberg algebra in (x(i),y(i),h) realization,
     20Exterior();             returns qring, the exterior algebra of a basering,
     21Fin_dim_algebra(matrix M, list #); creates finite dimensional algebra structure from the basering and the multiplication matrix M,
    2322
    2423AUXILIARY PROCEDURES:
    2524Newton(f);              Newton diagram of a polynomial f,
    26 NCRelations(r);         Recovers the non-commutative relations of a G-algebra,
    27 IsCentral(p,[v]);       Check for the commutativity of polynomial p with the G-algebra,
    28 Is_NC();                Checks whether basering is noncommutative,
    29 UpOneMatrix(N);         Returns NxN matrix with 1's in the whole upper triagle,
     25NCRelations(r);         recovers the non-commutative relations of a G-algebra,
     26IsCentral(p,[v]);       check for the commutativity of polynomial p with the G-algebra,
     27Is_NC();                checks whether basering is noncommutative,
     28UpOneMatrix(N);         returns NxN matrix with 1's in the whole upper triagle,
    3029
    3130ALIAS PROCEDURES:
    … …  
    4039proc Gweights(def r)
    4140"USAGE:   Gweights(r); r a ring or a square matrix
    42 RETURN:  a weights vector for the G-algebra r or for a G-algebra which tails matrix is r
    43 NOTE:    with Gweights you only obtain a vector, then you must use it to redefine the G-Algebra. If the input is a matrix and the output is the zero vector then there is not a G-algebra structure associated to these relations with respect to the given variables. Another possibility is to use wRing or weightedRing to obtain directly the G-Algebra.
     41RETURN:   a weight vector for the G-algebra:
     42          r itself, if it is of the type ring,
     43          or for a G-algebra, defined by the square matrix r
     44NOTE:    with Gweights you obtain a vector, which must be used to redefine the G-Algebra. If the input is a matrix and the output is the zero vector then there is not a G-algebra structure associated to these relations with respect to the given variables. Another possibility is to use wRing or weightedRing to obtain directly the G-Algebra.
    4445EXAMPLE: example Gweights; shows examples
    4546SEE ALSO: wRing, weightedRing
    … …  
    101102{
    102103  "EXAMPLE:";echo=2;
    103   ring r = (0,q),(a,b,c,d),M(0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0);
    104   // consider the UPPER TRIANGULAR MATRIX C:
    105   //    0,  q,  q, 1
    106   //    0,  0,  1, q
    107   //    0,  0,  0, q
    108   //    0,  0,  0, 0
    109   // and the UPPER TRIANGULAR MATRIX D:
    110   //    0,  0,  0, m
    111   //    0,  0,  0, 0
    112   //    0,  0,  0, 0  with m=(q - 1/q)*b*c
    113   //    0,  0,  0, 0
    114   matrix C[4][4]; C[1,2]=q; C[1,3]=q; C[1,4]=1; C[2,3]=1; C[2,4]=q; C[3,4]=q;
    115   matrix D[4][4]; D[1,4]=(q-1/q)*b*c;
     104  ring r = (0,q),(a,b,c,d),lp;
     105  matrix C[4][4];
     106  C[1,2]=q; C[1,3]=q; C[1,4]=1; C[2,3]=1; C[2,4]=q; C[3,4]=q;
     107  matrix D[4][4];
     108  D[1,4]=(q-1/q)*b*c;
    116109  ncalgebra(C,D);
    117110  setring r; r;
    118111  Gweights(r);
    119112  Gweights(D);
    120   Gweights(C);
    121 }
    122 
    123 ///////////////////////////////////////////////////////////////////////////////
    124 
    125 // This procedure take a ring r, call to Gweights(r) and use the output of Gweights(r) to make a change of order in r
     113}
     114
     115///////////////////////////////////////////////////////////////////////////////
     116
     117// This procedure take a ring r, call to Gweights(r) and use the output
     118// of Gweights(r) to make a change of order in r
    126119// The output is a new ring, equal to r but the order
    127120// r must be a G-algebra
    … …  
    129122proc weightedRing(def r)
    130123"USAGE:   weightedRing(r); r a ring
    131 RETURN:  the same ring r but the order
     124RETURN:  ring with the relations of r with order changed to comply with
     125the ordering condition for G-algebras
    132126NOTE:    you have to activate this ring with the "setring" command
    133127EXAMPLE: example weightedRing; shows examples
    … …  
    165159{
    166160  "EXAMPLE:";echo=2;
    167   ring r = (0,q),(a,b,c,d),M(0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0);
    168   // consider the UPPER TRIANGULAR MATRIX C:
    169   //    0,  q,  q, 1
    170   //    0,  0,  1, q
    171   //    0,  0,  0, q
    172   //    0,  0,  0, 0
    173   // and the UPPER TRIANGULAR MATRIX D:
    174   //    0,  0,  0, m
    175   //    0,  0,  0, 0
    176   //    0,  0,  0, 0  with m=(q - 1/q)*b*c
    177   //    0,  0,  0, 0
    178   matrix C[4][4]; C[1,2]=q; C[1,3]=q; C[1,4]=1; C[2,3]=1; C[2,4]=q; C[3,4]=q;
    179   matrix D[4][4]; D[1,4]=(q-1/q)*b*c;
     161  ring r = (0,q),(a,b,c,d),lp;
     162  matrix C[4][4];
     163  C[1,2]=q; C[1,3]=q; C[1,4]=1; C[2,3]=1; C[2,4]=q; C[3,4]=q;
     164  matrix D[4][4];
     165  D[1,4]=(q-1/q)*b*c;
    180166  ncalgebra(C,D);
    181167  setring r; r;
    … …  
    198184  "EXAMPLE:";echo=2;
    199185  LIB "qmatrix.lib";
    200   def r=quant(3); // generate quant(3) and store it in r
     186  def r=quant(2); // generate quant(2) and store it in r
    201187  setring r; // set the ring r the active ring
    202188  r;
    … …  
    317303
    318304static proc weightvector(list l)
    319 
    320305"ASSUME:  l is the output of simplex.
    321306RETURNS: if there is a solution, an intvec with the solution."
    … …  
    351336
    352337proc Newton(poly f)
    353 "USAGE:   Newton(f); f an polynomial
     338"USAGE:   Newton(f); f a poly
    354339RETURN:  intmat, representing the Newton diagram of f
    355340NOTE:    each row is the exponent of a monomial of f
    … …  
    389374"USAGE:   NCRelations(r); r a ring
    390375RETURN:  a list with two elements, both elements are of type matrix and
    391          represent the matrices defining the non-commutative relations
    392          of the G-algebra r.
     376         represent the matrices C,D defining the non-commutative relations
     377         of the G-algebra r
    393378EXAMPLE: example NCRelations; shows examples
    394379"{
    … …  
    451436"USAGE:   Fin_dim_algebra(M,[r]); M a matrix, r an optional ring.
    452437RETURN:  nothing. Creates finite dimensional algebra structure in a ring r
    453 (if it is given) or in a basering (by default) from the matrix M. Exports the ideal called Quot for further qring definition.
    454 NOTE: matrix M will be read according to relations x_j*x_i = M[i,j]; Quot is not a two-sided Groebner basis!
     438(if it is given) or in a basering (by default) from the matrix M. Exports the ideal called Quot for further qring definition. 
     439NOTE: matrix M will be read according to relations x_j*x_i = M[i,j]; Quot is not given in its two-sided Groebner basis.
    455440EXAMPLE: Fin_dim_algebra; shows examples
    456441"
    … …  
    555540"USAGE:   UpOneMatrix(N); N an integer, the number of columns
    556541RETURN:  intmat, NxN matrix with 1's in the whole upper triagle
    557 NOTE: is useful while setting noncommutative algebras
     542NOTE: helpful for setting noncommutative algebras with complicated
     543coefficient matrices
    558544EXAMPLE: example UpOneMatrix; shows examples
    559545"{
    … …  
    580566
    581567///////////////////////////////////////////////////////////////////////////////
    582 
    583568proc ndc(list #)
    584569"USAGE:   ndc([v]); v an optional integer. If v!=0 procedure will be verbose
    585 RETURN:  ideal of non-degeneracy conditions
     570RETURN:  ideal of non-degeneracy conditions of the basering
    586571EXAMPLE: example ndc; shows examples
    587572"
    588 // if the second argument is given, produces ndc wrt powers x^N
    589 {
     573{
     574  // if the second argument is given, produces ndc wrt powers x^N
    590575  int N = 1;
    591576  int Verbose = 0;
    … …  
    639624  ncalgebra(C,D);
    640625  r;
    641   ideal j=ndc();
     626  ideal j=ndc(); // the silent version
    642627  j;
    643628  ideal i=ndc(1); // the verbose version
    … …  
    646631
    647632///////////////////////////////////////////////////////////////////////////////
    648 
    649633proc RootOfUnity(int n)
    650634"USAGE:   RootOfUnity(n); n an integer
    651 RETURN:  number, for use as minpoly
     635RETURN:  number, the n-th primitive root of unity (for use as minpoly)
    652636NOTE: works only in field extensions by one element
    653637EXAMPLE: example RootOfUnity; shows examples
    … …  
    725709
    726710///////////////////////////////////////////////////////////////////////////////
    727 
    728711proc Weyl(list #)
    729712"USAGE:   Weyl([p]); p an optional integer.
    730713RETURN:  nothing. Creates Weyl algebra structure in a basering. By default
    731 mimics ( x(1..N),d(1..N) ) realization. If p is given and is not zero,
     714mimics (x(1..N),d(1..N)) realization. If p is given and is not zero,
    732715uses (x(1),d(1),x(2),d(2),... ) realization.
    733716EXAMPLE: example Weyl; shows examples
    … …  
    784767
    785768///////////////////////////////////////////////////////////////////////////////
    786 
    787769proc Heisenberg(int N, list #)
    788770"USAGE:   Heisenberg(N, [p,d]); N an integer (setting 2*N+1 variables), p an optional integer (field characteristic), d an optional integer (power of h in the commutator)

  • Singular/LIB/qmatrix.lib

    r9268ce r91c978  
    1 version="$Id: qmatrix.lib,v 1.7 2005-02-23 15:09:32 Singular Exp $";
     1version="$Id: qmatrix.lib,v 1.8 2005-02-23 18:10:46 levandov Exp $";
    22category="Noncommutative";
    33info="
    … …  
    66@*       Rabelo, C.,     crabelo@ugr.es
    77
    8 SUPPORT: Metodos algebraicos y efectivos en grupos cuanticos, BFM2001-3141, MCYT, Jose Gomez-Torrecillas (Main researcher).
     8SUPPORT: 'Metodos algebraicos y efectivos en grupos cuanticos', BFM2001-3141, MCYT, Jose Gomez-Torrecillas (Main researcher).
    99
    1010MAIN PROCEDURES:
    11 quant(n, [p]);          generates the quantum matrix ring of order n; if optional integer p is specified, the quantum parameter q will be specified at the p-th root of unity
     11quant(n, [p]);          generates the quantum matrix ring of order n;
    1212qminor(u, v, nr);       calculate a quantum minor of a quantum matrix
    1313
    … …  
    2424proc SymGroup(int n)
    2525"USAGE:   SymGroup(n); n an integer, n>0
    26 RETURN:  intmat, containing the symmetric group S(n)
    27 NOTE:    each row is an element of S(n)
     26PURPOSE: present the symmetric group S(n) via integer vectors
     27RETURN:  intmat
     28NOTE:    each row of the output integer matrix is an element of S(n)
     29SEE ALSO: LengthSym, LengthSymElement;
    2830EXAMPLE: example SymGroup; shows examples
    2931"{
    … …  
    7981"USAGE:   LengthSymElement(v); v an intvec representing an element of S(n)
    8082RETURN:  int, the length of v
    81 NOTE:    if v doesn't represent an element of S(n) you may obtain a nonsense output
     83NOTE:    if v doesn't represent an element of S(n), the output may have no sense
     84SEE ALSO: SymGroup, LengthSym
    8285EXAMPLE: example LengthSymElement; shows examples
    8386"{
    … …  
    107110RETURN:  intvec, the i-th element is the length of the i-th row of M
    108111NOTE:    If M is not a subset of S(n), the output may not have meaning
     112SEE ALSO: SymGroup, LengthSymElement
    109113EXAMPLE: example LengthSym; shows examples
    110114"{
    … …  
    131135
    132136proc quant(int n, list #)
    133 "USAGE:   quant(n, [p]); n integer, n>1, p (optional) integer
    134 RETURN:  a ring, describing the quantum matrix ring of order n; if p is specified, the quantum parameter q will be specialized at p-th root of unity
    135 NOTE:    You have to activate this ring with the "setring" command.
    136          The usual representation of the variables in this quantum
    137          algebra is not used because double indexes are not allowed
    138          in the variables. Instead the variables are listed reading
    139          the rows of the usual matrix representation.
     137"USAGE:   quant(n [, p]); n integer (n>1), p an optional integer
     138PURPOSE: compute the quantum matrix ring of order n;
     139RETURN:  ring (of quantum matrices). If p is specified, the quantum parameter q
     140@*       will be specialized at p-th root of unity
     141NOTE:    You have to activate this ring with the 'setring' command.
     142@*       The usual representation of the variables in this quantum
     143@*       algebra is not used because double indexes are not allowed
     144@*       in the variables. Instead the variables are listed reading
     145@*       the rows of the usual matrix representation.
     146SEE ALSO: qminor
    140147EXAMPLE: example quant; shows examples
    141148"{
    … …  
    199206  "EXAMPLE:"; echo=2;
    200207  def r=quant(2); // generate O_q(M_2) at q generic
    201   setring r;
    202   r;
     208  setring r;   r;
    203209  kill r;
    204210  def r=quant(2,5); // generate O_q(M_2) at q^5=1
    205   setring r;
    206   r;
     211  setring r;   r;
    207212}
    208213
    … …  
    210215
    211216proc qminor(intvec I, intvec J, int nr)
    212 "USAGE: qminor(I,J,nr); I is the ORDERED LIST of the rows to consider
    213         in the minor, J is the ORDERED LIST of the cols to consider in the minor and nr is the order of the quantum matrix algebra where you are working (quant(nr)).
     217"USAGE: qminor(I,J,nr); where
     218@*      I is the ordered list of the rows to consider in the minor,
     219@*      J is the ordered list of the columns to consider in the minor and
     220@*      nr is the order of the quantum matrix algebra you are working with (quant(nr)).
    214221RETURN: poly, the quantum minor.
    215222NOTE:    I and J must have the same number of elements.
     223SEE ALSO: quant
    216224EXAMPLE: example qminor; shows examples
    217225"{
    … …  
    258266///////////////////////////////////////////////////////////////////////////////
    259267
    260 // For tecnical reasons we work with a list of variables {y(1)...y(n²)}.
     268// For tecnical reasons we work with a list of variables {y(1)...y(n^2)}.
    261269// In quantum matrices the usual is to work with a square matrix of variables {y(ij)}.
    262270// The formulas are easier if we use matricial notation.
Note: See TracChangeset for help on using the changeset viewer.