Changeset 4caa6c in git

Timestamp:

May 18, 2005, 10:51:16 PM (19 years ago)

Author:

Viktor Levandovskyy <levandov@…>

Branches:

(u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')

Children:

cc5e38df80c917c52275aa45b1835bb4f86a0f7f

Parents:

46f327b10496ff7eead18a5eb83a82f2d90e6904

Message:

*levandov: renamed functions and dependencies


git-svn-id: file:///usr/local/Singular/svn/trunk@8239 2c84dea3-7e68-4137-9b89-c4e89433aadc

Location:

Singular/LIB

Files:

• ncalg.lib (modified) (19 diffs)
• ncdecomp.lib (modified) (4 diffs)
• nctools.lib (modified) (3 diffs)

Singular/LIB/ncalg.lib

@@ -1 +1 @@
 ///////////////////////////////////////////////////////////////////////////////
-version="$Id: ncalg.lib,v 1.13 2005-05-18 18:09:11 levandov Exp $";
+version="$Id: ncalg.lib,v 1.14 2005-05-18 20:51:15 levandov Exp $";
 category="Noncommutative";
 info="
 LIBRARY:  ncalg.lib      Definitions of important GR-algebras
 AUTHORS:  Viktor Levandovskyy,     levandov@mathematik.uni-kl.de,
-          Oleksandr Motsak,        motsak@mathematik.uni-kl.de.
+@*          Oleksandr Motsak,        motsak@mathematik.uni-kl.de.
+
+CONVENTIONS: This library provides pre-defined important noncommutative algebras. 
+@* For universal enveloping algebras of finite dimensional Lie algebras sl_n, gl_n and g_2 there are functions @code{makeUsl}, @code{makeUgl} and @code{makeUg2}.
+@* 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.
 
 PROCEDURES:
-sl(n[,p]);   returns U(sl_n) in char p, if an integer p is given,
-sl2([p]);    returns U(sl_2) in the (e,f,h) presentation; in char p, if an integer p is given,
-g2([p]);     returns U(g_2) in the (x(i),y(i),Ha,Hb) presentation; in char p, if an integer p is given,
-gl(n,[p]);    returns U(gl_n) in the (e_ij (1<i,j<n)) presentation; in char p, if an integer p is given,
-Qso3([n]);   returns U_q(so_3) in the presentation of Klimyk, if integer n is given, the quantum parameter will be specialized at the (2n)-th root of unity,
-Qso3Casimir(n [,m]); returns a list with the (optionally normalized) Casimir elements of U_q(so_3) for the quantum parameter specialized at the n-th root of unity,
-Qsl2([n]); returns ring, corresponding to the V_q(sl_2) and the ideal Qideal in it, such that 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
-Qsl3([n]); returns ring, corresponding to the V_q(sl_3) and the ideal Qideal in it, such that 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
-GKZsystem(A, sord, alg [,v]);  returns a ring and an ideal, describing
-Gelfand-Kapranov-Zelevinsky system of differential equations
+makeUsl(n[,p]);   create U(sl_n) in char p>=0
+makeUsl2([p]);    create U(sl_2) in the variables (e,f,h) in char p>=0
+makeUg2([p]);     create U(g_2) in the variables (x(i),y(i),Ha,Hb) in char p>=0
+makeUgl(n,[p]);   create U(gl_n) in the variables (e_ij (1<i,j<n)) in char p>=0
+makeQso3([n]);    create U_q(so_3) in the presentation of Klimyk (if int n is given, the quantum parameter will be specialized at the 2n-th root of unity)
+Qso3Casimir(n [,m]); returns a list with the (optionally normalized) Casimir elements of U_q(so_3) for the quantum parameter specialized at the 2n-th root of unity
+makeQsl2([n]);    preparation for U_q(sl_2) as factor-algebra; if n is specified, the quantum parameter q will be specialized at the n-th root of unity
+makeQsl3([n]);    preparation for U_q(sl_3) as factor-algebra; if n is specified, the quantum parameter q will be specialized at the n-th root of unity
+GKZsystem(A, sord, alg [,v]);  define a ring and a Gelfand-Kapranov-Zelevinsky system of differential equations
 ";
 
@@ -40 +44 @@
 
 ///////////////////////////////////////////////////////////////////////////////
-proc sl2(list #)
-"USAGE:   sl2([p]), p an optional integer (field characteristic)
-PURPOSE: set up the U(sl_2) in the (e,f,h) presentation over the field of char p
+proc makeUsl2(list #)
+"USAGE:   makeUsl2([p]), p an optional integer (field characteristic)
 RETURN:  ring
-NOTE:    you have to activate this ring with the 'setring' command
-SEE ALSO: sl, g2, gl
-EXAMPLE: example sl2; shows examples
+PURPOSE: set up the U(sl_2) in the variables e,f,h over the field of char p
+NOTE:    activate this ring with the @code{setring} command
+SEE ALSO: makeUsl, makeUg2, makeUgl
+EXAMPLE: example makeUsl2; shows examples
 "{
    int @p = defInt(#);
@@ -59 +63 @@
 example
 { "EXAMPLE:"; echo = 2;
-   def a=sl2();
+   def a=makeUsl2();
    setring a;
    a;
@@ -65 +69 @@
 
 ///////////////////////////////////////////////////////////////////////////////
-proc sl(int n, list #)
-"USAGE:   sl(n,[p]); n an integer, n>1; p an optional integer (field characteristic)
-PURPOSE: set up the U(sl_n) in x(i),y(i),h(i) presentation over the field of char p
-RETURN:  ring, describing
-NOTE:    You have to activate this ring with the 'setring' command.
-@*       The presentation of U(sl_n) is derived from the standard presentation of sl_n,
-@*       where positive resp. negative roots are denoted by x(i) resp. y(i) and
-@*       Cartan elements are denoted by h(i).
-SEE ALSO: sl2, g2, gl, Qsl3, Qso3
-EXAMPLE: example sl; shows examples
+proc makeUsl(int n, list #)
+"USAGE:   makeUsl(n,[p]); n an integer, n>1; p an optional integer (field characteristic)
+RETURN:  ring
+PURPOSE: set up the U(sl_n) in the variables ( x(i),y(i),h(i) | i=1..n+1) over the field of char p
+NOTE:    activate this ring with the @code{setring} command
+@*       This presentation of U(sl_n) is the standard one, i.e. positive resp. negative roots are denoted by x(i) resp. y(i) and the Cartan elements are denoted by h(i).
+@* The variables are ordered as x(1),...x(n),y(1),...,y(n),h(1),...h(n).
+SEE ALSO: makeUsl2, makeUg2, makeUgl, makeQsl3, makeQso3
+EXAMPLE: example makeUsl; shows examples
 "{
   if (n<2)
@@ -83 +86 @@
   if (n==2)
   {
-    def @@@a=sl2(#);
+    def @@@a=makeUsl2(#);
     setring @@@a;
     return(@@@a);
@@ -159 +162 @@
 example
 { "EXAMPLE:"; echo = 2;
-   def a=sl(3);
+   def a=makeUsl(3);
    setring a;
    a;
@@ -165 +168 @@
 
 ///////////////////////////////////////////////////////////////////////////////
-proc g2(list #)
-"USAGE:  g2([p]), p an optional integer (field characteristic)
-PURPOSE: set up the U(g_2) in (x(i),y(i),Ha,Hb) presentation over the field of char p
+proc makeUg2(list #)
+"USAGE:  makeUg2([p]), p an optional int (field characteristic)
 RETURN:  ring
-NOTE:    you have to activate this ring with the 'setring' command
-SEE ALSO: sl, gl
-EXAMPLE: example g2; shows examples
+PURPOSE: set up the U(g_2) in variables (x(i),y(i),Ha,Hb) for i=1..6 over the field of char p
+NOTE:    activate this ring with the @code{setring} command
+@* the variables are ordered as x(1),...x(6),y(1),...,y(6),Ha,Hb.
+SEE ALSO: makeUsl, makeUgl
+EXAMPLE: example makeUg2; shows examples
 "{
   int @p = defInt(#);
@@ -238 +242 @@
 example
 { "EXAMPLE:"; echo = 2;
-   def a = g2();
+   def a = makeUg2();
    setring a;  a;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-proc gl(int n, list #)
-"
-USAGE:   gl(n,[p]); n an integer, n>1;  p an optional integer (field characteristic)
-PURPOSE: set up the U(gl_n) in the (e_ij (1<i,j<n)) presentation over the field of char p
+proc makeUgl(int n, list #)
+"USAGE:   makeUgl(n,[p]); n an int, n>1;  p an optional int (field characteristic)
 RETURN:  ring
-NOTE:    You have to activate this ring with the 'setring' command.
-SEE ALSO: sl, g2
-EXAMPLE: example gl; shows examples
+PURPOSE: set up the U(gl_n) in the (e_ij (1<i,j<n)) presentation (where e_ij corresponds to a matrix with 1 at i,j only) over the field of char p
+NOTE:    activate this ring with the @code{setring} command
+@* the variables are ordered as e_12,e_13,...,e_1n,e_21,...,e_nn.
+SEE ALSO: makeUsl, makeUg2
+EXAMPLE: example makeUgl; shows examples
 "{
   if (n<2)
@@ -271 +275 @@
         };
   };
-  string strRING = "ring RING_GL=(" + string (@p) + "), (" + vs + "),dp;";
+  string strRING = "ring RING_MAKEUGL=(" + string (@p) + "), (" + vs + "),dp;";
   execute( strRING );
-  int N = nvars( RING_GL ); // n*n
+  int N = nvars( RING_MAKEUGL ); // n*n
   matrix D[N][N]=0;
   int k, l;
@@ -300 +304 @@
   };
   ncalgebra(1,D);
-  return(RING_GL);
-}
-example
-{ "EXAMPLE:"; echo = 2;
-   def a=gl(3);
+  return(RING_MAKEUGL);
+}
+example
+{ "EXAMPLE:"; echo = 2;
+   def a=makeUgl(3);
    setring a; a;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
-proc Qso3(list #)
-"USAGE:   Qso3([n]), n an optional integers
-PURPOSE: 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
+proc makeQso3(list #)
+"USAGE:   makeQso3([n]), n an optional int
+PURPOSE: 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 (2n)-th root of unity
 RETURN:  ring
-NOTE:    you have to activate this ring with the 'setring' command
-SEE ALSO: sl, g2, gl, Qsl2, Qsl3, Qso3Casimir
-EXAMPLE: example Qso3; shows examples
+NOTE:    activate this ring with the @code{setring} command
+SEE ALSO: makeUsl, makeUg2, makeUgl, makeQsl2, makeQsl3, Qso3Casimir
+EXAMPLE: example makeQso3; shows examples
 "{
   int @p = 2*defInt(#);
@@ -333 +337 @@
 example
 { "EXAMPLE:"; echo = 2;
-   def K = Qso3(3);
+   def K = makeQso3(3);
    setring K;
    K;
@@ -341 +345 @@
 proc Qso3Casimir(int n, list #)
 "USAGE:   Qso3Casimir(n [,m]), n an integer, m an optional integer
-PURPOSE: 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
 RETURN:  list (of polynomials)
-NOTE:    the result of the procedure makes sense only when the basering is U_q(so_3)
-SEE ALSO: Qso3
+PURPOSE: compute the Casimir (central) 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
+ASSUME:    the basering must be U_q(so_3)
+SEE ALSO: makeQso3
 EXAMPLE: example Qso3Casimir; shows examples
 "{
@@ -389 +393 @@
 example
 { "EXAMPLE:"; echo = 2;
-   def R = Qso3(5);
+   def R = makeQso3(5);
    setring R;
    list C = Qso3Casimir(5);
@@ -398 +402 @@
 
 ///////////////////////////////////////////////////////////////////////////////
-proc Qsl2(list #)
-"USAGE:   Qsl2([n]), n an optional integer
-PURPOSE: 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;
-@*       if n is specified, the quantum parameter q will be specialized at the n-th root of unity
-RETURN:  ring (V_q(sl_2))
-NOTE:    you have to activate this ring with the 'setring' command.
-@*       In order to create the U_q(sl_2) from the output, you have to call the command like 'qring Usl2q = Qideal;'
-SEE ALSO: sl, Qsl3, Qso3
-EXAMPLE: example Qsl2; shows examples
-"
-{
+proc makeQsl2(list #)
+"USAGE:   makeQsl2([n]), n an optional int
+RETURN:   ring
+PURPOSE:  define the U_q(sl_2) as a factor-ring of a ring V_q(sl_2) modulo the ideal @code{Qideal}
+NOTE:   the output consists of a ring, presenting V_q(sl_2) together with the ideal called @code{Qideal} in this ring
+@* activate this ring with the @code{setring} command
+@* in order to create the U_q(sl_2) from the output, execute the command like @code{qring Usl2q = Qideal;}
+@* If n is specified, the quantum parameter q will be specialized at the n-th root of unity
+SEE ALSO: makeUsl, makeQsl3, makeQso3
+EXAMPLE: example makeQsl2; shows examples
+"{
   ring r=(0,q),(E,F,Ke,Kf),dp;
   int @p = defInt(#);
@@ -430 +434 @@
 example
 { "EXAMPLE:"; echo = 2;
-   def A = Qsl2(3);
+   def A = makeQsl2(3);
    setring A;
    Qideal;
@@ -438 +442 @@
 
 ///////////////////////////////////////////////////////////////////////////////
-proc Qsl3(list #)
-"USAGE:   Qsl3([n]), n an optional integer
-PURPOSE: 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;
-@*       if n is specified, the quantum parameter q will be specialized at the n-th root of unity
-RETURN:  ring (V_q(sl_3))
-NOTE:    you have to activate this ring with the 'setring' command.
-@*       In order to create the U_q(sl_3) from the output, you have to call the command like 'qring Usl3q = Qideal;'
-SEE ALSO: sl, Qsl2, Qso3
-EXAMPLE: example Qsl3; shows examples
+proc makeQsl3(list #)
+"USAGE:   makeQsl3([n]), n an optional int
+RETURN:   ring
+PURPOSE:  define the U_q(sl_3) as a factor-ring of a ring V_q(sl_3) modulo the ideal @code{Qideal}
+NOTE:   the output consists of a ring, presenting V_q(sl_3) together with the ideal called @code{Qideal} in this ring
+@* activate this ring with the @code{setring} command
+@* in order to create the U_q(sl_3) from the output, execute the command like @code{qring Usl3q = Qideal;}
+@* If n is specified, the quantum parameter q will be specialized at the n-th root of unity
+SEE ALSO: makeUsl, makeQsl2, makeQso3
+EXAMPLE: example makeQsl3; shows examples
 "{
   int @p = defInt(#);
@@ -513 +518 @@
   C[ 2, 7 ]= q;
   C[ 3, 7 ]= Q;
-  ncalgebra(C,D); // the V_q(sl3) is done
+  ncalgebra(C,D); // the V_q(makeUsl3) is done
   ideal Qideal = k1*l1-1,  k2*l2-1;
   Qideal = twostd(Qideal);
@@ -521 +526 @@
 example
 { "EXAMPLE:"; echo = 2;
-   def B = Qsl3(5);
+   def B = makeQsl3(5);
    setring B;
    qring Usl3q = Qideal;
@@ -536 +541 @@
 @*        @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 \"setring\" command. This procedure is elaborated by Oleksandr Yena
+NOTE:    activate the ring with the @code{setring} command. This procedure is elaborated by Oleksandr Yena
 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

@@ -1 +1 @@
 ///////////////////////////////////////////////////////////////////////////////
-version="$Id: ncdecomp.lib,v 1.10 2005-05-18 18:09:12 levandov Exp $";
+version="$Id: ncdecomp.lib,v 1.11 2005-05-18 20:51:15 levandov Exp $";
 category="Noncommutative";
 info="
@@ -128 +128 @@
 { "EXAMPLE:"; echo = 2;
    option(returnSB);
-   def a = sl2();
+   def a = makeUsl2();
    setring a;
    ideal I = e3,f3,h3-4*h;
@@ -167 +167 @@
 { "EXAMPLE:"; echo = 2;
    option(returnSB);
-   def a = sl2();
+   def a = makeUsl2();
    setring a;
    ideal I = e3,f3,h3-4*h;
@@ -318 +318 @@
 { "EXAMPLE:"; echo = 2;
    option(returnSB);
-   def a = sl2(); // U(sl_2) in characteristic 0
+   def a = makeUsl2(); // U(sl_2) in characteristic 0
    setring a;
    ideal I = e3,f3,h3-4*h;

Singular/LIB/nctools.lib

@@ -1 +1 @@
 ///////////////////////////////////////////////////////////////////////////////
-version="$Id: nctools.lib,v 1.14 2005-05-18 18:09:12 levandov Exp $";
+version="$Id: nctools.lib,v 1.15 2005-05-18 20:51:16 levandov Exp $";
 category="Noncommutative";
 info="
@@ -665 +665 @@
 "USAGE:  makeHeisenberg(n, [p,d]); int n (setting 2n+1 variables), optional int p (field characteristic), optional int d (power of h in the commutator)
 RETURN: nothing
-PURPOSE: create an n-th Heisenberg algebra in the variables 
-x(1),y(1),...,x(n),y(n),h
+PURPOSE: create an n-th Heisenberg algebra in the variables x(1),y(1),...,x(n),y(n),h
 SEE ALSO: makeWeyl
 NOTE: activate this ring with the \"setring\" command
@@ -714 +713 @@
 PURPOSE:  create the exterior algebra of a basering
 NOTE:  activate this qring with the \"setring\" command
-THEORY: given a basering, this procedure introduces the anticommutative relations x(j)x(i)=-x(i)x(j) for all j>i and, moreover, creates a factor algebra modulo the two-sided ideal, generated by x(i)^2 for all i
+THEORY: given a basering, this procedure introduces the anticommutative relations x(j)x(i)=-x(i)x(j) for all j>i,
+@* moreover, creates a factor algebra modulo the two-sided ideal, generated by x(i)^2 for all i
 EXAMPLE: example Exterior; shows examples
 "