Changeset f2ed2d in git

Timestamp:

Apr 9, 2010, 11:22:04 PM (13 years ago)

Author:

Motsak Oleksandr <motsak@…>

Branches:

(u'spielwiese', '0d6b7fcd9813a1ca1ed4220cfa2b104b97a0a003')

Children:

a0f5849764a78dfc4f5394cbc998a82eefdd6644

Parents:

7d9253b1d9528cb0ec8435d0e009b4bc3b24d9ae

Message:

fixed help, examples + attributes

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

File:

• Singular/LIB/nctools.lib (modified) (19 diffs)

Singular/LIB/nctools.lib

@@ -22 +22 @@
 Exterior();               return qring, the exterior algebra of a basering,
 findimAlgebra(M,[r]);     create finite dimensional algebra structure from the basering and the multiplication matrix M,
-superCommutative([b,e,Q]);  return qring, the super-commutative algebra over a basering,
+superCommutative([b,e,Q]);  return qring, a super-commutative algebra over a basering,
 rightStd(I);              compute a right Groebner basis of an ideal,
 
@@ -733 +733 @@
 ///////////////////////////////////////////////////////////////////////////////
 proc superCommutative(list #)
-"USAGE:   superCommutative([b,[e, [Q, [flag]]]]);
+"USAGE:   superCommutative([b,[e, [Q]]]);
 RETURN:  qring
 PURPOSE:  create a super-commutative algebra (as a GR-algebra) over a basering,
 NOTE: activate this qring with the \"setring\" command.
-NOTE: if b==e then the resulting ring is commutative unless 'flag' is given and non-zero.
-@* By default, @code{b=1, e=nvars(basering), Q=0}, and @code{flag=0}.
-THEORY: given a basering, this procedure introduces the anticommutative relations x(j)x(i)=-x(i)x(j) for all e>=j>i>=b,
-@* moreover, creates a factor algebra modulo the two-sided ideal, generated by x(b)^2, ..., x(e)^2[ + Q]
+NOTE: if b==e then the resulting ring is commutative.
+@* By default, @code{b=1, e=nvars(basering), Q=0}.
+THEORY: given a basering, this procedure introduces the anti-commutative relations
+@* var(j)var(i)=-var(i)var(j) for all e>=j>i>=b and creates the quotient 
+@* of the anti-commutative algebra modulo the two-sided ideal, generated by 
+@* x(b)^2, ..., x(e)^2[ + Q]
 DISPLAY: If @code{printlevel} > 1, warning debug messages will be printed
 EXAMPLE: example superCommutative; shows examples
@@ -813 +815 @@
   }
 
-  if(size(#)>3)
+/*  if(size(#)>3)
   {
     if(typeof(#[4]) != "int")
@@ -822 +824 @@
     flag = #[4];
   }
+*/
 
   int iSavedDegBoung = degBound;
@@ -848 +851 @@
   setring @R; // @R;
 */
+  int i, j;
 
   if( (char(basering)==2) && (flag == 0) )// commutative ring!!!
@@ -856 +860 @@
     }
 
-    int j = ncols(Q) + 1;
-
-    for ( int i=e; i>=b; i--, j++ )
-    {
-      Q[j] = var(i)^2;
+    ideal I; 
+
+    for (i = e - b + 1; i > 0; i--)
+    {
+      I[i] = var(i + b - 1)^2;
     }
 
     degBound=0;
-    Q = std(Q);
+    Q = std(I + Q);
     degBound = iSavedDegBoung;
 
@@ -872 +876 @@
 
 
-  int i, j;
 
   if( (b == 1) && (e == N) ) // just an exterior algebra?
@@ -893 +896 @@
   }
 
-  ideal @Q = fetch(saveRing, Q);
-
-  j = ncols(@Q) + 1;
-
-  for ( i=e; i>=b; i--, j++ )
-  {
-    @Q[j] = var(i)^2;
-  }
-
-  if( (fprot == 1) and (attrib(basering, "global") != 1) )
-  {
-    print("Warning: Since the current ordering is not global there might be problems computing twostd(Q)!");
-    "Q:"; 
-    @Q;
-  }
+  ideal @I; 
+
+  for (i = e - b + 1; i > 0; i--)
+  {
+    @I[i] = var(i + b - 1)^2;
+  }
+
 
   degBound=0;
-  @Q = twostd(@Q); // must be computed within the ground G-algebra => problems with local orderings!
+  @I = twostd(@I); // must be computed within the ground G-algebra => problems with local orderings!
   degBound = iSavedDegBoung;
 
-  qring @EA = @Q;
+  qring @EA = @I;
+
+  ideal @Q = twostd(fetch(saveRing, Q));
+  
+  if( size(@Q) > 0 )
+  {
+    qring @EA2 = @Q;  
+  }
+  
+  attrib(basering, "isSCA", 1==1);
+  attrib(basering, "iAltVarStart", b);
+  attrib(basering, "iAltVarEnd", e);
 
 //   "Alternating variables: [", AltVarStart(), ",", AltVarEnd(), "].";
-  return(@EA);
+  return(basering);
 }
 example
@@ -931 +937 @@
   "Alternating variables: [", AltVarStart(), ",", AltVarEnd(), "].";
   kill R; kill ER;
-  ring R = 0,(x(1..6)),(ls(2), dp(2), lp(2)); // local!
-  def ER = superCommutative(3,4); // b = 3, e = 4
+  ring R = 0,(x, y, z),(ds(1), dp(2)); // mixed!
+  def ER = superCommutative(2,3); // b = 2, e = 3
   setring ER; ER;
   "Alternating variables: [", AltVarStart(), ",", AltVarEnd(), "].";
