Changeset df9f881 in git

Timestamp:

Oct 8, 2010, 3:37:40 PM (14 years ago)

Author:

Viktor Levandovskyy <levandov@…>

Branches:

(u'fieker-DuVal', '117eb8c30fc9e991c4decca4832b1d19036c4c65')(u'spielwiese', '38077648e7239f98078663eb941c3c979511150a')

Children:

39db9ff02d796a352e21e6c0a8ebac451b0e205c

Parents:

6c4bd6daa63b3045452ebf8a622b371160c5e243

Message:

*levandov: implemented critics by T. Markwig and minor changes

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

File:

• Singular/LIB/fpadim.lib (modified) (52 diffs)

Singular/LIB/fpadim.lib

@@ -6 +6 @@
 AUTHORS: Grischa Studzinski,       grischa.studzinski@rwth-aachen.de
 
-Support: Projects LE 2697/2-1; KR 1907/3-1 of the Priority Programme SPP 1489:
+Support: Joint projects LE 2697/2-1 and KR 1907/3-1 of the Priority Programme SPP 1489:
 @* 'Algorithmische und Experimentelle Methoden in Algebra, Geometrie und Zahlentheorie'
 @* of the German DFG
@@ -38 +38 @@
 @*      on. The monomial x_1*x_3*x_2 for example will be stored as (1,3,2).
 @*      Multiplication is concatenation. Note that there is no algorithm for
-@*      computing the normalform yet, but for our case it is not needed.
+@*      computing the normal form yet, but for our case it is not needed.
 @*
 
-REFERENCES:
+References:
+
 @*   [ufna] Ufnarovskij: Combinatorical and asymptotic methods in algebra, 1990
 @*   [lls] Levandovskyy, La Scala: Letterplace ideals and non-commutative
-           Groebner bases, 2009
+          Groebner bases, 2009
 @*   [studzins] Studzinski: Dimension computations in non-commutative,
-                      associative algebras, Diploma thesis, RWTH Aachen, 2010
+                     associative algebras, Diploma thesis, RWTH Aachen, 2010
 
 Assumptions:
@@ -52 +53 @@
 @* - all intvecs correspond to Letterplace monomials
 @* - if you specify a different degree bound d,
-      d <= attrib(basering,uptodeg) holds
+     d <= attrib(basering,uptodeg) holds
 @* In the procedures below, 'iv' stands for intvec representation
-   and 'lp' for the letterplace representation of monomials
+  and 'lp' for the letterplace representation of monomials
 
 PROCEDURES:
@@ -105 +106 @@
 "
 {int i,j,r;
- intvec V;
- for (i = 1; i <= size(P); i++) {if (P[i] == 1){ j = i; break;}}
- V = L[j][1..nrows(L[j]),1];
- for (i = 1; i <= n; i++) {if (isInVec(i,V) == 0) {r = 1; break;}}
- if (r == 0) {return(1);}
- else {return(0);}
+  intvec V;
+  for (i = 1; i <= size(P); i++) {if (P[i] == 1){ j = i; break;}}
+  V = L[j][1..nrows(L[j]),1];
+  for (i = 1; i <= n; i++) {if (isInVec(i,V) == 0) {r = 1; break;}}
+  if (r == 0) {return(1);}
+  else {return(0);}
 }
 
@@ -117 +118 @@
 "
 {if (typeof(attrib(basering,"isLetterplaceRing"))=="string") {ERROR("Basering is not a Letterplace ring!");}
- if (d > attrib(basering,"uptodeg")) {ERROR("Specified degree bound exceeds ring parameter!");}
- int i;
- for (i = 1; i <= size(L); i++)
- {if (entryViolation(L[i], attrib(basering,"lV")))
-  {ERROR("Not allowed monomial/intvec found!");}
- }
- return();
+  if (d > attrib(basering,"uptodeg")) {ERROR("Specified degree bound exceeds ring parameter!");}
+  int i;
+  for (i = 1; i <= size(L); i++)
+  {if (entryViolation(L[i], attrib(basering,"lV")))
+    {ERROR("Not allowed monomial/intvec found!");}
+  }
+  return();
 }
 
@@ -133 +134 @@
 "
 {intmat M[(n^d)][d];
- int i1,i2,i3,i4;
- for (i1 = 1; i1 <= d; i1++)  //Spalten
- {i2 = 1; //durchlaeuft Zeilen
-  while (i2 <= (n^d))
-  {for (i3 = 1; i3 <= n; i3++)
-   {for (i4 = 1; i4 <= (n^(i1-1)); i4++)
-    {M[i2,i1] = i3;
-     i2 = i2 + 1;
-    }
-   }
-  }
- }
- return(M);
+  int i1,i2,i3,i4;
+  for (i1 = 1; i1 <= d; i1++)  //Spalten
+  {i2 = 1; //durchlaeuft Zeilen
+    while (i2 <= (n^d))
+    {for (i3 = 1; i3 <= n; i3++)
+      {for (i4 = 1; i4 <= (n^(i1-1)); i4++)
+        {M[i2,i1] = i3;
+          i2 = i2 + 1;
+        }
+      }
+    }
+  }
+  return(M);
 }
 
@@ -153 +154 @@
 "
 {int i;
- intvec V,Vt;
- V = M[(1..nrows(M)),1];
- for (i = 1; i <= size(V); i++) {if (isInVec(i,V) == 0) {Vt = Vt,i;}}
- if (Vt == 0) {intmat S; return(S);}
- else {Vt = Vt[2..size(Vt)]; intmat S [size(Vt)][1]; S[1..size(Vt),1] = Vt; return(S);}
+  intvec V,Vt;
+  V = M[(1..nrows(M)),1];
+  for (i = 1; i <= size(V); i++) {if (isInVec(i,V) == 0) {Vt = Vt,i;}}
+  if (Vt == 0) {intmat S; return(S);}
+  else {Vt = Vt[2..size(Vt)]; intmat S [size(Vt)][1]; S[1..size(Vt),1] = Vt; return(S);}
 }
 
@@ -164 +165 @@
 "
 {int i,j;
- for (i = 1; i <= nrows(M); i++)
- {for (j = 1; j <= ncols(M); j++)
-  {if(!((1<=M[i,j])&&(M[i,j]<=n))) {return(1);}}
- }
- return(0);
+  for (i = 1; i <= nrows(M); i++)
+  {for (j = 1; j <= ncols(M); j++)
+    {if(!((1<=M[i,j])&&(M[i,j]<=n))) {return(1);}}
+  }
+  return(0);
 }
 
