Changeset c01764 in git

Timestamp:

Mar 16, 2018, 6:30:03 PM (6 years ago)

Author:

Karim Abou Zeid <karim23697@…>

Branches:

(u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')

Children:

01a1e69963e02904f3ebb7e48ddd938c9489cc76d1bb4ad41c5c390887e85591280f23792d561fb2

Parents:

0ffcd2e4895401f8aa6557ccbabaca11e287d05a9db8343e5043f1916262be4000d0b798d2cf2b8c

Message:

Merge branch 'fpalgebras' into stable

Location:

Singular/LIB

Files:

• fpadim.lib (modified) (3 diffs)
• fpalgebras.lib (added)
• fpaprops.lib (modified) (14 diffs)
• freegb.lib (modified) (9 diffs)

Singular/LIB/fpadim.lib

@@ -2378 +2378 @@
   return (words);
 }
-example {
+example
+{
   "EXAMPLE:"; echo = 2;
   ring r = 0,(a,b,c),dp;
@@ -2399 +2400 @@
   return(ivL2lpI(ivMaxIdeal(d, donly)));
 }
-example {
+example
+{
   "EXAMPLE:"; echo = 2;
   ring r = 0,(a,b,c),dp;
@@ -2489 +2491 @@
   return(I);
 }
-example {
+example
+{
   "EXAMPLE:"; echo = 2;
   ring r = 0,(x,y),dp;

Singular/LIB/fpaprops.lib

@@ -19 +19 @@
 PROCEDURES:
   lpNoetherian(<GB>);     check whether A/<GB> is (left/right) noetherian
-  lpIsSemiPrime(<GB>);    check whether A/<GB> is semi prime
-  lpIsPrime(<GB>);        check whether A/<GB> is prime
+  lpIsSemiPrime(<GB>);    check whether A/<LM(GB)> is semi prime
+  lpIsPrime(<GB>);        check whether A/<LM(GB)> is prime
   lpGkDim(<GB>);          compute the Gelfand Kirillov dimension of A/<GB>
   lpGlDimBound(<GB>);     compute an upper bound for the global dimension of A/<GB>
@@ -37 +37 @@
 @*      2 right noetherian
 @*      3 noetherian
-PURPOSE: Check whether R/<G> is (left/right) noetherian, where R is the basering
+PURPOSE: Check whether A/<G> is (left/right) noetherian
 ASSUME: - basering is a Letterplace ring
 @*      - G is a Groebner basis
@@ -108 +108 @@
   return (3 - inFlag - outFlag);
 }
-example {
+example
+{
   "EXAMPLE:"; echo = 2;
   ring r = 0,(x,y),dp;
@@ -198 +199 @@
 "USAGE: lpIsSemiPrime(G); G an ideal in a Letterplace ring
 RETURN: boolean
-PURPOSE: Check whether R/<G> is semi prime, where R is the basering
+PURPOSE: Check whether A/<LM(G)> is semi prime, that is when p * (A/<LM(G)>) * p != 0 for all p in (A/<LM(G)> - {0}).
 ASSUME: - basering is a Letterplace ring
       - G is a Groebner basis
@@ -249 +250 @@
   return (1);
 }
-example {
+example
+{
   "EXAMPLE:"; echo = 2;
   ring r = 0,(x1,x2),dp;
@@ -298 +300 @@
 "USAGE: lpIsPrime(G); G an ideal in a Letterplace ring
 RETURN: boolean
-PURPOSE: Check whether R/<G> is prime, where R is the basering
+PURPOSE: Check whether A/<LM(G)> is prime, that is when p1 * (A/<LM(G)>) * p2 != 0 for all p1, p2 in (A/<LM(G)> - {0}).
 ASSUME: - basering is a Letterplace ring
       - G is a Groebner basis
@@ -362 +364 @@
   return (1);
 }
-example {
+example
+{
   "EXAMPLE:"; echo = 2;
   ring r = 0,(x,y),dp;
@@ -681 +684 @@
   return (UG);
 }
-example {
+example
+{
   "EXAMPLE:"; echo = 2;
   ring r = 0,(x,y,z),dp;
@@ -1047 +1051 @@
     for (int j = 1; j <= size(ivfi); j++) {
       int varindex = ivfi[j];
-      int subindex = lpIndexOf(s1, var(varindex));
-      if (subindex > 0) {
-        s2[subindex] = lpNF(s2[subindex],G);
-        fis = lpMult(fis, s2[subindex]);
-      } else {
-        fis = lpMult(fis, lpNF(iv2lp(varindex),G));
-      }
-      /*fis = lpNF(fis,G);*/
-      kill varindex; kill subindex;
+      if (varindex > 0) {
+        int subindex = lpIndexOf(s1, var(varindex));
+        if (subindex > 0) {
+          s2[subindex] = lpNF(s2[subindex],G);
+          fis = lpMult(fis, s2[subindex]);
+        } else {
+          fis = lpMult(fis, lpNF(iv2lp(varindex),G));
+        }
+        /*fis = lpNF(fis,G);*/
+        kill subindex;
+      }
+      kill varindex;
     } kill j;
     kill ivfi;
@@ -1065 +1072 @@
   return (fs);
 }
-example {
+example
+{
+  "EXAMPLE:"; echo = 2;
   //////// EXAMPLE A ////////
   ring r = 0,(x,y,z),dp;
@@ -1144 +1153 @@
     for (int j = 1; j <= size(ivfi); j++) {
       int varindex = ivfi[j];
-      int subindex = lpIndexOf(s1, var(varindex));
-      if (subindex > 0) {
-        tmpDegBound = tmpDegBound + deg(s2[subindex]);
-      } else {
-        tmpDegBound = tmpDegBound + 1;
-      }
-      kill varindex; kill subindex;
+      if (varindex > 0) {
+        int subindex = lpIndexOf(s1, var(varindex));
+        if (subindex > 0) {
+          tmpDegBound = tmpDegBound + deg(s2[subindex]);
+        } else {
+          tmpDegBound = tmpDegBound + 1;
+        }
+        kill subindex;
+      }
+      kill varindex;
     } kill j;
     if (tmpDegBound > maxDegBound) {
@@ -1160 +1172 @@
   // increase degbound by 50% when ideal is provided
   // needed for lpNF
-  maxDegBound = maxDegBound + maxDegBound/2;
+  maxDegBound = maxDegBound + (maxDegBound div 2);
 
   return (maxDegBound);
 }
-example {
+example
+{
   // see lpSubstitute()
 }
@@ -1187 +1200 @@
   return (maxDegBound);
 }
-example {
+example
+{
   // see lpSubstitute()
 }
@@ -1277 +1291 @@
   def R = lpDelVar(2); setring R; R;
 }
+

Singular/LIB/freegb.lib

@@ -37 +37 @@
 ademRelations(i,j);    compute the ideal of Adem relations for i<2j in char 0
 
+lpPrint(ideal I, def @r); print a letterplace ideal as an easily readable string
+
 SEE ALSO: fpadim_lib, LETTERPLACE
 ";
@@ -49 +51 @@
 LIB "qhmoduli.lib"; // for Max
 LIB "bfun.lib"; // for inForm
+LIB "fpadim.lib"; // for intvec conversion
 
 proc tstfreegb()
@@ -2521 +2524 @@
   int uptodeg = attrib(basering,"uptodeg");
   int lV = attrib(basering,"lV");
-  if (deg(a) + i > uptodeg)
-  {
-    ERROR("degree bound violated by the shift!");
-  }
   return(system("stest",a,i,uptodeg,lV));
 }
@@ -2539 +2538 @@
 }
 
+proc lastBlock(poly p)
+"USAGE:  lastBlock(p); p letterplace poly
+RETURN: int
+ASSUME: basering has letterplace ring structure
+PURPOSE: get the number of the last block occuring in the poly
+EXAMPLE: example lastBlock; shows examples
+"
+{
+  if (lpAssumeViolation())
+  {
+    ERROR("Incomplete Letterplace structure on the basering!");
+  }
+  int lV = attrib(basering,"lV");
+  // calls pLastVblock(p,lV);
+  return(system("btest",p,lV));
+}
+example
+{
+  "EXAMPLE:"; echo = 2;
+  ring r = 0,(x,y,z),dp;
+  int uptodeg = 5;
+  def R = makeLetterplaceRing(uptodeg);
+  setring R;
+  poly f = x(1)*z(2)*y(3) - 2*z(1)*y(2) + 3*x(1);
+  lastBlock(f); // should be 3
+}
 
 static proc mmLiebr(poly a, poly b)
@@ -3276 +3301 @@
 }
 
+proc lpDivision(poly p, ideal I)
+"ASSUME: I is a Groebner basis G = {g1,...,gN}, the original ring of the Letterplace ring has the name 'r' and no variable is called 'tag_i' for i in 1...N
+RETURN: list L
+NOTE: - L[1] NF(p,I)
+      - L[2] list of expressions [i,l_{ij},r_{ij}] with \sum_{i,j} l_{ij} g_i r_{ij} = p - NF(p,I)
+"
+{
+  if (p == 0 || size(I) == 0) {
+    list L = 0;
+    list empty;
+    L[2] = empty;
+    return (L);
+  }
+  poly pNF = lpNF(p,I);
+  p = p - pNF;
+
+  // make new ring
+  def save = basering;
+  int norigvars = nvars(r);
+  string tagvarstr = "(tag_1";
+  for (int i = 2; i <= size(I); i++) {
+    tagvarstr = tagvarstr + ",tag_" + string(i);
+  } kill i;
+  tagvarstr = tagvarstr + ")";
+  string field = string(ringlist(r)[1]);
+  execute("ring @tags = " + field + "," + tagvarstr + ",dp;");
+  ring @tagged = (r + @tags);
+  def @R = makeLetterplaceRing(attrib(save,"uptodeg")); setring @R;
+
+  // restore vars
+  poly p = imap(save, p);
+  poly pNF = imap(save, pNF);
+  ideal I = imap(save, I);
+  for (int i = 1; i <= size(I); i++) {
+    I[i] = I[i] - var(norigvars + i);
+  } kill i;
+
+  list summands;
+  list L = pNF;
+  poly pTaggedNF = lpNF(p,I);
+  for (int i = 1; i <= size(pTaggedNF); i++) {
+    intvec iv = lp2iv(pTaggedNF[i]);
+    for (int j = 1; j <= size(iv); j++) {
+      if (iv[j] > norigvars) {
+        intvec left;
+        intvec right;
+        if (j > 1) {
+          left = iv[1..(j-1)];
+        }
+        if (j < size(iv)) {
+          right = iv[(j+1)..size(iv)];
+        }
+        list summand = (iv[j] - norigvars), leadcoef(pTaggedNF[i])*iv2lp(left), iv2lp(right);
+        summands = insert(summands, summand, size(summands));
+
+        kill left;
+        kill right;
+        kill summand;
+        break;
+      }
+    } kill j;
+    kill iv;
+  } kill i;
+
+  L[2] = summands;
+
+  setring save;
+  list L = imap(@R,L);
+  return (L);
+}
+
+proc lpGBPres2Poly(list L, ideal I)
+"ASSUME: L is a valid Groebner presentation as for example the result of lpDivision
+RETURN: poly
+NOTE: computes p = \sum_{i,j} l_{ij} g_i r_{ij} + NF(p,I) = \sum_{i} L[2][i][2] I[L[2][i][1]] L[2][i][3] + L[1]
+"
+{
+  poly p;
+  for (int i = 1; i <= size(L[2]); i++) {
+    p = p + lpMult(lpMult(L[2][i][2], I[L[2][i][1]]), L[2][i][3]);
+  }
+  p = p + L[1];
+  return (p);
+}
+
 //procedures to convert monomials into the DVec representation, all static
 ////////////////////////////////////////////////////////
@@ -3473 +3583 @@
 }
 
-
+proc isOrderingShiftInvariant(int withHoles)
+  "USAGE: isOrderingShiftInvariant(b); b an integer interpreted as a boolean
+  RETURN: int
+  NOTE: Tests whether the ordering of the current ring is shift invariant, which is the case, when LM(p) > LM(p') for all p and p' where p' is p shifted by any number of places.
+@*      If withHoles != 0 even Letterplace polynomials with holes (eg. x(1)*y(4)) are considered.
+  ASSUME: - basering is a Letterplace ring.
+  "
+{
+  int shiftInvariant = 1;
+
+  int n = attrib(basering, "lV");
+  int d = attrib(basering, "uptodeg");
+
+  ideal monomials;
+  if (withHoles) {
+    monomials = delete(lpMonomialsWithHoles(d-1), 1); // ignore the first element (1)
+  } else {
+    monomials = lpMaxIdeal(d-1, 0);
+  }
+
+  for (int i = 1; i <= size(monomials); i++) {
+    poly monom = monomials[i];
+    int lastblock = lastBlock(monom);
+    for (int s = 1; s <= d - lastblock; s++) {
+      for (int s2 = 0; s2 < s; s2++) { // paranoid, check every pair
+        poly first = shiftPoly(monom,s2);
+        poly second = shiftPoly(monom,s);
+        if (!(first > second)) {
+          dbprint(string(first) + " <= " + string(second));
+          shiftInvariant = 0;
+        }
+        kill first; kill second;
+      } kill s2;
+    } kill s;
+    kill monom; kill lastblock;
+  } kill i;
+
+  return(shiftInvariant);
+}
+example
+{
+  "EXAMPLE:"; echo = 2;
+  ring r = 0,(x,y,z),dp;
+  def R = makeLetterplaceRing(5);
+  setring R;
+  isOrderingShiftInvariant(0);// should be 1
+
+  ring r = 0,(x,y,z),dp;
+  def R = makeLetterplaceRing(5);
+  list RL = ringlist(R);
+  RL[3][1][1] = "wp";
+  intvec weights = 1,1,1,1,1,1,1,2,3,1,1,1,1,1,1;
+  RL[3][1][2] = weights;
+  def Rw = setLetterplaceAttributes(ring(RL),5,3);
+  setring Rw;
+  printlevel = voice + 1;
+  isOrderingShiftInvariant(0);
+  isOrderingShiftInvariant(1);
+}
+
+static proc lpMonomialsWithHoles(int d)
+{
+  if (d < 0) {
+    ERROR("d must not be negative")
+  }
+
+  ideal monomials = 1;
+  if (d == 0) {
+     return (monomials);
+  }
+
+  int lV = attrib(basering, "lV"); // variable count
+  ideal prevMonomials = lpMonomialsWithHoles(d - 1);
+
+  for (int i = 1; i <= size(prevMonomials); i++) {
+    /* if (deg(prevMonomials[i]) >= d - 1) { */
+      for (int j = 1; j <= lV; j++) {
+        poly m = prevMonomials[i];
+        m = m * var(j + (d-1)*lV);
+        monomials = monomials, m;
+        kill m;
+      } kill j;
+    /* } */
+  } kill i;
+
+  if (d > 1) {
+    // removes the 1
+    monomials[1] = 0;
+    monomials = simplify(monomials,2);
+
+    monomials = prevMonomials, monomials;
+  }
+  return (monomials);
+}
 
 
@@ -3479 +3682 @@
 
 static proc getlpCoeffs(poly q, poly p)
-"
-"
 {list R; poly m; intvec cq,t,lv,rv,bla;
  int n = attrib(basering,"lV"); int d = attrib(basering,"uptodeg");
@@ -3503 +3704 @@
 "
 {poly l,r,qt; int i;
- g = shiftPoly(g,s);
- list K = getlpCoeffs(lead(g),lead(p));
+ list K = getlpCoeffs(lead(shiftPoly(g,s)), lead(p));
  l = K[1]; r = K[2];
  kill K;
  for (i = 1; i <= size(g); i++)
- {qt = qt + lpMult(lpMult(l,g[i]),r);
+ {
+   qt = qt + lpMult(lpMult(l,g[i]),r);
  }
- return((leadcoef(qt)*p - leadcoef(p)*qt));
+ return(p - leadcoef(p)*normalize(qt));
 }
 
@@ -3730 +3931 @@
   lpMultX(b,a);
   lpMultX(a,b); // seems to work properly
+}
+
+proc lpPrint(ideal I, def @r)
+"USAGE: lpPrint(I, r); I an ideal, r a ring
+RETURN: list of strings
+PURPOSE: represent Letterplace ideal in the form of words
+ASSUME: - basering is a Letterplace ring, r is the commutative ring
+from which basering has been built
+EXAMPLE: example lpPrint; shows example
+"
+{
+        def save = basering;
+        lp2lstr(I,@r); // export an object called @code{@LN} to the ring r
+        setring @r;  // change to the ring r
+        list @L = lst2str(@LN,1);
+        export @L;
+        setring save;
+        list @@L = @L;
+        setring @r;
+        kill @L;
+        kill @LN;
+        setring save;
+        return(@@L);
+}
+example
+{
+ "EXAMPLE:"; echo = 2;
+ ring r = (0,a,b,g),(x,y),Dp;
+ def R = makeLetterplaceRing(4); // constructs a Letterplace ring
+ setring R; // downup algebra A
+ ideal J = x(1)*x(2)*y(3)-a*x(1)*y(2)*x(3) - b*y(1)*x(2)*x(3) - g*x(1),
+ x(1)*y(2)*y(3)-a*y(1)*x(2)*y(3) - b*y(1)*y(2)*x(3) - g*y(1);
+ list L = lpPrint(J,r);
+ L;
 }