+  x + 1 + z + y; // ordering on variables: y > z > 1 > x
+  std(x - x*x*x);
+  std(ideal(x - x*x*x, x*x*z + y, z + y*x*x));
   kill R; kill ER;
+  ring R = 0,(x, y, z),(ds(1), dp(2)); // mixed!
+  def ER = superCommutative(2, 3, ideal(x - x*x, x*x*z + y, z + y*x*x )); // b = 2, e = 3
+  setring ER; ER;
+  "Alternating variables: [", AltVarStart(), ",", AltVarEnd(), "].";  
 }
 
 // Please, don't throw this away!!! Needed for backward compatibility.
 proc SuperCommutative(list #)
-{
-  // "Please use superCommutative instead";
+"USAGE:   please use @code{superCommutative} instead
+"
+{
+  "// This procedure is deprecated. Please use superCommutative instead";
   return( superCommutative(#) );
 }
-
+example
+{
+  "EXAMPLE:";
+  "Procedure is deprecated. Please use superCommutative instead";
+}
 
 static proc ParseSCA()
@@ -952 +971 @@
 "
 {
+  if(typeof(attrib(basering, "isSCA"))=="int") // workaround, if(defined()) doesn't work!!!!
+  {
+    if(typeof(attrib(basering, "iAltVarStart"))=="int")
+    {
+      if(typeof(attrib(basering, "iAltVarEnd"))=="int")
+      {
+        if(attrib(basering, "isSCA")) 
+        {
+          return(list(
+            attrib(basering, "iAltVarStart"),
+            attrib(basering, "iAltVarEnd")
+                 ));
+        }
+      }
+    }
+  }
+
   def saveRing = basering;
 
@@ -960 +996 @@
   int e =  -1;
 
-  int fprot = (find(option(),"prot") != 0);
+  int fprot = 0; // (find(option(),"prot") != 0);
 
 
@@ -974 +1010 @@
     if(fprot)
     {
-      print("Warning: The current ring is internally commutative!");
+      print("// Warning: The current ring is internally commutative!");
     }
 
@@ -983 +1019 @@
         if( (fprot == 1) and (i > 1) )
         {
-          print("Warning: the SCA representation of the current commutative factor ring may be ambiguous!");
+          print("// Warning: the SCA representation of the current commutative factor ring may be ambiguous!");
         }
 
@@ -1084 +1120 @@
 
   ////////////////////////////////////////////////////////////////////////
-  // ok. it is a SCA!!!
+  // ok. this is a SCA!!!
 
   return(list(b, e));
@@ -1094 +1130 @@
 RETURN:  int
 PURPOSE:  returns the number of the first alternating variable of basering
-NOTE:  basering should be a super-commutative algebra with at most one block of anti-commutative variables
-@* For commutative rings, @code{nvars(basering)+1} will be returned.
+NOTE:  basering should be a super-commutative algebra constructed by 
+@*     the procedure @code{superCommutative}, emits an error otherwise
 EXAMPLE: example AltVarStart; shows examples
 "
@@ -1116 +1152 @@
   setring ER; ER;
   "Alternating variables: [", AltVarStart(), ",", AltVarEnd(), "].";
+  setring R;
+  "Alternating variables: [", AltVarStart(), ",", AltVarEnd(), "].";  
+  kill R, ER;
+  //////////////////////////////////////////////////////////////////
+  ring R = 2,(x(1..4)),dp; // the same in char. = 2!
+  def ER = superCommutative(2); // (b = 2, e = N)
+  setring ER; ER;
+  "Alternating variables: [", AltVarStart(), ",", AltVarEnd(), "].";
+  setring R;
+  "Alternating variables: [", AltVarStart(), ",", AltVarEnd(), "].";  
 }
 
@@ -1123 +1169 @@
 RETURN:  int
 PURPOSE:  returns the number of the last alternating variable of basering
-NOTE:  basering should be a super-commutative algebra with at most one block of anti-commutative variables
-@* returns -1 for commutative rings
+NOTE:  basering should be a super-commutative algebra constructed by 
+@*     the procedure @code{superCommutative}, emits an error otherwise
 EXAMPLE: example AltVarEnd; shows examples
 "
@@ -1145 +1191 @@
   setring ER; ER;
   "Alternating variables: [", AltVarStart(), ",", AltVarEnd(), "].";
+  setring R;
+  "Alternating variables: [", AltVarStart(), ",", AltVarEnd(), "].";  
+  kill R, ER;
+  //////////////////////////////////////////////////////////////////
+  ring R = 2,(x(1..4)),dp; // the same in char. = 2!
+  def ER = superCommutative(2); // (b = 2, e = N)
+  setring ER; ER;
+  "Alternating variables: [", AltVarStart(), ",", AltVarEnd(), "].";
+  setring R;
+  "Alternating variables: [", AltVarStart(), ",", AltVarEnd(), "].";  
 }
 
@@ -1151 +1207 @@
 "USAGE:   IsSCA();
 RETURN:  int
-PURPOSE:  returns 1 if basering is a super-commutative algebra and 0 otherwise.
-NOTE:     shows hint message for non-SCA algebras if the 'prot' option is on.
+PURPOSE:  returns 1 if basering is a super-commutative algebra and 0 otherwise
 EXAMPLE: example IsSCA; shows examples
 "