@@ -178 +179 @@
 "
 {int degbound = 0;
- if (size(#) > 0) {if (#[1] > 0) {degbound = #[1];}}
- int dimen,i,j,w,it;
- intvec Vt,Vt2;
- module M;
- if (degbound == 0)
- {for (i = 1; i <= n; i++)
-  {Vt = V, i; w = 0;
-   for (j = 1; j<= size(P); j++)
-   {if (P[j] <= size(Vt))
-    {Vt2 = Vt[(size(Vt)-P[j]+1)..size(Vt)];
-     if (isInMat(Vt2,L[j]) > 0) {w = 1; break;}
-    }
-   }
-    if (w == 0)
-    {vector Vtt;
-     for (it = 1; it <= size(Vt); it++){Vtt = Vtt + Vt[it]*gen(it);}
-     M = M,Vtt;
-     kill Vtt;
-    }
-  }
-  if (size(M) == 0) {return(0);}
+  if (size(#) > 0) {if (#[1] > 0) {degbound = #[1];}}
+  int dimen,i,j,w,it;
+  intvec Vt,Vt2;
+  module M;
+  if (degbound == 0)
+  {for (i = 1; i <= n; i++)
+    {Vt = V, i; w = 0;
+      for (j = 1; j<= size(P); j++)
+      {if (P[j] <= size(Vt))
+        {Vt2 = Vt[(size(Vt)-P[j]+1)..size(Vt)];
+          if (isInMat(Vt2,L[j]) > 0) {w = 1; break;}
+        }
+      }
+      if (w == 0)
+      {vector Vtt;
+        for (it = 1; it <= size(Vt); it++){Vtt = Vtt + Vt[it]*gen(it);}
+        M = M,Vtt;
+        kill Vtt;
+      }
+    }
+    if (size(M) == 0) {return(0);}
+    else
+    {M = simplify(M,2);
+      for (i = 1; i <= size(M); i++)
+      {kill Vt; intvec Vt;
+        for (j =1; j <= size(M[i]); j++){Vt[j] =  int(leadcoef(M[i][j]));}
+        dimen = dimen + 1 + findDimen(Vt,n,L,P);
+      }
+      return(dimen);
+    }
+  }
   else
-  {M = simplify(M,2);
-   for (i = 1; i <= size(M); i++)
-   {kill Vt; intvec Vt;
-    for (j =1; j <= size(M[i]); j++){Vt[j] =  int(leadcoef(M[i][j]));}
-    dimen = dimen + 1 + findDimen(Vt,n,L,P);
-   }
-   return(dimen);
-  }
- }
- else
- {if (size(V) > degbound) {ERROR("monomial exceeds degreebound");}
-  if (size(V) == degbound) {return(0);}
-  for (i = 1; i <= n; i++)
-  {Vt = V, i; w = 0;
-   for (j = 1; j<= size(P); j++)
-   {if (P[j] <= size(Vt))
-    {Vt2 = Vt[(size(Vt)-P[j]+1)..size(Vt)];
-     if (isInMat(Vt2,L[j]) > 0) {w = 1; break;}
-    }
-   }
-    if (w == 0) {vector Vtt;
-     for (it = 1; it <= size(Vt); it++){Vtt = Vtt + Vt[it]*gen(it);}
-     M = M,Vtt;
-     kill Vtt;
-    }
-  }
-  if (size(M) == 0) {return(0);}
-  else
-  {M = simplify(M,2);
-   for (i = 1; i <= size(M); i++)
-   {kill Vt; intvec Vt;
-    for (j =1; j <= size(M[i]); j++){Vt[j] =  int(leadcoef(M[i][j]));}
-    dimen = dimen + 1 + findDimen(Vt,n,L,P,degbound);
-   }
-   return(dimen);
-  }
- }
+  {if (size(V) > degbound) {ERROR("monomial exceeds degreebound");}
+    if (size(V) == degbound) {return(0);}
+    for (i = 1; i <= n; i++)
+    {Vt = V, i; w = 0;
+      for (j = 1; j<= size(P); j++)
+      {if (P[j] <= size(Vt))
+        {Vt2 = Vt[(size(Vt)-P[j]+1)..size(Vt)];
+          if (isInMat(Vt2,L[j]) > 0) {w = 1; break;}
+        }
+      }
+      if (w == 0) {vector Vtt;
+        for (it = 1; it <= size(Vt); it++){Vtt = Vtt + Vt[it]*gen(it);}
+        M = M,Vtt;
+        kill Vtt;
+      }
+    }
+    if (size(M) == 0) {return(0);}
+    else
+    {M = simplify(M,2);
+      for (i = 1; i <= size(M); i++)
+      {kill Vt; intvec Vt;
+        for (j =1; j <= size(M[i]); j++){Vt[j] =  int(leadcoef(M[i][j]));}
+        dimen = dimen + 1 + findDimen(Vt,n,L,P,degbound);
+      }
+      return(dimen);
+    }
+  }
 }
 
@@ -245 +246 @@
 "
 {int i,j,w,r;intvec Vt,Vt2;
- int it, it2;
- if (size(V) < ld)
- {for (i = 1; i <= n; i++)
-  {Vt = V,i; w = 0;
-   for (j = 1; j <= size(P); j++)
-   {if (P[j] <= size(Vt))
-    {Vt2 = Vt[(size(Vt)-P[j]+1)..size(Vt)];
-     if (isInMat(Vt2,L[j]) > 0)
-     {w = 1; break;}
-    }
-   }
-   if (w == 0) {r = findCycle(Vt,L,P,n,ld,M);}
-   if (r == 1) {break;}
-  }
-  return(r);
- }
- else
- {j = size(M);
-  if (j > 0)
-  {
-   intmat Mt[j][nrows(M)];
-   for (it = 1; it <= j; it++)
-   { for(it2 = 1; it2 <= nrows(M);it2++)
-     {Mt[it,it2] = int(leadcoef(M[it2,it]));}
-   }
-   Vt = V[(size(V)-ld+1)..size(V)];
-   //Mt; type(Mt);Vt;type(Vt);
-   if (isInMat(Vt,Mt) > 0) {return(1);}
-   else
-   {vector Vtt;
-    for (it =1; it <= size(Vt); it++)
-     {Vtt = Vtt + Vt[it]*gen(it);}
-    M = M,Vtt;
-    kill Vtt;
-    for (i = 1; i <= n; i++)
+  int it, it2;
+  if (size(V) < ld)
+  {for (i = 1; i <= n; i++)
     {Vt = V,i; w = 0;
-     for (j = 1; j <= size(P); j++)
-     {if (P[j] <= size(Vt))
-      {Vt2 = Vt[(size(Vt)-P[j]+1)..size(Vt)];
-      //L[j]; type(L[j]);Vt2;type(Vt2);
-       if (isInMat(Vt2,L[j]) > 0)
-       {w = 1; break;}
-      }
-     }
-     if (w == 0) {r = findCycle(Vt,L,P,n,ld,M);}
-     if (r == 1) {break;}
+      for (j = 1; j <= size(P); j++)
+      {if (P[j] <= size(Vt))
+        {Vt2 = Vt[(size(Vt)-P[j]+1)..size(Vt)];
+          if (isInMat(Vt2,L[j]) > 0)
+          {w = 1; break;}
+        }
+      }
+      if (w == 0) {r = findCycle(Vt,L,P,n,ld,M);}
+      if (r == 1) {break;}
     }
     return(r);
-   }
   }
   else
-  { Vt = V[(size(V)-ld+1)..size(V)];
-    vector Vtt;
-    for (it = 1; it <= size(Vt); it++)
-     {Vtt = Vtt + Vt[it]*gen(it);}
-    M = Vtt;
-    kill Vtt;
-    for (i = 1; i <= n; i++)
-    {Vt = V,i; w = 0;
-     for (j = 1; j <= size(P); j++)
-     {if (P[j] <= size(Vt))
-      {Vt2 = Vt[(size(Vt)-P[j]+1)..size(Vt)];
-      //L[j]; type(L[j]);Vt2;type(Vt2);
-       if (isInMat(Vt2,L[j]) > 0)
-       {w = 1; break;}
-      }
-     }
-     if (w == 0) {r = findCycle(Vt,L,P,n,ld,M);}
-     if (r == 1) {break;}
-    }
-    return(r);
-  }
- }
+  {j = size(M);
+    if (j > 0)
+    {
+      intmat Mt[j][nrows(M)];
+      for (it = 1; it <= j; it++)
+      { for(it2 = 1; it2 <= nrows(M);it2++)
+        {Mt[it,it2] = int(leadcoef(M[it2,it]));}
+      }
+      Vt = V[(size(V)-ld+1)..size(V)];
+      //Mt; type(Mt);Vt;type(Vt);
+      if (isInMat(Vt,Mt) > 0) {return(1);}
+      else
+      {vector Vtt;
+        for (it =1; it <= size(Vt); it++)
+        {Vtt = Vtt + Vt[it]*gen(it);}
+        M = M,Vtt;
+        kill Vtt;
+        for (i = 1; i <= n; i++)
+        {Vt = V,i; w = 0;
+          for (j = 1; j <= size(P); j++)
+          {if (P[j] <= size(Vt))
+            {Vt2 = Vt[(size(Vt)-P[j]+1)..size(Vt)];
+              //L[j]; type(L[j]);Vt2;type(Vt2);
+              if (isInMat(Vt2,L[j]) > 0)
+              {w = 1; break;}
+            }
+          }
+          if (w == 0) {r = findCycle(Vt,L,P,n,ld,M);}
+          if (r == 1) {break;}
+        }
+        return(r);
+      }
+    }
+    else
+    { Vt = V[(size(V)-ld+1)..size(V)];
+      vector Vtt;
+      for (it = 1; it <= size(Vt); it++)
+      {Vtt = Vtt + Vt[it]*gen(it);}
+      M = Vtt;
+      kill Vtt;
+      for (i = 1; i <= n; i++)
+      {Vt = V,i; w = 0;
+        for (j = 1; j <= size(P); j++)
+        {if (P[j] <= size(Vt))
+          {Vt2 = Vt[(size(Vt)-P[j]+1)..size(Vt)];
+            //L[j]; type(L[j]);Vt2;type(Vt2);
+            if (isInMat(Vt2,L[j]) > 0)
+            {w = 1; break;}
+          }
+        }
+        if (w == 0) {r = findCycle(Vt,L,P,n,ld,M);}
+        if (r == 1) {break;}
+      }
+      return(r);
+    }
+  }
 }
 
@@ -325 +326 @@
 PURPOSE:Computing the coefficient of the Hilbert series (upto degree degbound)
 NOTE:   Starting with a part of the Hilbert series we change the coefficient
-@*      depending on how many baseelements we found on the actual branch
+@*      depending on how many basis elements we found on the actual branch
 "
 {int degbound = 0;
- if (size(#) > 0){if (#[1] > 0){degbound = #[1];}}
- int i,w,j,it;
- int h1 = 0;
- intvec Vt,Vt2,H1;
- module M;
- if (degbound == 0)
- {for (i = 1; i <= n; i++)
-  {Vt = V, i; w = 0;
-   for (j = 1; j<= size(P); j++)
-   {if (P[j] <= size(Vt))
-    {Vt2 = Vt[(size(Vt)-P[j]+1)..size(Vt)];
-     if (isInMat(Vt2,L[j]) > 0) {w = 1; break;}
-    }
-   }
-    if (w == 0)
-    {vector Vtt;
-     for (it = 1; it <= size(Vt); it++){Vtt = Vtt + Vt[it]*gen(it);}
-     M = M,Vtt;
-     kill Vtt;
-    }
-  }
-  if (size(M) == 0) {return(H);}
+  if (size(#) > 0){if (#[1] > 0){degbound = #[1];}}
+  int i,w,j,it;
+  int h1 = 0;
+  intvec Vt,Vt2,H1;
+  module M;
+  if (degbound == 0)
+  {for (i = 1; i <= n; i++)
+    {Vt = V, i; w = 0;
+      for (j = 1; j<= size(P); j++)
+      {if (P[j] <= size(Vt))
+        {Vt2 = Vt[(size(Vt)-P[j]+1)..size(Vt)];
+          if (isInMat(Vt2,L[j]) > 0) {w = 1; break;}
+        }
+      }
+      if (w == 0)
+      {vector Vtt;
+        for (it = 1; it <= size(Vt); it++){Vtt = Vtt + Vt[it]*gen(it);}
+        M = M,Vtt;
+        kill Vtt;
+      }
+    }
+    if (size(M) == 0) {return(H);}
+    else
+    {M = simplify(M,2);
+      for (i = 1; i <= size(M); i++)
+      {kill Vt; intvec Vt;
+        for (j =1; j <= size(M[i]); j++) {Vt[j] =  int(leadcoef(M[i][j]));}
+        h1 = h1 + 1; H1 = findHCoeff(Vt,n,L,P,H1);
+      }
+      if (size(H1) < (size(V)+2)) {H1[(size(V)+2)] = h1;}
+      else {H1[(size(V)+2)] = H1[(size(V)+2)] + h1;}
+      H1 = H1 + H;
+      return(H1);
+    }
+  }
   else
-  {M = simplify(M,2);
-   for (i = 1; i <= size(M); i++)
-   {kill Vt; intvec Vt;
-    for (j =1; j <= size(M[i]); j++) {Vt[j] =  int(leadcoef(M[i][j]));}
-    h1 = h1 + 1; H1 = findHCoeff(Vt,n,L,P,H1);
-   }
-   if (size(H1) < (size(V)+2)) {H1[(size(V)+2)] = h1;}
-   else {H1[(size(V)+2)] = H1[(size(V)+2)] + h1;}
-   H1 = H1 + H;
-   return(H1);
-  }
- }
- else
- {if (size(V) > degbound) {ERROR("monomial exceeds degreebound");}
-  if (size(V) == degbound) {return(H);}
-  for (i = 1; i <= n; i++)
-  {Vt = V, i; w = 0;
-   for (j = 1; j<= size(P); j++)
-   {if (P[j] <= size(Vt))
-    {Vt2 = Vt[(size(Vt)-P[j]+1)..size(Vt)];
-     if (isInMat(Vt2,L[j]) > 0) {w = 1; break;}
-    }
-   }
-    if (w == 0)
-    {vector Vtt;
-     for (it = 1; it <= size(Vt); it++){Vtt = Vtt + Vt[it]*gen(it);}
-     M = M,Vtt;
-     kill Vtt;
-    }
-  }
-  if (size(M) == 0) {return(H);}
-  else
-  {M = simplify(M,2);
-   for (i = 1; i <= size(M); i++)
-   {kill Vt; intvec Vt;
-    for (j =1; j <= size(M[i]); j++)
-     {Vt[j] =  int(leadcoef(M[i][j]));}
-    h1 = h1 + 1; H1 = findHCoeff(Vt,n,L,P,H1,degbound);
-   }
-   if (size(H1) < (size(V)+2)) { H1[(size(V)+2)] = h1;}
-   else {H1[(size(V)+2)] = H1[(size(V)+2)] + h1;}
-   H1 = H1 + H;
-   return(H1);
-  }
- }
+  {if (size(V) > degbound) {ERROR("monomial exceeds degreebound");}
+    if (size(V) == degbound) {return(H);}
+    for (i = 1; i <= n; i++)
+    {Vt = V, i; w = 0;
+      for (j = 1; j<= size(P); j++)
+      {if (P[j] <= size(Vt))
+        {Vt2 = Vt[(size(Vt)-P[j]+1)..size(Vt)];
+          if (isInMat(Vt2,L[j]) > 0) {w = 1; break;}
+        }
+      }
+      if (w == 0)
+      {vector Vtt;
+        for (it = 1; it <= size(Vt); it++){Vtt = Vtt + Vt[it]*gen(it);}
+        M = M,Vtt;
+        kill Vtt;
+      }
+    }
+    if (size(M) == 0) {return(H);}
+    else
+    {M = simplify(M,2);
+      for (i = 1; i <= size(M); i++)
+      {kill Vt; intvec Vt;
+        for (j =1; j <= size(M[i]); j++)
+        {Vt[j] =  int(leadcoef(M[i][j]));}
+        h1 = h1 + 1; H1 = findHCoeff(Vt,n,L,P,H1,degbound);
+      }
+      if (size(H1) < (size(V)+2)) { H1[(size(V)+2)] = h1;}
+      else {H1[(size(V)+2)] = H1[(size(V)+2)] + h1;}
+      H1 = H1 + H;
+      return(H1);
+    }
+  }
 }
 
@@ -406 +407 @@
 "
 {int degbound = 0;
- if (size(#) > 0) {if (#[1] > 0) {degbound = #[1];}}
- int i,w,j,h1;
- intvec Vt,Vt2,H1; int it;
- module M;
- if (degbound == 0)
- {for (i = 1; i <= n; i++)
-  {Vt = V, i; w = 0;
-   for (j = 1; j<= size(P); j++)
-   {if (P[j] <= size(Vt))
-    {Vt2 = Vt[(size(Vt)-P[j]+1)..size(Vt)];
-     if (isInMat(Vt2,L[j]) > 0) {w = 1; break;}
-    }
-   }
-    if (w == 0)
-    {vector Vtt;
-    for (it = 1; it <= size(Vt); it++){Vtt = Vtt + Vt[it]*gen(it);}
-    M = M,Vtt;
-    kill Vtt;
-    }
-  }
-  if (size(M) == 0) {if (size(R) < 2){R[2] = list(V);} else {R[2] = R[2] + list(V);} return(R);}
+  if (size(#) > 0) {if (#[1] > 0) {degbound = #[1];}}
+  int i,w,j,h1;
+  intvec Vt,Vt2,H1; int it;
+  module M;
+  if (degbound == 0)
+  {for (i = 1; i <= n; i++)
+    {Vt = V, i; w = 0;
+      for (j = 1; j<= size(P); j++)
+      {if (P[j] <= size(Vt))
+        {Vt2 = Vt[(size(Vt)-P[j]+1)..size(Vt)];
+          if (isInMat(Vt2,L[j]) > 0) {w = 1; break;}
+        }
+      }
+      if (w == 0)
+      {vector Vtt;
+        for (it = 1; it <= size(Vt); it++){Vtt = Vtt + Vt[it]*gen(it);}
+        M = M,Vtt;
+        kill Vtt;
+      }
+    }
+    if (size(M) == 0) {if (size(R) < 2){R[2] = list(V);} else {R[2] = R[2] + list(V);} return(R);}
+    else
+    {M = simplify(M,2);
+      for (i = 1; i <= size(M); i++)
+      {kill Vt; intvec Vt;
+        for (j =1; j <= size(M[i]); j++)
+        {Vt[j] =  int(leadcoef(M[i][j]));}
+        if (size(R[1]) < (size(V)+2)) { R[1][(size(V)+2)] = 1;}
+        else
+        {R[1][(size(V)+2)] = R[1][(size(V)+2)] + 1;}
+        R = findHCoeffMis(Vt,n,L,P,R);
+      }
+      return(R);
+    }
+  }
   else
-  {M = simplify(M,2);
-   for (i = 1; i <= size(M); i++)
-   {kill Vt; intvec Vt;
-    for (j =1; j <= size(M[i]); j++)
-     {Vt[j] =  int(leadcoef(M[i][j]));}
-    if (size(R[1]) < (size(V)+2)) { R[1][(size(V)+2)] = 1;}
+  {if (size(V) > degbound) {ERROR("monomial exceeds degreebound");}
+    if (size(V) == degbound)
+    {if (size(R) < 2){R[2] = list (V);}
+      else{R[2] = R[2] + list (V);}
+      return(R);
+    }
+    for (i = 1; i <= n; i++)
+    {Vt = V, i; w = 0;
+      for (j = 1; j<= size(P); j++)
+      {if (P[j] <= size(Vt))
+        {Vt2 = Vt[(size(Vt)-P[j]+1)..size(Vt)];
+          if (isInMat(Vt2,L[j]) > 0) {w = 1; break;}
+        }
+      }
+      if (w == 0)
+      {vector Vtt;
+        for (it = 1; it <= size(Vt); it++){Vtt = Vtt + Vt[it]*gen(it);}
+        M = M,Vtt;
+        kill Vtt;
+      }
+    }
+    if (size(M) == 0) {if (size(R) < 2){R[2] = list(V);} else {R[2] = R[2] + list(V);} return(R);}
     else
-    {R[1][(size(V)+2)] = R[1][(size(V)+2)] + 1;}
-    R = findHCoeffMis(Vt,n,L,P,R);
-   }
-   return(R);
-  }
- }
- else
- {if (size(V) > degbound) {ERROR("monomial exceeds degreebound");}
-  if (size(V) == degbound)
-  {if (size(R) < 2){R[2] = list (V);}
-   else{R[2] = R[2] + list (V);}
-   return(R);
-  }
-  for (i = 1; i <= n; i++)
-  {Vt = V, i; w = 0;
-   for (j = 1; j<= size(P); j++)
-   {if (P[j] <= size(Vt))
-    {Vt2 = Vt[(size(Vt)-P[j]+1)..size(Vt)];
-     if (isInMat(Vt2,L[j]) > 0) {w = 1; break;}
-    }
-   }
-    if (w == 0)
-    {vector Vtt;
-    for (it = 1; it <= size(Vt); it++){Vtt = Vtt + Vt[it]*gen(it);}
-    M = M,Vtt;
-    kill Vtt;
-    }
-  }
-  if (size(M) == 0) {if (size(R) < 2){R[2] = list(V);} else {R[2] = R[2] + list(V);} return(R);}
-  else
-  {M = simplify(M,2);
-    for (i = 1; i <= ncols(M); i++)
-    {kill Vt; intvec Vt;
-     for (j =1; j <= size(M[i]); j++)
-     {Vt[j] =  int(leadcoef(M[i][j]));}
-     if (size(R[1]) < (size(V)+2)) { R[1][(size(V)+2)] = 1;}
-     else
-     {R[1][(size(V)+2)] = R[1][(size(V)+2)] + 1;}
-     R = findHCoeffMis(Vt,n,L,P,R,degbound);
-    }
-   return(R);
-  }
- }
+    {M = simplify(M,2);
+      for (i = 1; i <= ncols(M); i++)
+      {kill Vt; intvec Vt;
+        for (j =1; j <= size(M[i]); j++)
+        {Vt[j] =  int(leadcoef(M[i][j]));}
+        if (size(R[1]) < (size(V)+2)) { R[1][(size(V)+2)] = 1;}
+        else
+        {R[1][(size(V)+2)] = R[1][(size(V)+2)] + 1;}
+        R = findHCoeffMis(Vt,n,L,P,R,degbound);
+      }
+      return(R);
+    }
+  }
 }
 
@@ -487 +488 @@
 "
 {int degbound = 0;
- if (size(#) > 0) {if (#[1] > 0) {degbound = #[1];}}
- int dimen,i,j,w;
- intvec Vt,Vt2; int it;
- module M;
- if (degbound == 0)
- {for (i = 1; i <= n; i++)
-  {Vt = V, i; w = 0;
-   for (j = 1; j<= size(P); j++)
-   {if (P[j] <= size(Vt))
-    {Vt2 = Vt[(size(Vt)-P[j]+1)..size(Vt)];
-     if (isInMat(Vt2,L[j]) > 0) {w = 1; break;}
-    }
-   }
-    if (w == 0)
-    {vector Vtt;
-     for (it = 1; it <= size(Vt); it++){Vtt = Vtt + Vt[it]*gen(it);}
-     M = M,Vtt;
-     kill Vtt;
-    }
-  }
-  if (size(M) == 0)
-  {if (size(R) < 2){R[2] = list (V);}
-   else{R[2] = R[2] + list(V);}
-   return(R);
+  if (size(#) > 0) {if (#[1] > 0) {degbound = #[1];}}
+  int dimen,i,j,w;
+  intvec Vt,Vt2; int it;
+  module M;
+  if (degbound == 0)
+  {for (i = 1; i <= n; i++)
+    {Vt = V, i; w = 0;
+      for (j = 1; j<= size(P); j++)
+      {if (P[j] <= size(Vt))
+        {Vt2 = Vt[(size(Vt)-P[j]+1)..size(Vt)];
+          if (isInMat(Vt2,L[j]) > 0) {w = 1; break;}
+        }
+      }
+      if (w == 0)
+      {vector Vtt;
+        for (it = 1; it <= size(Vt); it++){Vtt = Vtt + Vt[it]*gen(it);}
+        M = M,Vtt;
+        kill Vtt;
+      }
+    }
+    if (size(M) == 0)
+    {if (size(R) < 2){R[2] = list (V);}
+      else{R[2] = R[2] + list(V);}
+      return(R);
+    }
+    else
+    {M = simplify(M,2);
+      for (i = 1; i <= size(M); i++)
+      {kill Vt; intvec Vt;
+        for (j =1; j <= size(M[i]); j++){Vt[j] =  int(leadcoef(M[i][j]));}
+        R[1] = R[1] + 1; R = findMisDim(Vt,n,L,P,R);
+      }
+      return(R);
+    }
   }
   else
-  {M = simplify(M,2);
-   for (i = 1; i <= size(M); i++)
-   {kill Vt; intvec Vt;
-    for (j =1; j <= size(M[i]); j++){Vt[j] =  int(leadcoef(M[i][j]));}
-     R[1] = R[1] + 1; R = findMisDim(Vt,n,L,P,R);
-   }
-   return(R);
-  }
- }
- else
- {if (size(V) > degbound) {ERROR("monomial exceeds degreebound");}
-  if (size(V) == degbound)
-  {if (size(R) < 2){R[2] = list (V);}
-   else{R[2] = R[2] + list (V);}
-   return(R);
-  }
-  for (i = 1; i <= n; i++)
-  {Vt = V, i; w = 0;
-   for (j = 1; j<= size(P); j++)
-   {if (P[j] <= size(Vt))
-    {Vt2 = Vt[(size(Vt)-P[j]+1)..size(Vt)];
-     if (isInMat(Vt2,L[j]) > 0) {w = 1; break;}
-    }
-   }
-    if (w == 0)
-    {vector Vtt;
-     for (it = 1; it <= size(Vt); it++){Vtt = Vtt + Vt[it]*gen(it);}
-     M = M,Vtt;
-     kill Vtt;
-    }
-  }
-  if (size(M) == 0)
-  {if (size(R) < 2){R[2] = list (V);}
-   else{R[2] = R[2] + list(V);}
-   return(R);
-  }
-  else
-  {M = simplify(M,2);
-   for (i = 1; i <= size(M); i++)
-   {kill Vt; intvec Vt;
-    for (j =1; j <= size(M[i]); j++){Vt[j] =  int(leadcoef(M[i][j]));}
-     R[1] = R[1] + 1; R = findMisDim(Vt,n,L,P,R,degbound);
-   }
-   return(R);
-
-  }
- }
+  {if (size(V) > degbound) {ERROR("monomial exceeds degreebound");}
+    if (size(V) == degbound)
+    {if (size(R) < 2){R[2] = list (V);}
+      else{R[2] = R[2] + list (V);}
+      return(R);
+    }
+    for (i = 1; i <= n; i++)
+    {Vt = V, i; w = 0;
+      for (j = 1; j<= size(P); j++)
+      {if (P[j] <= size(Vt))
+        {Vt2 = Vt[(size(Vt)-P[j]+1)..size(Vt)];
+          if (isInMat(Vt2,L[j]) > 0) {w = 1; break;}
+        }
+      }
+      if (w == 0)
+      {vector Vtt;
+        for (it = 1; it <= size(Vt); it++){Vtt = Vtt + Vt[it]*gen(it);}
+        M = M,Vtt;
+        kill Vtt;
+      }
+    }
+    if (size(M) == 0)
+    {if (size(R) < 2){R[2] = list (V);}
+      else{R[2] = R[2] + list(V);}
+      return(R);
+    }
+    else
+    {M = simplify(M,2);
+      for (i = 1; i <= size(M); i++)
+      {kill Vt; intvec Vt;
+        for (j =1; j <= size(M[i]); j++){Vt[j] =  int(leadcoef(M[i][j]));}
+        R[1] = R[1] + 1; R = findMisDim(Vt,n,L,P,R,degbound);
+      }
+      return(R);
+
+    }
+  }
 }
 
@@ -572 +573 @@
 "
 {int degbound = 0;
- if (size(#) > 0) {if (#[1] > 0) {degbound = #[1];}}
- list R; intvec Vt,Vt2; int it;
- int i,j;
- module M;
- if (degbound == 0)
- {int w;
-  for (i = 1; i <= n; i++)
-  {Vt = V,i; w = 0;
-   for (j = 1; j <= size(P); j++)
-   {if (P[j] <= size(Vt))
-    {Vt2 = Vt[(size(Vt)-P[j]+1)..size(Vt)];
-     if (isInMat(Vt2,L[j]) > 0)
-     {w = 1; break;}
-    }
-   }
-   if (w == 0)
-   {vector Vtt;
-    for (it = 1; it <= size(Vt); it++){Vtt = Vtt + Vt[it]*gen(it);}
-    M = M,Vtt;
-    kill Vtt;
-   }
-  }
-  if (size(M)==0) {R = V; return(R);}
+  if (size(#) > 0) {if (#[1] > 0) {degbound = #[1];}}
+  list R; intvec Vt,Vt2; int it;
+  int i,j;
+  module M;
+  if (degbound == 0)
+  {int w;
+    for (i = 1; i <= n; i++)
+    {Vt = V,i; w = 0;
+      for (j = 1; j <= size(P); j++)
+      {if (P[j] <= size(Vt))
+        {Vt2 = Vt[(size(Vt)-P[j]+1)..size(Vt)];
+          if (isInMat(Vt2,L[j]) > 0)
+          {w = 1; break;}
+        }
+      }
+      if (w == 0)
+      {vector Vtt;
+        for (it = 1; it <= size(Vt); it++){Vtt = Vtt + Vt[it]*gen(it);}
+        M = M,Vtt;
+        kill Vtt;
+      }
+    }
+    if (size(M)==0) {R = V; return(R);}
+    else
+    {M = simplify(M,2);
+      for (i = 1; i <= size(M); i++)
+      {kill Vt; intvec Vt;
+        for (j =1; j <= size(M[i]); j++){Vt[j] =  int(leadcoef(M[i][j]));}
+        R = R + findmistletoes(Vt,n,L,P);
+      }
+      return(R);
+    }
+  }
   else
-  {M = simplify(M,2);
-   for (i = 1; i <= size(M); i++)
-   {kill Vt; intvec Vt;
-    for (j =1; j <= size(M[i]); j++){Vt[j] =  int(leadcoef(M[i][j]));}
-    R = R + findmistletoes(Vt,n,L,P);
-   }
-   return(R);
-  }
- }
- else
- {if (size(V) > degbound) {ERROR("monomial exceeds degreebound");}
-  if (size(V) == degbound) {R = V; return(R);}
-  int w;
-  for (i = 1; i <= n; i++)
-  {Vt = V,i; w = 0;
-   for (j = 1; j <= size(P); j++)
-   {if (P[j] <= size(Vt))
-    {Vt2 = Vt[(size(Vt)-P[j]+1)..size(Vt)];
-     if (isInMat(Vt2,L[j]) > 0){w = 1; break;}
-    }
-   }
-   if (w == 0)
-   {vector Vtt;
-    for (it = 1; it <= size(Vt); it++){Vtt = Vtt + Vt[it]*gen(it);}
-    M = M,Vtt;
-    kill Vtt;
-   }
-  }
-  if (size(M) == 0) {R = V; return(R);}
-  else
-  {M = simplify(M,2);
-   for (i = 1; i <= ncols(M); i++)
-   {kill Vt; intvec Vt;
-    for (j =1; j <= size(M[i]); j++)
-     {Vt[j] =  int(leadcoef(M[i][j]));}
-      //Vt; typeof(Vt); size(Vt);
-      R = R + findmistletoes(Vt,n,L,P,degbound);
-   }
-   return(R);
-  }
- }
+  {if (size(V) > degbound) {ERROR("monomial exceeds degreebound");}
+    if (size(V) == degbound) {R = V; return(R);}
+    int w;
+    for (i = 1; i <= n; i++)
+    {Vt = V,i; w = 0;
+      for (j = 1; j <= size(P); j++)
+      {if (P[j] <= size(Vt))
+        {Vt2 = Vt[(size(Vt)-P[j]+1)..size(Vt)];
+          if (isInMat(Vt2,L[j]) > 0){w = 1; break;}
+        }
+      }
+      if (w == 0)
+      {vector Vtt;
+        for (it = 1; it <= size(Vt); it++){Vtt = Vtt + Vt[it]*gen(it);}
+        M = M,Vtt;
+        kill Vtt;
+      }
+    }
+    if (size(M) == 0) {R = V; return(R);}
+    else
+    {M = simplify(M,2);
+      for (i = 1; i <= ncols(M); i++)
+      {kill Vt; intvec Vt;
+        for (j =1; j <= size(M[i]); j++)
+        {Vt[j] =  int(leadcoef(M[i][j]));}
+        //Vt; typeof(Vt); size(Vt);
+        R = R + findmistletoes(Vt,n,L,P,degbound);
+      }
+      return(R);
+    }
+  }
 }
 
@@ -645 +646 @@
 "
 {int i,n;
- n = 0;
- for (i = 1; i <= size(L); i++) {if (L[i] == V) {n = i; break;}}
- return(n);
+  n = 0;
+  for (i = 1; i <= size(L); i++) {if (L[i] == V) {n = i; break;}}
+  return(n);
 }
 
@@ -656 +657 @@
 "
 {if (size(V) <> ncols(M)) {return(0);}
- int i;
- intvec Vt;
- for (i = 1; i <= nrows(M); i++)
- {Vt = M[i,1..ncols(M)];
-  if ((V-Vt) == 0){return(i);}
- }
- return(0);
+  int i;
+  intvec Vt;
+  for (i = 1; i <= nrows(M); i++)
+  {Vt = M[i,1..ncols(M)];
+    if ((V-Vt) == 0){return(i);}
+  }
+  return(0);
 }
 
@@ -671 +672 @@
 "
 {int i,n;
- n = 0;
- for (i = 1; i <= size(V); i++) {if (V[i] == v) {n = i; break;}}
- return(n);
+  n = 0;
+  for (i = 1; i <= size(V); i++) {if (V[i] == v) {n = i; break;}}
+  return(n);
 }
 
@@ -685 +686 @@
 "
 {checkAssumptions(0,L);
- int i; ideal G;
- poly p;
- for (i = 1; i <= size(L); i++)
- {p = iv2lp(L[i]);
-  G[(size(G) + 1)] = p;
- }
- return(G);
+  int i; ideal G;
+  poly p;
+  for (i = 1; i <= size(L); i++)
+  {p = iv2lp(L[i]);
+    G[(size(G) + 1)] = p;
+  }
+  return(G);
 }
 example
@@ -715 +716 @@
 "
 {if (I[1] == 0) {return(1);}
- int i = size(I);
- if (i > attrib(basering,"uptodeg")) {ERROR("polynomial exceeds degreebound");}
- int j; poly p = 1;
- for (j = 1; j <= i; j++) {if (I[j] > 0) { p = lpMult(p,var(I[j]));}} //ignore zeroes, because they correspond to 1
- return(p);
+  int i = size(I);
+  if (i > attrib(basering,"uptodeg")) {ERROR("polynomial exceeds degreebound");}
+  int j; poly p = 1;
+  for (j = 1; j <= i; j++) {if (I[j] > 0) { p = lpMult(p,var(I[j]));}} //ignore zeroes, because they correspond to 1
+  return(p);
 }
 example
@@ -743 +744 @@
 "
 {checkAssumptions(0,L);
- ideal G;
- int i;
- for (i = 1; i <= size(L); i++){G = G + iv2lpMat(L[i]);}
- return(G);
+  ideal G;
+  int i;
+  for (i = 1; i <= size(L); i++){G = G + iv2lpMat(L[i]);}
+  return(G);
 }
 example
@@ -772 +773 @@
 "
 {list L = M;
- checkAssumptions(0,L);
- kill L;
- ideal G; poly p;
- int i; intvec I;
- for (i = 1; i <= nrows(M); i++)
+  checkAssumptions(0,L);
+  kill L;
+  ideal G; poly p;
+  int i; intvec I;
+  for (i = 1; i <= nrows(M); i++)
   { I = M[i,1..ncols(M)];
     p = iv2lp(I);
     G[size(G)+1] = p;
   }
- return(G);
+  return(G);
 }
 example
@@ -805 +806 @@
 "
 {int i,j,k;
- list M;
- checkAssumptions(0,M);
- for (i = 1; i <= size(G); i++) {M[i] = lp2iv(G[i]);}
- return(M);
-}
-example
-{
-  "EXAMPLE:"; echo = 2;
-   ring r = 0,(x,y),dp;
-   def R = makeLetterplaceRing(5); // constructs a Letterplace ring
-   setring R; // sets basering to Letterplace ring
-   ideal L = x(1)*x(2),y(1)*y(2),x(1)*y(2)*x(3);
-   lpId2ivLi(L); // returns the corresponding intvecs as a list
+  list M;
+  checkAssumptions(0,M);
+  for (i = 1; i <= size(G); i++) {M[i] = lp2iv(G[i]);}
+  return(M);
+}
+example
+{
+  "EXAMPLE:"; echo = 2;
+  ring r = 0,(x,y),dp;
+  def R = makeLetterplaceRing(5); // constructs a Letterplace ring
+  setring R; // sets basering to Letterplace ring
+  ideal L = x(1)*x(2),y(1)*y(2),x(1)*y(2)*x(3);
+  lpId2ivLi(L); // returns the corresponding intvecs as a list
 }
 
@@ -829 +830 @@
 "
 {p = normalize(lead(p));
- intvec I;
- int i,j;
- if (deg(p) > attrib(basering,"uptodeg")) {ERROR("Monomial exceeds degreebound");}
- if (p == 1) {return(I);}
- if (p == 0) {ERROR("Monomial is not allowed to equal zero");}
- intvec lep = leadexp(p);
- for ( i = 1; i <= attrib(basering,"lV"); i++) {if (lep[i] == 1) {I = i; break;}}
- for (i = (attrib(basering,"lV")+1); i <= size(lep); i++)
-   {if (lep[i] == 1)
+  intvec I;
+  int i,j;
+  if (deg(p) > attrib(basering,"uptodeg")) {ERROR("Monomial exceeds degreebound");}
+  if (p == 1) {return(I);}
+  if (p == 0) {ERROR("Monomial is not allowed to equal zero");}
+  intvec lep = leadexp(p);
+  for ( i = 1; i <= attrib(basering,"lV"); i++) {if (lep[i] == 1) {I = i; break;}}
+  for (i = (attrib(basering,"lV")+1); i <= size(lep); i++)
+  {if (lep[i] == 1)
     { j = (i mod attrib(basering,"lV"));
       if (j == 0) {I = I,attrib(basering,"lV");}
@@ -843 +844 @@
     }
     else { if (lep[i] > 1) {ERROR("monomial has a not allowed multidegree");}}
-   }
- if (I[1] == 0) {ERROR("monomial has a not allowed multidegree");}
-
- return(I);
+  }
+  if (I[1] == 0) {ERROR("monomial has a not allowed multidegree");}
+
+  return(I);
 }
 example
@@ -870 +871 @@
 "
 {G = normalize(lead(G));
- intvec I; list L;
- checkAssumptions(0,L);
- int i,md;
- for (i = 1; i <= size(G); i++) { if (md <= deg(G[i])) {md = deg(G[i]);}}
- while (size(G) > 0)
- {ideal Gt;
-  for (i = 1; i <= ncols(G); i++) {if (md == deg(G[i])) {Gt = Gt + G[i]; G[i] = 0;}}
-  if (size(Gt) > 0)
-  {G = simplify(G,2);
-   intmat M [size(Gt)][md];
-   for (i = 1; i <= size(Gt); i++) {M[i,1..md] = lp2iv(Gt[i]);}
-   L = insert(L,M);
-   kill M; kill Gt;
-   md = md - 1;
-  }
-  else {kill Gt; md = md - 1;}
- }
- return(L);
+  intvec I; list L;
+  checkAssumptions(0,L);
+  int i,md;
+  for (i = 1; i <= size(G); i++) { if (md <= deg(G[i])) {md = deg(G[i]);}}
+  while (size(G) > 0)
+  {ideal Gt;
+    for (i = 1; i <= ncols(G); i++) {if (md == deg(G[i])) {Gt = Gt + G[i]; G[i] = 0;}}
+    if (size(Gt) > 0)
+    {G = simplify(G,2);
+      intmat M [size(Gt)][md];
+      for (i = 1; i <= size(Gt); i++) {M[i,1..md] = lp2iv(Gt[i]);}
+      L = insert(L,M);
+      kill M; kill Gt;
+      md = md - 1;
+    }
+    else {kill Gt; md = md - 1;}
+  }
+  return(L);
 }
 example
@@ -927 +928 @@
 "
 {int degbound = 0;
- if (size(#) > 0){if (typeof(#[1])=="int"){if (#[1] > 0){degbound = #[1];}}}
- checkAssumptions(degbound,L);
- intvec H; int i,dimen;
- H = ivHilbert(L,n,degbound);
- for (i = 1; i <= size(H); i++){dimen = dimen + H[i];}
- L = dimen,H;
- return(L);
-}
-example
-{
-  "EXAMPLE:"; echo = 2;
-  ring r = 0,(x,y),dp;
-  def R = makeLetterplaceRing(5); // constructs a Letterplace ring
-    R;
+  if (size(#) > 0){if (typeof(#[1])=="int"){if (#[1] > 0){degbound = #[1];}}}
+  checkAssumptions(degbound,L);
+  intvec H; int i,dimen;
+  H = ivHilbert(L,n,degbound);
+  for (i = 1; i <= size(H); i++){dimen = dimen + H[i];}
+  L = dimen,H;
+  return(L);
+}
+example
+{
+  "EXAMPLE:"; echo = 2;
+  ring r = 0,(x,y),dp;
+  def R = makeLetterplaceRing(5); // constructs a Letterplace ring
+  R;
   setring R; // sets basering to Letterplace ring
   //some intmats, which contain monomials in intvec representation as rows
@@ -966 +967 @@
 @*      - If you specify a different degree bound degbound,
 @*        degbound <= attrib(basering,uptodeg) holds.
-NOTE: - If L is the list returned, then L[1] is an intvec which contains the
-@*      coefficients of the Hilbert series, L[2] is an integer and L[3]
+NOTE: - If L is the list returned, then L[1] is an integer, L[2] is an intvec
+@*      which contains the coefficients of the Hilbert series and L[3]
 @*      is a list, containing the mistletoes as intvecs.
 @*    - If degbound is set, a degree bound will be added. By default there
 @*      is no degree bound.
 @*    - n is the number of variables.
-@*    - If I = L[1] is the intvec returned, then I[k] is the (k-1)-th
+@*    - If I = L[2] is the intvec returned, then I[k] is the (k-1)-th
 @*      coefficient of the Hilbert series.
 @*    - If the K-dimension is known to be infinite, a degree bound is needed
@@ -978 +979 @@
 "
 {int degbound = 0;
- if (size(#) > 0){if (typeof(#[1])=="int"){if (#[1] > 0){degbound = #[1];}}}
- checkAssumptions(degbound,L);
- int i,dimen; list R;
- R = ivSickleHil(L,n,degbound);
- for (i = 1; i <= size(R[1]); i++){dimen = dimen + R[1][i];}
- R[3] = R[2]; R[2] = dimen;
- return(R);
+  if (size(#) > 0){if (typeof(#[1])=="int"){if (#[1] > 0){degbound = #[1];}}}
+  checkAssumptions(degbound,L);
+  int i,dimen; list R;
+  R = ivSickleHil(L,n,degbound);
+  for (i = 1; i <= size(R[1]); i++){dimen = dimen + R[1][i];}
+  R[3] = R[2]; R[2] = R[1]; R[1] = dimen;
+  return(R);
 }
 example
@@ -1016 +1017 @@
 "
 {checkAssumptions(0,L);
- int i,r;
- intvec P,H;
- for (i = 1; i <= size(L); i++)
- {P[i] = ncols(L[i]);
-  if (P[i] == 1) {if (isInMat(H,L[i]) > 0) {ERROR("Quotient algebra is trivial");}}
- }
- if (size(L) == 0) {ERROR("GB is empty, quotient algebra corresponds to free algebra");}
- kill H;
- intmat S; int sd,ld; intvec V;
- sd = P[1]; ld = P[1];
- for (i = 2; i <= size(P); i++)
- {if (P[i] < sd) {sd = P[i];}
-  if (P[i] > ld) {ld = P[i];}
- }
- sd = (sd - 1); ld = ld - 1;
- if (ld == 0) { return(allVars(L,P,n));}
- if (sd == 0) { for (i = 1; i <= size(L); i++){if (ncols(L[i]) == 1){S = createStartMat1(n,L[i]); break;}}}
- else {S = createStartMat(sd,n);}
- module M;
- for (i = 1; i <= nrows(S); i++)
- {V = S[i,1..ncols(S)];
-  if (findCycle(V,L,P,n,ld,M)) {r = 1; break;}
- }
- return(r);
+  int i,r;
+  intvec P,H;
+  for (i = 1; i <= size(L); i++)
+  {P[i] = ncols(L[i]);
+    if (P[i] == 1) {if (isInMat(H,L[i]) > 0) {ERROR("Quotient algebra is trivial");}}
+  }
+  if (size(L) == 0) {ERROR("GB is empty, quotient algebra corresponds to free algebra");}
+  kill H;
+  intmat S; int sd,ld; intvec V;
+  sd = P[1]; ld = P[1];
+  for (i = 2; i <= size(P); i++)
+  {if (P[i] < sd) {sd = P[i];}
+    if (P[i] > ld) {ld = P[i];}
+  }
+  sd = (sd - 1); ld = ld - 1;
+  if (ld == 0) { return(allVars(L,P,n));}
+  if (sd == 0) { for (i = 1; i <= size(L); i++){if (ncols(L[i]) == 1){S = createStartMat1(n,L[i]); break;}}}
+  else {S = createStartMat(sd,n);}
+  module M;
+  for (i = 1; i <= nrows(S); i++)
+  {V = S[i,1..ncols(S)];
+    if (findCycle(V,L,P,n,ld,M)) {r = 1; break;}
+  }
+  return(r);
 }
 example
@@ -1079 +1080 @@
 "
 {int degbound = 0;
- if (size(#) > 0) {if (typeof(#[1])=="int"){if (#[1] > 0) {degbound = #[1];}}}
- intvec P,H; int i;
- for (i = 1; i <= size(L); i++)
- {P[i] = ncols(L[i]);
-  if (P[i] == 1) {if ( isInMat(H,L[i]) > 0) {ERROR("Quotient algebra is trivial");}}
- }
- if (size(L) == 0) {ERROR("GB is empty, quotient algebra corresponds to free algebra");}
- H[1] = 1;
- checkAssumptions(degbound,L);
- if (degbound == 0)
- {int sd;
-  intmat S;
-  sd = P[1];
-  for (i = 2; i <= size(P); i++) {if (P[i] < sd) {sd = P[i];}}
-  sd = (sd - 1);
-  if (sd == 0) { for (i = 1; i <= size(L); i++){if (ncols(L[i]) == 1){S = createStartMat1(n,L[i]); break;}}}
-  else {S = createStartMat(sd,n);}
-  if (intvec(S) == 0) {return(H);}
-  for (i = 1; i <= sd; i++) {H = H,(n^i);}
-  for (i = 1; i <= nrows(S); i++)
-  {intvec St = S[i,1..ncols(S)];
-   H = findHCoeff(St,n,L,P,H);
-   kill St;
-  }
-  return(H);
- }
- else
- {for (i = 1; i <= size(P); i++)
-  {if (P[i] > degbound) {ERROR("degreebound is too small, GB contains elements of higher degree");}}
-  int sd;
-  intmat S;
-  sd = P[1];
-  for (i = 2; i <= size(P); i++) {if (P[i] < sd) {sd = P[i];}}
-  sd = (sd - 1);
-  if (sd == 0) { for (i = 1; i <= size(L); i++){if (ncols(L[i]) == 1){S = createStartMat1(n,L[i]); break;}}}
-  else {S = createStartMat(sd,n);}
-  if (intvec(S) == 0) {return(H);}
-  for (i = 1; i <= sd; i++) {H = H,(n^i);}
-  for (i = 1; i <= nrows(S); i++)
-  {intvec St = S[i,1..ncols(S)];
-   H = findHCoeff(St,n,L,P,H,degbound);
-   kill St;
-  }
-  return(H);
- }
+  if (size(#) > 0) {if (typeof(#[1])=="int"){if (#[1] > 0) {degbound = #[1];}}}
+  intvec P,H; int i;
+  for (i = 1; i <= size(L); i++)
+  {P[i] = ncols(L[i]);
+    if (P[i] == 1) {if ( isInMat(H,L[i]) > 0) {ERROR("Quotient algebra is trivial");}}
+  }
+  if (size(L) == 0) {ERROR("GB is empty, quotient algebra corresponds to free algebra");}
+  H[1] = 1;
+  checkAssumptions(degbound,L);
+  if (degbound == 0)
+  {int sd;
+    intmat S;
+    sd = P[1];
+    for (i = 2; i <= size(P); i++) {if (P[i] < sd) {sd = P[i];}}
+    sd = (sd - 1);
+    if (sd == 0) { for (i = 1; i <= size(L); i++){if (ncols(L[i]) == 1){S = createStartMat1(n,L[i]); break;}}}
+    else {S = createStartMat(sd,n);}
+    if (intvec(S) == 0) {return(H);}
+    for (i = 1; i <= sd; i++) {H = H,(n^i);}
+    for (i = 1; i <= nrows(S); i++)
+    {intvec St = S[i,1..ncols(S)];
+      H = findHCoeff(St,n,L,P,H);
+      kill St;
+    }
+    return(H);
+  }
+  else
+  {for (i = 1; i <= size(P); i++)
+    {if (P[i] > degbound) {ERROR("degreebound is too small, GB contains elements of higher degree");}}
+    int sd;
+    intmat S;
+    sd = P[1];
+    for (i = 2; i <= size(P); i++) {if (P[i] < sd) {sd = P[i];}}
+    sd = (sd - 1);
+    if (sd == 0) { for (i = 1; i <= size(L); i++){if (ncols(L[i]) == 1){S = createStartMat1(n,L[i]); break;}}}
+    else {S = createStartMat(sd,n);}
+    if (intvec(S) == 0) {return(H);}
+    for (i = 1; i <= sd; i++) {H = H,(n^i);}
+    for (i = 1; i <= nrows(S); i++)
+    {intvec St = S[i,1..ncols(S)];
+      H = findHCoeff(St,n,L,P,H,degbound);
+      kill St;
+    }
+    return(H);
+  }
 }
 example
@@ -1162 +1163 @@
 "
 {int degbound = 0;
- if (size(#) > 0) {if (typeof(#[1])=="int"){if (#[1] > 0) {degbound = #[1];}}}
- intvec P,H; int i;
- for (i = 1; i <= size(L); i++)
- {P[i] = ncols(L[i]);
-  if (P[i] == 1) {if ( isInMat(H,L[i]) > 0) {ERROR("Quotient algebra is trivial");}}
- }
- if (size(L) == 0) {ERROR("GB is empty, quotient algebra corresponds to free algebra");}
- kill H;
- checkAssumptions(degbound,L);
- if (degbound == 0)
- {int sd; int dimen = 1;
-  intmat S;
-  sd = P[1];
-  for (i = 2; i <= size(P); i++) {if (P[i] < sd) {sd = P[i];}}
-  sd = (sd - 1);
-  if (sd == 0) { for (i = 1; i <= size(L); i++){if (ncols(L[i]) == 1){S = createStartMat1(n,L[i]); break;}}}
-  else {S = createStartMat(sd,n);}
-  if (intvec(S) == 0) {return(dimen);}
-  for (i = 1; i <= sd; i++) {dimen = dimen +(n^i);}
-  for (i = 1; i <= nrows(S); i++)
-  {intvec St = S[i,1..ncols(S)];
-   dimen = dimen + findDimen(St,n,L,P);
-   kill St;
-  }
-  return(dimen);
- }
- else
- {for (i = 1; i <= size(P); i++)
-  {if (P[i] > degbound) {ERROR("degreebound is too small, GB contains elements of higher degree");}}
-  int sd; int dimen = 1;
-  intmat S;
-  sd = P[1];
-  for (i = 2; i <= size(P); i++) {if (P[i] < sd) {sd = P[i];}}
-  sd = (sd - 1);
-  if (sd == 0) { for (i = 1; i <= size(L); i++){if (ncols(L[i]) == 1){S = createStartMat1(n,L[i]); break;}}}
-  else {S = createStartMat(sd,n);}
-  if (intvec(S) == 0) {return(dimen);}
-  for (i = 1; i <= sd; i++) {dimen = dimen +(n^i);}
-  for (i = 1; i <= nrows(S); i++)
-  {intvec St = S[i,1..ncols(S)];
-   dimen = dimen + findDimen(St,n,L,P, degbound);
-   kill St;
-  }
-  return(dimen);
- }
+  if (size(#) > 0) {if (typeof(#[1])=="int"){if (#[1] > 0) {degbound = #[1];}}}
+  intvec P,H; int i;
+  for (i = 1; i <= size(L); i++)
+  {P[i] = ncols(L[i]);
+    if (P[i] == 1) {if ( isInMat(H,L[i]) > 0) {ERROR("Quotient algebra is trivial");}}
+  }
+  if (size(L) == 0) {ERROR("GB is empty, quotient algebra corresponds to free algebra");}
+  kill H;
+  checkAssumptions(degbound,L);
+  if (degbound == 0)
+  {int sd; int dimen = 1;
+    intmat S;
+    sd = P[1];
+    for (i = 2; i <= size(P); i++) {if (P[i] < sd) {sd = P[i];}}
+    sd = (sd - 1);
+    if (sd == 0) { for (i = 1; i <= size(L); i++){if (ncols(L[i]) == 1){S = createStartMat1(n,L[i]); break;}}}
+    else {S = createStartMat(sd,n);}
+    if (intvec(S) == 0) {return(dimen);}
+    for (i = 1; i <= sd; i++) {dimen = dimen +(n^i);}
+    for (i = 1; i <= nrows(S); i++)
+    {intvec St = S[i,1..ncols(S)];
+      dimen = dimen + findDimen(St,n,L,P);
+      kill St;
+    }
+    return(dimen);
+  }
+  else
+  {for (i = 1; i <= size(P); i++)
+    {if (P[i] > degbound) {ERROR("degreebound is too small, GB contains elements of higher degree");}}
+    int sd; int dimen = 1;
+    intmat S;
+    sd = P[1];
+    for (i = 2; i <= size(P); i++) {if (P[i] < sd) {sd = P[i];}}
+    sd = (sd - 1);
+    if (sd == 0) { for (i = 1; i <= size(L); i++){if (ncols(L[i]) == 1){S = createStartMat1(n,L[i]); break;}}}
+    else {S = createStartMat(sd,n);}
+    if (intvec(S) == 0) {return(dimen);}
+    for (i = 1; i <= sd; i++) {dimen = dimen +(n^i);}
+    for (i = 1; i <= nrows(S); i++)
+    {intvec St = S[i,1..ncols(S)];
+      dimen = dimen + findDimen(St,n,L,P, degbound);
+      kill St;
+    }
+    return(dimen);
+  }
 }
 example
@@ -1238 +1239 @@
 "
 {checkAssumptions(0,M);
- intvec L;
- if (size(M) == 0){ERROR("There are no mistletoes, so it appears your dimension is infinite!");}
- if (isInList(L,M) > 0) {print("1 is a mistletoe, therefore dim = 1"); return(1);}
- int i,j,d,s;
- j = 1;
- d = 1 + size(M[1]);
- for (i = 1; i < size(M); i++)
+  intvec L;
+  if (size(M) == 0){ERROR("There are no mistletoes, so it appears your dimension is infinite!");}
+  if (isInList(L,M) > 0) {print("1 is a mistletoe, therefore dim = 1"); return(1);}
+  int i,j,d,s;
+  j = 1;
+  d = 1 + size(M[1]);
+  for (i = 1; i < size(M); i++)
   {s = size(M[i]); if (s > size(M[i+1])){s = size(M[i+1]);}
-   while ((M[i][j] == M[i+1][j]) && (j <= s)){j = j + 1;}
-   d = d + size(M[i+1])- j + 1;
-  }
- return(d);
-}
-example
-{
-  "EXAMPLE:"; echo = 2;
-   ring r = 0,(x,y),dp;
-   def R = makeLetterplaceRing(5); // constructs a Letterplace ring
-   R;
-   setring R; // sets basering to Letterplace ring
-   intvec i1 = 1,2; intvec i2 = 2,1,2;
-   // the mistletoes are xy and yxy, which are already ordered lexicographically
-   list L = i1,i2;
-   ivMis2Dim(L); // returns the dimension of the factor algebra
+    while ((M[i][j] == M[i+1][j]) && (j <= s)){j = j + 1;}
+    d = d + size(M[i+1])- j + 1;
+  }
+  return(d);
+}
+example
+{
+  "EXAMPLE:"; echo = 2;
+  ring r = 0,(x,y),dp;
+  def R = makeLetterplaceRing(5); // constructs a Letterplace ring
+  R;
+  setring R; // sets basering to Letterplace ring
+  intvec i1 = 1,2; intvec i2 = 2,1,2;
+  // the mistletoes are xy and yxy, which are already ordered lexicographically
+  list L = i1,i2;
+  ivMis2Dim(L); // returns the dimension of the factor algebra
 }
 
@@ -1269 +1270 @@
 PURPOSE:Orders a given set of mistletoes lexicographically
 ASSUME: - basering is a Letterplace ring.
-        - intvecs correspond to monomials
+       - intvecs correspond to monomials
 NOTE:   - This is preprocessing, it's not needed if the mistletoes are returned
 @*        from the sickle algorithm.
@@ -1276 +1277 @@
 "
 {checkAssumptions(0,M);
- return(sort(M)[1]);
-}
-example
-{
-  "EXAMPLE:"; echo = 2;
-   ring r = 0,(x,y),dp;
-   def R = makeLetterplaceRing(5); // constructs a Letterplace ring
-   setring R; // sets basering to Letterplace ring
-   intvec i1 = 1,2,1; intvec i2 = 2,2,1; intvec i3 = 1,1; intvec i4 = 2,1,1,1;
-   // the corresponding monomials are xyx,y^2x,x^2,yx^3
-   list M = i1,i2,i3,i4;
-   M;
-   ivOrdMisLex(M);// orders the list of monomials
+  return(sort(M)[1]);
+}
+example
+{
+  "EXAMPLE:"; echo = 2;
+  ring r = 0,(x,y),dp;
+  def R = makeLetterplaceRing(5); // constructs a Letterplace ring
+  setring R; // sets basering to Letterplace ring
+  intvec i1 = 1,2,1; intvec i2 = 2,2,1; intvec i3 = 1,1; intvec i4 = 2,1,1,1;
+  // the corresponding monomials are xyx,y^2x,x^2,yx^3
+  list M = i1,i2,i3,i4;
+  M;
+  ivOrdMisLex(M);// orders the list of monomials
 }
 
@@ -1307 +1308 @@
 "
 {list M;
- int degbound = 0;
- if (size(#) > 0){if (typeof(#[1])=="int"){if (#[1] > 0){degbound = #[1];}}}
- int i;
- intvec P,H;
- for (i = 1; i <= size(L); i++)
- {P[i] = ncols(L[i]);
-  if (P[i] == 1) {if (isInMat(H,L[i]) > 0) {ERROR("Quotient algebra is trivial");}}
- }
- if (size(L) == 0) {ERROR("GB is empty, quotient algebra corresponds to free algebra");}
- kill H;
- checkAssumptions(degbound,L);
- if (degbound == 0)
- {intmat S; int sd;
-  sd = P[1];
-  for (i = 2; i <= size(P); i++) {if (P[i] < sd) {sd = P[i];}}
-  sd = (sd - 1);
-  if (sd == 0) { for (i = 1; i <= size(L); i++){if (ncols(L[i]) == 1){S = createStartMat1(n,L[i]); break;}}}
-  else {S = createStartMat(sd,n);}
-  if (intvec(S) == 0) {return(list (intvec(0)));}
-  for (i = 1; i <= nrows(S); i++)
-  {intvec St = S[i,1..ncols(S)];
-   M = M + findmistletoes(St,n,L,P);
-   kill St;
-  }
-  return(M);
- }
- else
- {for (i = 1; i <= size(P); i++)
-  {if (P[i] > degbound) {ERROR("degreebound is too small, GB contains elements of higher degree");}}
-  intmat S; int sd;
-  sd = P[1];
-  for (i = 2; i <= size(P); i++) {if (P[i] < sd) {sd = P[i];}}
-  sd = (sd - 1);
-  if (sd == 0) { for (i = 1; i <= size(L); i++){if (ncols(L[i]) == 1){S = createStartMat1(n,L[i]); break;}}}
-  else {S = createStartMat(sd,n);}
-  if (intvec(S) == 0) {return(list (intvec(0)));}
-  for (i = 1; i <= nrows(S); i++)
-  {intvec St = S[i,1..ncols(S)];
-   M = M + findmistletoes(St,n,L,P,degbound);
-   kill St;
-  }
-  return(M);
- }
+  int degbound = 0;
+  if (size(#) > 0){if (typeof(#[1])=="int"){if (#[1] > 0){degbound = #[1];}}}
+  int i;
+  intvec P,H;
+  for (i = 1; i <= size(L); i++)
+  {P[i] = ncols(L[i]);
+    if (P[i] == 1) {if (isInMat(H,L[i]) > 0) {ERROR("Quotient algebra is trivial");}}
+  }
+  if (size(L) == 0) {ERROR("GB is empty, quotient algebra corresponds to free algebra");}
+  kill H;
+  checkAssumptions(degbound,L);
+  if (degbound == 0)
+  {intmat S; int sd;
+    sd = P[1];
+    for (i = 2; i <= size(P); i++) {if (P[i] < sd) {sd = P[i];}}
+    sd = (sd - 1);
+    if (sd == 0) { for (i = 1; i <= size(L); i++){if (ncols(L[i]) == 1){S = createStartMat1(n,L[i]); break;}}}
+    else {S = createStartMat(sd,n);}
+    if (intvec(S) == 0) {return(list (intvec(0)));}
+    for (i = 1; i <= nrows(S); i++)
+    {intvec St = S[i,1..ncols(S)];
+      M = M + findmistletoes(St,n,L,P);
+      kill St;
+    }
+    return(M);
+  }
+  else
+  {for (i = 1; i <= size(P); i++)
+    {if (P[i] > degbound) {ERROR("degreebound is too small, GB contains elements of higher degree");}}
+    intmat S; int sd;
+    sd = P[1];
+    for (i = 2; i <= size(P); i++) {if (P[i] < sd) {sd = P[i];}}
+    sd = (sd - 1);
+    if (sd == 0) { for (i = 1; i <= size(L); i++){if (ncols(L[i]) == 1){S = createStartMat1(n,L[i]); break;}}}
+    else {S = createStartMat(sd,n);}
+    if (intvec(S) == 0) {return(list (intvec(0)));}
+    for (i = 1; i <= nrows(S); i++)
+    {intvec St = S[i,1..ncols(S)];
+      M = M + findmistletoes(St,n,L,P,degbound);
+      kill St;
+    }
+    return(M);
+  }
 }
 example
@@ -1388 +1389 @@
 "
 {list M;
- int degbound = 0;
- if (size(#) > 0){if (typeof(#[1])=="int"){if (#[1] > 0){degbound = #[1];}}}
- int i,dimen; list R;
- intvec P,H;
- for (i = 1; i <= size(L); i++)
- {P[i] = ncols(L[i]);
-  if (P[i] == 1) {if (isInMat(H,L[i]) > 0) {ERROR("Quotient algebra is trivial, dimension equals zero");}}
- }
- if (size(L) == 0) {ERROR("GB is empty, quotient algebra corresponds to free algebra");}
- kill H;
- checkAssumptions(degbound,L);
- if (degbound == 0)
- {int sd; dimen = 1;
-  intmat S;
-  sd = P[1];
-  for (i = 2; i <= size(P); i++) {if (P[i] < sd) {sd = P[i];}}
-  sd = (sd - 1);
-  if (sd == 0) { for (i = 1; i <= size(L); i++){if (ncols(L[i]) == 1){S = createStartMat1(n,L[i]); break;}}}
-  else {S = createStartMat(sd,n);}
-  if (intvec(S) == 0) {return(list(dimen,list(intvec(0))));}
-  for (i = 1; i <= sd; i++) {dimen = dimen +(n^i);}
-  R[1] = dimen;
-  for (i = 1; i <= nrows(S); i++)
-  {intvec St = S[i,1..ncols(S)];
-   R = findMisDim(St,n,L,P,R);
-   kill St;
-  }
-  return(R);
- }
- else
- {for (i = 1; i <= size(P); i++)
-  {if (P[i] > degbound) {ERROR("degreebound is too small, GB contains elements of higher degree");}}
-  int sd; dimen = 1;
-  intmat S;
-  sd = P[1];
-  for (i = 2; i <= size(P); i++) {if (P[i] < sd) {sd = P[i];}}
-  sd = (sd - 1);
-  if (sd == 0) { for (i = 1; i <= size(L); i++){if (ncols(L[i]) == 1){S = createStartMat1(n,L[i]); break;}}}
-  else {S = createStartMat(sd,n);}
-  if (intvec(S) == 0) {return(list(dimen,list(intvec(0))));}
-  for (i = 1; i <= sd; i++) {dimen = dimen +(n^i);}
-  R[1] = dimen;
-  for (i = 1; i <= nrows(S); i++)
-  {intvec St = S[i,1..ncols(S)];
-   R = findMisDim(St,n,L,P,R,degbound);
-   kill St;
-  }
-  return(R);
- }
+  int degbound = 0;
+  if (size(#) > 0){if (typeof(#[1])=="int"){if (#[1] > 0){degbound = #[1];}}}
+  int i,dimen; list R;
+  intvec P,H;
+  for (i = 1; i <= size(L); i++)
+  {P[i] = ncols(L[i]);
+    if (P[i] == 1) {if (isInMat(H,L[i]) > 0) {ERROR("Quotient algebra is trivial, dimension equals zero");}}
+  }
+  if (size(L) == 0) {ERROR("GB is empty, quotient algebra corresponds to free algebra");}
+  kill H;
+  checkAssumptions(degbound,L);
+  if (degbound == 0)
+  {int sd; dimen = 1;
+    intmat S;
+    sd = P[1];
+    for (i = 2; i <= size(P); i++) {if (P[i] < sd) {sd = P[i];}}
+    sd = (sd - 1);
+    if (sd == 0) { for (i = 1; i <= size(L); i++){if (ncols(L[i]) == 1){S = createStartMat1(n,L[i]); break;}}}
+    else {S = createStartMat(sd,n);}
+    if (intvec(S) == 0) {return(list(dimen,list(intvec(0))));}
+    for (i = 1; i <= sd; i++) {dimen = dimen +(n^i);}
+    R[1] = dimen;
+    for (i = 1; i <= nrows(S); i++)
+    {intvec St = S[i,1..ncols(S)];
+      R = findMisDim(St,n,L,P,R);
+      kill St;
+    }
+    return(R);
+  }
+  else
+  {for (i = 1; i <= size(P); i++)
+    {if (P[i] > degbound) {ERROR("degreebound is too small, GB contains elements of higher degree");}}
+    int sd; dimen = 1;
+    intmat S;
+    sd = P[1];
+    for (i = 2; i <= size(P); i++) {if (P[i] < sd) {sd = P[i];}}
+    sd = (sd - 1);
+    if (sd == 0) { for (i = 1; i <= size(L); i++){if (ncols(L[i]) == 1){S = createStartMat1(n,L[i]); break;}}}
+    else {S = createStartMat(sd,n);}
+    if (intvec(S) == 0) {return(list(dimen,list(intvec(0))));}
+    for (i = 1; i <= sd; i++) {dimen = dimen +(n^i);}
+    R[1] = dimen;
+    for (i = 1; i <= nrows(S); i++)
+    {intvec St = S[i,1..ncols(S)];
+      R = findMisDim(St,n,L,P,R,degbound);
+      kill St;
+    }
+    return(R);
+  }
 }
 example
@@ -1477 +1478 @@
 "
 {int degbound = 0;
- if (size(#) > 0) {if (typeof(#[1])=="int"){if (#[1] > 0) {degbound = #[1];}}}
- intvec P,H; int i; list R;
- for (i = 1; i <= size(L); i++)
- {P[i] = ncols(L[i]);
-  if (P[i] == 1) {if ( isInMat(H,L[i]) > 0) {ERROR("Quotient algebra is trivial");}}
- }
- if (size(L) == 0) {ERROR("GB is empty, quotient algebra corresponds to free algebra");}
- H[1] = 1;
- checkAssumptions(degbound,L);
- if (degbound == 0)
- {int sd;
-  intmat S;
-  sd = P[1];
-  for (i = 2; i <= size(P); i++) {if (P[i] < sd) {sd = P[i];}}
-  sd = (sd - 1);
-  if (sd == 0) { for (i = 1; i <= size(L); i++){if (ncols(L[i]) == 1){S = createStartMat1(n,L[i]); break;}}}
-  else {S = createStartMat(sd,n);}
-  if (intvec(S) == 0) {return(list(H,list(intvec (0))));}
-  for (i = 1; i <= sd; i++) {H = H,(n^i);}
-  R[1] = H; kill H;
-  for (i = 1; i <= nrows(S); i++)
-  {intvec St = S[i,1..ncols(S)];
-   R = findHCoeffMis(St,n,L,P,R);
-   kill St;
-  }
-  return(R);
- }
- else
- {for (i = 1; i <= size(P); i++)
-  {if (P[i] > degbound) {ERROR("degreebound is too small, GB contains elements of higher degree");}}
-  int sd;
-  intmat S;
-  sd = P[1];
-  for (i = 2; i <= size(P); i++) {if (P[i] < sd) {sd = P[i];}}
-  sd = (sd - 1);
-  if (sd == 0) { for (i = 1; i <= size(L); i++){if (ncols(L[i]) == 1){S = createStartMat1(n,L[i]); break;}}}
-  else {S = createStartMat(sd,n);}
-  if (intvec(S) == 0) {return(list(H,list(intvec(0))));}
-  for (i = 1; i <= sd; i++) {H = H,(n^i);}
-  R[1] = H; kill H;
-  for (i = 1; i <= nrows(S); i++)
-  {intvec St = S[i,1..ncols(S)];
-   R = findHCoeffMis(St,n,L,P,R,degbound);
-   kill St;
-  }
-  return(R);
- }
+  if (size(#) > 0) {if (typeof(#[1])=="int"){if (#[1] > 0) {degbound = #[1];}}}
+  intvec P,H; int i; list R;
+  for (i = 1; i <= size(L); i++)
+  {P[i] = ncols(L[i]);
+    if (P[i] == 1) {if ( isInMat(H,L[i]) > 0) {ERROR("Quotient algebra is trivial");}}
+  }
+  if (size(L) == 0) {ERROR("GB is empty, quotient algebra corresponds to free algebra");}
+  H[1] = 1;
+  checkAssumptions(degbound,L);
+  if (degbound == 0)
+  {int sd;
+    intmat S;
+    sd = P[1];
+    for (i = 2; i <= size(P); i++) {if (P[i] < sd) {sd = P[i];}}
+    sd = (sd - 1);
+    if (sd == 0) { for (i = 1; i <= size(L); i++){if (ncols(L[i]) == 1){S = createStartMat1(n,L[i]); break;}}}
+    else {S = createStartMat(sd,n);}
+    if (intvec(S) == 0) {return(list(H,list(intvec (0))));}
+    for (i = 1; i <= sd; i++) {H = H,(n^i);}
+    R[1] = H; kill H;
+    for (i = 1; i <= nrows(S); i++)
+    {intvec St = S[i,1..ncols(S)];
+      R = findHCoeffMis(St,n,L,P,R);
+      kill St;
+    }
+    return(R);
+  }
+  else
+  {for (i = 1; i <= size(P); i++)
+    {if (P[i] > degbound) {ERROR("degreebound is too small, GB contains elements of higher degree");}}
+    int sd;
+    intmat S;
+    sd = P[1];
+    for (i = 2; i <= size(P); i++) {if (P[i] < sd) {sd = P[i];}}
+    sd = (sd - 1);
+    if (sd == 0) { for (i = 1; i <= size(L); i++){if (ncols(L[i]) == 1){S = createStartMat1(n,L[i]); break;}}}
+    else {S = createStartMat(sd,n);}
+    if (intvec(S) == 0) {return(list(H,list(intvec(0))));}
+    for (i = 1; i <= sd; i++) {H = H,(n^i);}
+    R[1] = H; kill H;
+    for (i = 1; i <= nrows(S); i++)
+    {intvec St = S[i,1..ncols(S)];
+      R = findHCoeffMis(St,n,L,P,R,degbound);
+      kill St;
+    }
+    return(R);
+  }
 }
 example
@@ -1564 +1565 @@
 "
 {int degbound = attrib(basering,"uptodeg");int n = attrib(basering, "lV");
- if (size(#) > 0){if (typeof(#[1])=="int"){if (#[1] >= 0){degbound = #[1];}}}
- if (size(#) > 1){if (typeof(#[1])=="int"){if (#[2] > 0){n = #[2];}}}
- list L;
- L = lp2ivId(normalize(lead(G)));
- return(ivDHilbert(L,n,degbound));
+  if (size(#) > 0){if (typeof(#[1])=="int"){if (#[1] >= 0){degbound = #[1];}}}
+  if (size(#) > 1){if (typeof(#[1])=="int"){if (#[2] > 0){n = #[2];}}}
+  list L;
+  L = lp2ivId(normalize(lead(G)));
+  return(ivDHilbert(L,n,degbound));
 }
 example
@@ -1593 +1594 @@
 @*      - if you specify a different degree bound degbound,
 @*        degbound <= attrib(basering,uptodeg) holds.
-NOTE: - If L is the list returned, then L[1] is an intvec, the Hilbert series,
-@*      L[2] is an integer, the K-dimension and L[3] is an ideal, the mistletoes
+NOTE: - If L is the list returned, then L[1] is an integer, the K-dimension,
+@*      L[2] is an intvec, the Hilbert series and L[3] is an ideal, 
+@*      the mistletoes
 @*    - If degbound is set, there will be a degree bound added. 0 means no
 @*      degree bound. Default: attrib(basering,uptodeg).
@@ -1605 +1607 @@
 "
 {int degbound = attrib(basering,"uptodeg");int n = attrib(basering, "lV");
- if (size(#) > 0){if (typeof(#[1])=="int"){if (#[1] >= 0){degbound = #[1];}}}
- if (size(#) > 1){if (typeof(#[1])=="int"){if (#[2] > 0){n = #[2];}}}
- list L;
- L = lp2ivId(normalize(lead(G)));
- L = ivDHilbertSickle(L,n,degbound);
- L[3] =  ivL2lpI(L[3]);
- return(L);
+  if (size(#) > 0){if (typeof(#[1])=="int"){if (#[1] >= 0){degbound = #[1];}}}
+  if (size(#) > 1){if (typeof(#[1])=="int"){if (#[2] > 0){n = #[2];}}}
+  list L;
+  L = lp2ivId(normalize(lead(G)));
+  L = ivDHilbertSickle(L,n,degbound);
+  L[3] =  ivL2lpI(L[3]);
+  return(L);
 }
 example
@@ -1624 +1626 @@
   // note that the optional parameters are not necessary, due to the finiteness
   // of the K-dimension of the factor algebra
-  lpDHilbert(G); // procedure with ring parameters
-  lpDHilbert(G,0); // procedure without degreebound
+  lpDHilbertSickle(G); // procedure with ring parameters
+  lpDHilbertSickle(G,0); // procedure without degreebound
 }
 
@@ -1645 +1647 @@
 "
 {int degbound = attrib(basering,"uptodeg");int n = attrib(basering, "lV");
- if (size(#) > 0){if (typeof(#[1])=="int"){if (#[1] >= 0){degbound = #[1];}}}
- if (size(#) > 1){if (typeof(#[1])=="int"){if (#[2] > 0){n = #[2];}}}
- list L;
- L = lp2ivId(normalize(lead(G)));
- return(ivHilbert(L,n,degbound));
+  if (size(#) > 0){if (typeof(#[1])=="int"){if (#[1] >= 0){degbound = #[1];}}}
+  if (size(#) > 1){if (typeof(#[1])=="int"){if (#[2] > 0){n = #[2];}}}
+  list L;
+  L = lp2ivId(normalize(lead(G)));
+  return(ivHilbert(L,n,degbound));
 }
 example
@@ -1674 +1676 @@
 "
 {int n = attrib(basering,"lV");
- list L;
- ideal R;
- R = normalize(lead(G));
- L = lp2ivId(R);
- return(ivDimCheck(L,n));
+  list L;
+  ideal R;
+  R = normalize(lead(G));
+  L = lp2ivId(R);
+  return(ivDimCheck(L,n));
 }
 example
@@ -1709 +1711 @@
 "
 {int degbound = attrib(basering, "uptodeg");int n = attrib(basering, "lV");
- if (size(#) > 0){if (typeof(#[1])=="int"){if (#[1] >= 0){degbound = #[1];}}}
- if (size(#) > 1){if (typeof(#[1])=="int"){if (#[2] > 0){n = #[2];}}}
- list L;
- L = lp2ivId(normalize(lead(G)));
- return(ivKDim(L,n,degbound));
+  if (size(#) > 0){if (typeof(#[1])=="int"){if (#[1] >= 0){degbound = #[1];}}}
+  if (size(#) > 1){if (typeof(#[1])=="int"){if (#[2] > 0){n = #[2];}}}
+  list L;
+  L = lp2ivId(normalize(lead(G)));
+  return(ivKDim(L,n,degbound));
 }
 example
@@ -1739 +1741 @@
 "
 {list L;
- L = lpId2ivLi(M);
- return(ivMis2Dim(L));
-}
-example
-{
-  "EXAMPLE:"; echo = 2;
-   ring r = 0,(x,y),dp;
-   def R = makeLetterplaceRing(5); // constructs a Letterplace ring
-  setring R; // sets basering to Letterplace ring
-   ideal L = x(1)*y(2),y(1)*x(2)*y(3);
-   // ideal containing the mistletoes
-   lpMis2Dim(L); // returns the K-dimension of the factor algebra
+  L = lpId2ivLi(M);
+  return(ivMis2Dim(L));
+}
+example
+{
+  "EXAMPLE:"; echo = 2;
+  ring r = 0,(x,y),dp;
+  def R = makeLetterplaceRing(5); // constructs a Letterplace ring
+  setring R; // sets basering to Letterplace ring
+  ideal L = x(1)*y(2),y(1)*x(2)*y(3);
+  // ideal containing the mistletoes
+  lpMis2Dim(L); // returns the K-dimension of the factor algebra
 }
 
@@ -1766 +1768 @@
 {
   "EXAMPLE:"; echo = 2;
-   ring r = 0,(x,y),dp;
-   def R = makeLetterplaceRing(5); // constructs a Letterplace ring
-   setring R; // sets basering to Letterplace ring
-   ideal M = x(1)*y(2)*x(3), y(1)*y(2)*x(3), x(1)*x(2), y(1)*x(2)*x(3)*x(4);
-   // some monomials
-   lpOrdMisLex(M); // orders the monomials lexicographically
+  ring r = 0,(x,y),dp;
+  def R = makeLetterplaceRing(5); // constructs a Letterplace ring
+  setring R; // sets basering to Letterplace ring
+  ideal M = x(1)*y(2)*x(3), y(1)*y(2)*x(3), x(1)*x(2), y(1)*x(2)*x(3)*x(4);
+  // some monomials
+  lpOrdMisLex(M); // orders the monomials lexicographically
 }
 
@@ -1789 +1791 @@
 "
 {int degbound = attrib(basering,"uptodeg"); int n = attrib(basering, "lV");
- if (size(#) > 0){if (typeof(#[1])=="int"){if (#[1] >= 0){degbound = #[1];}}}
- if (size(#) > 1){if (typeof(#[1])=="int"){if (#[2] > 0){n = #[2];}}}
- list L; ideal R;
- R = normalize(lead(G));
- L = lp2ivId(R);
- L = ivSickle(L,n,degbound);
- R = ivL2lpI(L);
- return(R);
+  if (size(#) > 0){if (typeof(#[1])=="int"){if (#[1] >= 0){degbound = #[1];}}}
+  if (size(#) > 1){if (typeof(#[1])=="int"){if (#[2] > 0){n = #[2];}}}
+  list L; ideal R;
+  R = normalize(lead(G));
+  L = lp2ivId(R);
+  L = ivSickle(L,n,degbound);
+  R = ivL2lpI(L);
+  return(R);
 }
 example
@@ -1829 +1831 @@
 "
 {int degbound = attrib(basering,"uptodeg");int n = attrib(basering, "lV");
- if (size(#) > 0){if (typeof(#[1])=="int"){if (#[1] >= 0){degbound = #[1];}}}
- if (size(#) > 1){if (typeof(#[1])=="int"){if (#[2] > 0){n = #[2];}}}
- list L;
- L = lp2ivId(normalize(lead(G)));
- L = ivSickleDim(L,n,degbound);
- L[2] = ivL2lpI(L[2]);
- return(L);
+  if (size(#) > 0){if (typeof(#[1])=="int"){if (#[1] >= 0){degbound = #[1];}}}
+  if (size(#) > 1){if (typeof(#[1])=="int"){if (#[2] > 0){n = #[2];}}}
+  list L;
+  L = lp2ivId(normalize(lead(G)));
+  L = ivSickleDim(L,n,degbound);
+  L[2] = ivL2lpI(L[2]);
+  return(L);
 }
 example
@@ -1870 +1872 @@
 "
 {int degbound = attrib(basering,"uptodeg");int n = attrib(basering, "lV");
- if (size(#) > 0){if (typeof(#[1])=="int"){if (#[1] >= 0){degbound = #[1];}}}
- if (size(#) > 1){if (typeof(#[1])=="int"){if (#[2] > 0){n = #[2];}}}
- list L;
- L = lp2ivId(normalize(lead(G)));
- L = ivSickleHil(L,n,degbound);
- L[2] =  ivL2lpI(L[2]);
- return(L);
+  if (size(#) > 0){if (typeof(#[1])=="int"){if (#[1] >= 0){degbound = #[1];}}}
+  if (size(#) > 1){if (typeof(#[1])=="int"){if (#[2] > 0){n = #[2];}}}
+  list L;
+  L = lp2ivId(normalize(lead(G)));
+  L = ivSickleHil(L,n,degbound);
+  L[2] =  ivL2lpI(L[2]);
+  return(L);
 }
 example
@@ -1916 +1918 @@
 "
 {int m,d,h,degbound;
- m = 1; d = 0; h = 0; degbound = attrib(basering,"uptodeg");
- if (size(#) > 0) {if (typeof(#[1])=="int"){if (#[1] < 1) {m = 0;}}}
- if (size(#) > 1) {if (typeof(#[1])=="int"){if (#[2] > 0) {d = 1;}}}
- if (size(#) > 2) {if (typeof(#[1])=="int"){if (#[3] > 0) {h = 1;}}}
- if (size(#) > 3) {if (typeof(#[1])=="int"){if (#[4] >= 0) {degbound = #[4];}}}
- if (m == 1)
- {if (d == 0)
-  {if (h == 0) {return(lpSickle(G,degbound,attrib(basering,"lV")));}
-   else        {return(lpSickleHil(G,degbound,attrib(basering,"lV")));}
+  m = 1; d = 0; h = 0; degbound = attrib(basering,"uptodeg");
+  if (size(#) > 0) {if (typeof(#[1])=="int"){if (#[1] < 1) {m = 0;}}}
+  if (size(#) > 1) {if (typeof(#[1])=="int"){if (#[2] > 0) {d = 1;}}}
+  if (size(#) > 2) {if (typeof(#[1])=="int"){if (#[3] > 0) {h = 1;}}}
+  if (size(#) > 3) {if (typeof(#[1])=="int"){if (#[4] >= 0) {degbound = #[4];}}}
+  if (m == 1)
+  {if (d == 0)
+    {if (h == 0) {return(lpSickle(G,degbound,attrib(basering,"lV")));}
+      else        {return(lpSickleHil(G,degbound,attrib(basering,"lV")));}
+    }
+    else
+    {if (h == 0) {return(lpSickleDim(G,degbound,attrib(basering,"lV")));}
+      else {return(lpDHilbertSickle(G,degbound,attrib(basering,"lV")));}
+    }
   }
   else
-  {if (h == 0) {return(lpSickleDim(G,degbound,attrib(basering,"lV")));}
-   else {return(lpDHilbertSickle(G,degbound,attrib(basering,"lV")));}
-  }
- }
- else
- {if (d == 0)
-  {if (h == 0) {ERROR("You request to do nothing, so relax and do so");}
-   else        {return(lpHilbert(G,degbound,attrib(basering,"lV")));}
-  }
-  else
-  {if (h == 0) {return(lpKDim(G,degbound,attrib(basering,"lV")));}
-   else {return(lpDHilbert(G,degbound,attrib(basering,"lV")));}
-  }
- }
+  {if (d == 0)
+    {if (h == 0) {ERROR("You request to do nothing, so relax and do so");}
+      else        {return(lpHilbert(G,degbound,attrib(basering,"lV")));}
+    }
+    else
+    {if (h == 0) {return(lpKDim(G,degbound,attrib(basering,"lV")));}
+      else {return(lpDHilbert(G,degbound,attrib(basering,"lV")));}
+    }
+  }
 }
 example
@@ -1961 +1963 @@
 proc tst_fpadim()
 {
- example ivDHilbert;
- example ivDHilbertSickle;
- example ivDimCheck;
- example ivHilbert;
- example ivKDim;
- example ivMis2Dim;
- example ivOrdMisLex;
- example ivSickle;
- example ivSickleHil;
- example ivSickleDim;
- example lpDHilbert;
- example lpDHilbertSickle;
- example lpHilbert;
- example lpDimCheck;
- example lpKDim;
- example lpMis2Dim;
- example lpOrdMisLex;
- example lpSickle;
- example lpSickleHil;
- example lpSickleDim;
- example sickle;
- example ivL2lpI;
- example iv2lp;
- example iv2lpList;
- example iv2lpMat;
- example lp2iv;
- example lp2ivId;
- example lpId2ivLi;
+  example ivDHilbert;
+  example ivDHilbertSickle;
+  example ivDimCheck;
+  example ivHilbert;
+  example ivKDim;
+  example ivMis2Dim;
+  example ivOrdMisLex;
+  example ivSickle;
+  example ivSickleHil;
+  example ivSickleDim;
+  example lpDHilbert;
+  example lpDHilbertSickle;
+  example lpHilbert;
+  example lpDimCheck;
+  example lpKDim;
+  example lpMis2Dim;
+  example lpOrdMisLex;
+  example lpSickle;
+  example lpSickleHil;
+  example lpSickleDim;
+  example sickle;
+  example ivL2lpI;
+  example iv2lp;
+  example iv2lpList;
+  example iv2lpMat;
+  example lp2iv;
+  example lp2ivId;
+  example lpId2ivLi;
 }
 
@@ -1996 +1998 @@
 
 /*
-Here are some examples one may try. Just copy them into your console.
-These are relations for braid groups, up to degree d:
-
-
-LIB "fpadim.lib";
-ring r = 0,(x,y,z),dp;
-int d =10; // degree
-def R = makeLetterplaceRing(d);
-setring R;
-ideal I = y(1)*x(2)*y(3) - z(1)*y(2)*z(3), x(1)*y(2)*x(3) - z(1)*x(2)*y(3),
-z(1)*x(2)*z(3) - y(1)*z(2)*x(3), x(1)*x(2)*x(3) + y(1)*y(2)*y(3) +
-z(1)*z(2)*z(3) + x(1)*y(2)*z(3);
-option(prot);
-option(redSB);option(redTail);option(mem);
-ideal J = system("freegb",I,d,3);
-lpDimCheck(J);
-sickle(J,1,1,1,d);//Computes mistletoes, K-dimension and the Hilbert series
-
-
-
-LIB "fpadim.lib";
-ring r = 0,(x,y,z),dp;
-int d =11; // degree
-def R = makeLetterplaceRing(d);
-setring R;
-ideal I = y(1)*x(2)*y(3) - z(1)*y(2)*z(3), x(1)*y(2)*z(3) - z(1)*x(2)*y(3),
-z(1)*x(2)*z(3) - y(1)*z(2)*x(3), x(1)*x(2)*x(3) + y(1)*y(2)*y(3) +
-z(1)*z(2)*z(3) + x(1)*y(2)*z(3);
-option(prot);
-option(redSB);option(redTail);option(mem);
-ideal J = system("freegb",I,d,3);
-lpDimCheck(J);
-sickle(J,1,1,1,d);
-
-
-
-LIB "fpadim.lib";
-ring r = 0,(x,y,z),dp;
-int d  = 6; // degree
-def R  = makeLetterplaceRing(d);
-setring R;
-ideal I = y(1)*x(2)*y(3) - z(1)*y(2)*z(3), x(1)*y(2)*x(3) - z(1)*x(2)*y(3),
-z(1)*x(2)*z(3) - y(1)*z(2)*x(3), x(1)*x(2)*x(3) -2*y(1)*y(2)*y(3) + 3*z(1)*z(2)*z(3) -4*x(1)*y(2)*z(3) + 5*x(1)*z(2)*z(3)- 6*x(1)*y(2)*y(3) +7*x(1)*x(2)*z(3) - 8*x(1)*x(2)*y(3);
-option(prot);
-option(redSB);option(redTail);option(mem);
-ideal J = system("freegb",I,d,3);
-lpDimCheck(J);
-sickle(J,1,1,1,d);
+  Here are some examples one may try. Just copy them into your console.
+  These are relations for braid groups, up to degree d:
+
+
+  LIB "fpadim.lib";
+  ring r = 0,(x,y,z),dp;
+  int d =10; // degree
+  def R = makeLetterplaceRing(d);
+  setring R;
+  ideal I = y(1)*x(2)*y(3) - z(1)*y(2)*z(3), x(1)*y(2)*x(3) - z(1)*x(2)*y(3),
+  z(1)*x(2)*z(3) - y(1)*z(2)*x(3), x(1)*x(2)*x(3) + y(1)*y(2)*y(3) +
+  z(1)*z(2)*z(3) + x(1)*y(2)*z(3);
+  option(prot);
+  option(redSB);option(redTail);option(mem);
+  ideal J = system("freegb",I,d,3);
+  lpDimCheck(J);
+  sickle(J,1,1,1,d);//Computes mistletoes, K-dimension and the Hilbert series
+
+
+
+  LIB "fpadim.lib";
+  ring r = 0,(x,y,z),dp;
+  int d =11; // degree
+  def R = makeLetterplaceRing(d);
+  setring R;
+  ideal I = y(1)*x(2)*y(3) - z(1)*y(2)*z(3), x(1)*y(2)*z(3) - z(1)*x(2)*y(3),
+  z(1)*x(2)*z(3) - y(1)*z(2)*x(3), x(1)*x(2)*x(3) + y(1)*y(2)*y(3) +
+  z(1)*z(2)*z(3) + x(1)*y(2)*z(3);
+  option(prot);
+  option(redSB);option(redTail);option(mem);
+  ideal J = system("freegb",I,d,3);
+  lpDimCheck(J);
+  sickle(J,1,1,1,d);
+
+
+
+  LIB "fpadim.lib";
+  ring r = 0,(x,y,z),dp;
+  int d  = 6; // degree
+  def R  = makeLetterplaceRing(d);
+  setring R;
+  ideal I = y(1)*x(2)*y(3) - z(1)*y(2)*z(3), x(1)*y(2)*x(3) - z(1)*x(2)*y(3),
+  z(1)*x(2)*z(3) - y(1)*z(2)*x(3), x(1)*x(2)*x(3) -2*y(1)*y(2)*y(3) + 3*z(1)*z(2)*z(3) -4*x(1)*y(2)*z(3) + 5*x(1)*z(2)*z(3)- 6*x(1)*y(2)*y(3) +7*x(1)*x(2)*z(3) - 8*x(1)*x(2)*y(3);
+  option(prot);
+  option(redSB);option(redTail);option(mem);
+  ideal J = system("freegb",I,d,3);
+  lpDimCheck(J);
+  sickle(J,1,1,1,d);
 */
 
 /*
-Here are some examples, which can also be found in [studzins]:
-
-// takes up to 880Mb of memory
-LIB "fpadim.lib";
-ring r = 0,(x,y,z),dp;
-int d =10; // degree
-def R = makeLetterplaceRing(d);
-setring R;
-ideal I =
-z(1)*z(2)*z(3)*z(4) + y(1)*x(2)*y(3)*x(4) - x(1)*y(2)*y(3)*x(4) - 3*z(1)*y(2)*x(3)*z(4), x(1)*x(2)*x(3) + y(1)*x(2)*y(3) - x(1)*y(2)*x(3), z(1)*y(2)*x(3)-x(1)*y(2)*z(3) + z(1)*x(2)*z(3);
-option(prot);
-option(redSB);option(redTail);option(mem);
-ideal J = system("freegb",I,d,nvars(r));
-lpDimCheck(J);
-sickle(J,1,1,1,d); // dimension is 24872
-
-
-LIB "fpadim.lib";
-ring r = 0,(x,y,z),dp;
-int d =10; // degree
-def R = makeLetterplaceRing(d);
-setring R;
-ideal I = x(1)*y(2) + y(1)*z(2), x(1)*x(2) + x(1)*y(2) - y(1)*x(2) - y(1)*y(2);
-option(prot);
-option(redSB);option(redTail);option(mem);
-ideal J = system("freegb",I,d,3);
-lpDimCheck(J);
-sickle(J,1,1,1,d);
+  Here are some examples, which can also be found in [studzins]:
+
+  // takes up to 880Mb of memory
+  LIB "fpadim.lib";
+  ring r = 0,(x,y,z),dp;
+  int d =10; // degree
+  def R = makeLetterplaceRing(d);
+  setring R;
+  ideal I =
+  z(1)*z(2)*z(3)*z(4) + y(1)*x(2)*y(3)*x(4) - x(1)*y(2)*y(3)*x(4) - 3*z(1)*y(2)*x(3)*z(4), x(1)*x(2)*x(3) + y(1)*x(2)*y(3) - x(1)*y(2)*x(3), z(1)*y(2)*x(3)-x(1)*y(2)*z(3) + z(1)*x(2)*z(3);
+  option(prot);
+  option(redSB);option(redTail);option(mem);
+  ideal J = system("freegb",I,d,nvars(r));
+  lpDimCheck(J);
+  sickle(J,1,1,1,d); // dimension is 24872
+
+
+  LIB "fpadim.lib";
+  ring r = 0,(x,y,z),dp;
+  int d =10; // degree
+  def R = makeLetterplaceRing(d);
+  setring R;
+  ideal I = x(1)*y(2) + y(1)*z(2), x(1)*x(2) + x(1)*y(2) - y(1)*x(2) - y(1)*y(2);
+  option(prot);
+  option(redSB);option(redTail);option(mem);
+  ideal J = system("freegb",I,d,3);
+  lpDimCheck(J);
+  sickle(J,1,1,1,d);
 */