Index: Singular/LIB/monomial.lib
===================================================================
--- Singular/LIB/monomial.lib	(revision 7f8587b3752e6d6a92df017bafdfb3d03198e66b)
+++ Singular/LIB/monomial.lib	(revision abbd22e3508e31d6abd926f194f4cb62f9365784)
@@ -40,7 +40,7 @@
 ";
 LIB "poly.lib";  // Para "maxdeg1" en "isprimeMon"
-//---------------------------------------------------------------------------        
+//---------------------------------------------------------------------------
 //-----------------------   INTERNOS    -------------------------------------
-//---------------------------------------------------------------------------        
+//---------------------------------------------------------------------------
 /////////////////////////////////////////////////////////////////////////////
 //
@@ -54,11 +54,11 @@
   int i,n;
   n = ncols(I);
-  for (i = 1 ; i <= n ; i ++)
-    {
-      if ( size(I[i]) > 1 )
-        {
-          return (0);
-        }
-    }
+  for (i = n ; i >= 1 ; i --)
+  {
+    if ( size(I[i]) > 1 )
+    {
+      return (0);
+    }
+  }
   return (1);
 }
@@ -80,17 +80,17 @@
   J = 0;
 
-  int sizI = size(I);
+  int sizI = ncols(I);
   for (i = 1 ; i <= sizI ; i++)
-    {
-      g = gcdMon(I[i],f);
-      // Cociente de dos monomios: restamos los exponentes, y en el
-      // denominador va el mcd
-      v = leadexp(I[i]) - leadexp(g);
-      generator = monomial (v);
-      if (membershipMon(generator,J) == 0)
-        {
-          J=J,generator;
-        }
-    }
+  {
+    g = gcd(I[i],f);
+    // Cociente de dos monomios: restamos los exponentes, y en el
+    // denominador va el mcd
+    v = leadexp(I[i]) - leadexp(g);
+    generator = monomial (v);
+    if (membershipMon(generator,J) == 0)
+    {
+      J=J,generator;
+    }
+  }
   // minimal monomial basis
   return ( minbase(J) );
@@ -107,26 +107,25 @@
 "
 {
-  def R = basering;
   // Variables
-  int nvar,i,cont,sop;
+  int i,cont,sop;
   intvec expf;
-  nvar = nvars(R);
+  int nvar = nvars(basering);
   expf = leadexp(f);
   cont = 0;
   // cont va a contar el numero de componentes del vector no nulas.
   // En sop guardamos el subindice de la componente no nula.
-  for (i = 1 ; i <= nvar ; i++)
-    {
-      if (expf[i] > 0)
-        {
-          cont ++;
-          sop = i;
-          // Si cont > 1 ==> aparece mas de una variable, devolvemos 0
-          if (cont > 1)
-            {
-              return (0);
-            }
-        }
-    }
+  for (i = nvar ; i >= 1 ; i--)
+  {
+    if (expf[i] > 0)
+    {
+      cont ++;
+      sop = i;
+      // Si cont > 1 ==> aparece mas de una variable, devolvemos 0
+      if (cont > 1)
+      {
+        return (0);
+      }
+    }
+  }
   return(sop);
 }
@@ -145,31 +144,30 @@
 "
 {
-  def R = basering;
   // Variables
   int sizI,i,nvar,j,sum;
   intvec w,exp;
-  sizI = size(I);
-  nvar = nvars(R);
+  sizI = ncols(I);
+  nvar = nvars(basering);
   for (i = 1 ; i <= sizI ; i++)
-    {
-      sum = 0;
-      exp = leadexp(I[i]);
-      for (j = 1 ; j <= nvar ; j++)
-        {
-          // Al menos tenemos una variable en cada generador, luego
-          // entramos minimo 1 vez, luego sum >= 1.
-          if (exp[j] <> 0)
-            {
-              sum = sum + 1;
-              w[sum] = j;
-            }
-        }
-      // Si hay mas de una variable la suma sera mayor que 1; y ya
-      // sabemos que I no es irreducible.
-      if (sum <> 1)
-        {
-          return(i,w);
-        }
-    }
+  {
+    sum = 0;
+    exp = leadexp(I[i]);
+    for (j = 1 ; j <= nvar ; j++)
+    {
+      // Al menos tenemos una variable en cada generador, luego
+      // entramos minimo 1 vez, luego sum >= 1.
+      if (exp[j] <> 0)
+      {
+        sum++;
+        w[sum] = j;
+      }
+    }
+    // Si hay mas de una variable la suma sera mayor que 1; y ya
+    // sabemos que I no es irreducible.
+    if (sum <> 1)
+    {
+      return(i,w);
+    }
+  }
   return(1);
 }
@@ -186,15 +184,15 @@
   poly f;
   int i,resp;
-  int n = size(I);
+  int n = ncols(I);
   // Desde que haya un generador que no pertenzca al ideal, ya no se da
   // el contenido y terminamos.
   for (i = 1 ; i <= n ; i++)
-    {
-      resp = membershipMon(I[i],J);
-      if (resp == 0)
-        {
-          return(0);
-        }
-    }
+  {
+    resp = membershipMon(I[i],J);
+    if (resp == 0)
+    {
+      return(0);
+    }
+  }
   return(1);
 }
@@ -215,22 +213,23 @@
   // que vienen dados por el sistema minimal de generadores.
   if (size(I) <> size(J))
-    {
-      return(0);
-    }
-  n = size(I);
+  {
+    return(0);
+  }
   // Como ambos ideales vienen dados por la base minimal, no vamos a
   // tener problemas con que comparemos uno de I con otro de J, pues
   // no puede haber generadores iguales en el mismo ideal.
   // Si los ordenamos, se puede comparar uno a uno
-  I = sort(I)[1];
-  J = sort(J)[1];
-  for (i = 1 ; i <= n ; i++)
-    {
-      if (I[i] <> J[i])
-        {
-          return(0);
-        }
-    }
-  return(1);
+  return(matrix( sort(I)[1])==matrix(sort(J)[1]));
+  //n = size(I);
+  //I = sort(I)[1];
+  //J = sort(J)[1];
+  //for (i = 1 ; i <= n ; i++)
+  //{
+  //  if (I[i] <> J[i])
+  //  {
+  //    return(0);
+  //  }
+  //}
+  //return(1);
 }
 /////////////////////////////////////////////////////////////////////////////
@@ -245,34 +244,27 @@
 {
   // Cambiamos de anillo
-  def R = basering;
-  int nvar = nvars(R);
-  string s = "ring R1 =",charstr(R),",x(1..nvar),dp;";
-  execute(s);
+  int nvar = nvars(basering);
   // Variables
   int i,cont;
   intvec exp;
   ideal rad;
-  ideal I = fetch(R,I);
   // Como en cada generador aparece solo una variable,  y ademas la
   // la misma variable no va a aparecer dos veces, es suficiente
   // con sumar los exponentes de todos los generadores para saber que
   // variables aparecen.
-  int n = size(I);
+  int n = ncols(I);
   for (i = 1 ; i <= n ; i++)
-    {
-      exp = exp + leadexp (I[i]);
-    }
+  {
+    exp = exp + leadexp (I[i]);
+  }
   cont = 1;
   for (i = 1 ; i <= nvar ; i++)
-    {
-      if (exp[i] <> 0)
-        {
-          rad[cont] = x(i);
-          cont ++;
-        }
-    }
-  setring R;
-  ideal rad = fetch(R1,rad);
-  kill R1;
+  {
+    if (exp[i] <> 0)
+    {
+      rad[cont] = var(i);
+      cont ++;
+    }
+  }
   return (rad);
 }
@@ -292,11 +284,10 @@
 "
 {
-  def R = basering;
   // Variables
   int control,nvar,i,sub_in,l,j;
   intvec v,w,exp_gen;
   // El ideal ya entra generado por el sistema minimal
-  nvar = nvars(R);
-  int sizI = size(I);
+  nvar = nvars(basering);
+  int sizI = ncols(I);
   v[nvar] = 0;
   int cont = 1;
@@ -305,40 +296,40 @@
   // generadores de I que hay que comprobar.
   for (i = 1 ; i <= sizI ; i++ )
-    {
-      sub_in = soporte(I[i]);
-      if ( sub_in <> 0)
-        {
-          v[sub_in] = 1;
-        }
-      else
-        {
-          w[cont] = i;
-          cont ++;
-        }
-    }
+  {
+    sub_in = soporte(I[i]);
+    if ( sub_in <> 0)
+    {
+      v[sub_in] = 1;
+    }
+    else
+    {
+      w[cont] = i;
+      cont ++;
+    }
+  }
   l = size(w);
   // No hay ningun generador que tenga productos de variables, luego
   //  este ideal ya es primario.
   if (l == 1 && w[1] == 0)
-    {
-      return (1);
-    }
+  {
+    return (1);
+  }
   for (i = 1 ; i <= l ; i++)
-    {
-      exp_gen = leadexp(I[w[i]]);
-      // Ahora hay que ver que valor tiene el exponente de los
-      // generadores oportunos en la posicion que es cero dentro del
-      // vector v.
-      for (j = 1 ; j <= nvar ; j++)
-        {
-          if (v[j] == 0)
-            {
-              if (exp_gen[j] <> 0)
-                {
-                  return (0,j,w);
-                }
-            }
-        }
-    }
+  {
+    exp_gen = leadexp(I[w[i]]);
+    // Ahora hay que ver que valor tiene el exponente de los
+    // generadores oportunos en la posicion que es cero dentro del
+    // vector v.
+    for (j = 1 ; j <= nvar ; j++)
+    {
+      if (v[j] == 0)
+      {
+        if (exp_gen[j] <> 0)
+        {
+          return (0,j,w);
+        }
+      }
+    }
+  }
   // Si hemos llegado hasta aqui hemos recorrido todo el ideal y por tanto
   // es primario.
@@ -371,11 +362,11 @@
   max = 0;
   for (i = 1 ; i <= n ; i++)
-    {
-      exp = leadexp (I[v[i+2]]);
-      if (exp[v[2]] > max)
-        {
-          max = exp[v[2]];
-        }
-    }
+  {
+    exp = leadexp (I[v[i+2]]);
+    if (exp[v[2]] > max)
+    {
+      max = exp[v[2]];
+    }
+  }
   return (max);
 }
@@ -396,24 +387,24 @@
   int sizl = size(l);
   for (i = 1 ; i <= sizl ; i++)
-    {
-      J = 1;
-      for (j = 1 ; j <= sizl ; j++)
-        {
-          // Hacemos la interseccion de todos los ideales menos uno y
-          // luego se estudia el contenido.
-          if (j <> i)
-            {
-              J = intersect (J,l[j]);
-            }
-        }
-      J = minbase(J);
-      resp = contents(J,l[i]);
-      if (resp == 1)
-        {
-          l = delete (l,i);
-          i--;
-          sizl = size(l);
-        }
-    }
+  {
+    J = 1;
+    for (j = 1 ; j <= sizl ; j++)
+    {
+      // Hacemos la interseccion de todos los ideales menos uno y
+      // luego se estudia el contenido.
+      if (j <> i)
+      {
+        J = intersect (J,l[j]);
+      }
+    }
+    J = minbase(J);
+    resp = contents(J,l[i]);
+    if (resp == 1)
+    {
+      l = delete (l,i);
+      i--;
+      sizl = size(l);
+    }
+  }
   return (l);
 }
@@ -432,8 +423,5 @@
 {
   // Cambiamos de anillo
-  def R = basering;
-  int nvar = nvars(R);
-  string s = "ring R1 =",charstr(R),",x(1..nvar),dp;";
-  execute(s);
+  int nvar = nvars(basering);
   // Variables
   int i,j;
@@ -441,29 +429,25 @@
   list l;
   ideal J;
-  ideal I = fetch (R,I);
-  int sizI = size(I);
+  int sizI = ncols(I);
   // Vamos a tener tantas componentes como generadores minimales tiene el
   // ideal, por eso el bucle es de 1 a size(I).
- for (i = 1 ; i <= sizI ; i++)
-   {
-     J = 0;
-     exp_I = leadexp (I[i]);
-     for (j = 1 ; j <= nvar ; j++)
-       {
-         if (exp_I[j] <> 0)
-           {
-             exp[j] = v[j] + 1 - exp_I[j];
-             J = J, x(j)^exp[j];
-           }
-       }
-     // Tenemos siempre un cero por la inicializacion de J, entonces
-     // lo quitamos.
-     J = simplify (J,2);
-     l = insert (l,J);
-   }
- setring R;
- list l = fetch (R1,l);
- kill R1;
- return (l);
+  for (i = 1 ; i <= sizI ; i++)
+  {
+    J = 0;
+    exp_I = leadexp (I[i]);
+    for (j = 1 ; j <= nvar ; j++)
+    {
+      if (exp_I[j] <> 0)
+      {
+        exp[j] = v[j] + 1 - exp_I[j];
+        J = J, var(j)^exp[j];
+      }
+    }
+    // Tenemos siempre un cero por la inicializacion de J, entonces
+    // lo quitamos.
+    J = simplify (J,2);
+    l = insert (l,J);
+  }
+  return (l);
 }
 /////////////////////////////////////////////////////////////////////////////
@@ -485,7 +469,7 @@
   sizl1 = size(l1);
   for (i = 1 ; i <= sizl1 ; i++)
-    {
-      l2[i] = radicalAux (l1[i]);
-    }
+  {
+    l2[i] = radicalAux (l1[i]);
+  }
   sizl2 = size(l2);
   int sizl2i, sizl2j;
@@ -495,31 +479,31 @@
   // l3 = primary components list
   for (i = 1 ; i <= sizl1 ; i++)
-    {
-      J = l2[i];
-      sizl2i = size(l2[i]);
-      K = l1[i];
-      for (j = i+1 ; j <= sizl2 ; j++)
-        {
-          sizl2j = size(l2[j]);
-          if (sizl2i == sizl2j)
-            {
-              if (equal (J,l2[j]) == 1)
-                {
-                  K = minbase(intersect (K,l1[j]));
-                  l1 = delete (l1,j);
-                  sizl1 = size(l1);
-                  l2 = delete (l2,j);
-                  sizl2 = size(l2);
-                  j--;
-                }
-            }
-        }
-      l3 = insert (l3,K);
-    }
+  {
+    J = l2[i];
+    sizl2i = size(l2[i]);
+    K = l1[i];
+    for (j = i+1 ; j <= sizl2 ; j++)
+    {
+      sizl2j = size(l2[j]);
+      if (sizl2i == sizl2j)
+      {
+        if (equal (J,l2[j]) == 1)
+        {
+          K = minbase(intersect (K,l1[j]));
+          l1 = delete (l1,j);
+          sizl1 = size(l1);
+          l2 = delete (l2,j);
+          sizl2 = size(l2);
+          j--;
+        }
+      }
+    }
+    l3 = insert (l3,K);
+  }
   return (l3);
 }
 /////////////////////////////////////////////////////////////////////////////
 //
-static proc isMinimal (ideal I)        
+static proc isMinimal (ideal I)
 "
 USAGE:    isMinimal (I); I ideal.
@@ -535,50 +519,50 @@
   I = simplify(I,2);
   int resp = 1;
-  int sizI = size(I);
+  int sizI = ncols(I);
   // Cambiamos el tamano de I cuando eliminamos generadores
   for (i = 1 ; i <= sizI ; i++)
-    {
-      if (sizI <> 1)
-        {
-          if (i == 1)
-            {
-              J = I[2..sizI];
-            }
-          else
-            {
-              if (i > 1 && i < sizI)
-                {
-                  J = I[1..i-1], I[i+1..sizI];
-                }
-              else
-                {
-                  J = I[1..sizI-1];
-                }
-            }
-          // Si quitamos el generador del lugar "i", luego el que
-          // ocupa ahora el lugar "i" es el "i+1", de ahi que restemos
-          // 1 al i para volver al for de manera que recorramos los
-          // generadores como debemos.                
-          if (membershipMon(I[i],J) == 1)
-            {
-              resp = 0;
-              I = J;
-              i--;
-              sizI = size(I);
-            }
-        }
-    }
+  {
+    if (sizI <> 1)
+    {
+      if (i == 1)
+      {
+        J = I[2..sizI];
+      }
+      else
+      {
+        if (i > 1 && i < sizI)
+        {
+          J = I[1..i-1], I[i+1..sizI];
+        }
+        else
+        {
+          J = I[1..sizI-1];
+        }
+      }
+      // Si quitamos el generador del lugar "i", luego el que
+      // ocupa ahora el lugar "i" es el "i+1", de ahi que restemos
+      // 1 al i para volver al for de manera que recorramos los
+      // generadores como debemos.
+      if (membershipMon(I[i],J) == 1)
+      {
+        resp = 0;
+        I = J;
+        i--;
+        sizI = size(I);
+      }
+    }
+  }
   if (resp == 1)
-    {
-      return (1);
-    }
+  {
+    return (1);
+  }
   else
-    {
-      return (0,I);
-    }
+  {
+    return (0,I);
+  }
 }
 /////////////////////////////////////////////////////////////////////////////
-//        
-static proc isMonomialGB (ideal I)        
+//
+static proc isMonomialGB (ideal I)
 "
 USAGE:    isMonomialGB (I); I ideal.
@@ -591,38 +575,28 @@
 "
 {
-  // Cambiamos de anillo
-  def R = basering;
-  int nvar = nvars(R);
-  string s = "ring R1 =",charstr(R),",x(1..nvar),dp;";
-  execute(s);
-        
   // Variables
-  int resp,m,k;
-  // Queremos la base de Grobner reducida, para uncidad.
-  ideal I = fetch(R,I);
-  option(redSB);        
+  int resp;
   // Si el ideal es cero, no es monomial.
   if ( size(I) == 0)
-    {
-      return(0);
-    }
+  {
+    return(0);
+  }
+  // Queremos la base de Grobner reducida, para uncidad.
+  intvec save_opt=option(get);
+  option(redSB);
   // Base de Grobner
   I = std(I);
+  option(set,save_opt);
   // Una vez que tenemos la GB, no es mas que comprobar que el ideal
   // esta generado por monomios.
   resp = checkIdeal(I);
   if (resp == 0)
-    {
-      setring R;
-      kill R1;
-      return (0);
-    }
+  {
+    return (0);
+  }
   else
-    {
-      setring R;
-      I = fetch (R1,I);
-      kill R1;
-      return (1,I);
-    }
+  {
+    return (1,I);
+  }
 }
 /////////////////////////////////////////////////////////////////////////////
@@ -635,7 +609,4 @@
 proc areEqual(list l1,list l2)
 {
-  def R = basering;
-  l1 = fetch(R,l1);
-  l2 = fetch(R,l2);
   int i,j,sizIdeal;
   poly generator;
@@ -643,24 +614,24 @@
   int sizl1 = size(l1);
   for (i = 1 ; i <= sizl1 ; i ++)
-    {
-      sizIdeal = size(l1[i]);
-      generator = 1;
-      for (j = 1 ; j <= sizIdeal ; j ++)
-        {
-          generator = generator*l1[i][j];
-        }
-      l1Ideal[i] = generator;
-    }
+  {
+    sizIdeal = size(l1[i]);
+    generator = 1;
+    for (j = 1 ; j <= sizIdeal ; j ++)
+    {
+      generator = generator*l1[i][j];
+    }
+    l1Ideal[i] = generator;
+  }
   int sizl2 = size(l2);
   for (i = 1 ; i <= sizl2 ; i ++)
-    {
-      sizIdeal = size(l2[i]);
-      generator = 1;
-      for (j = 1 ; j <= sizIdeal ; j ++)
-        {
-          generator = generator*l2[i][j];
-        }
-      l2Ideal[i] = generator;
-    }
+  {
+    sizIdeal = size(l2[i]);
+    generator = 1;
+    for (j = 1 ; j <= sizIdeal ; j ++)
+    {
+      generator = generator*l2[i][j];
+    }
+    l2Ideal[i] = generator;
+  }
   return (equal(l1Ideal,l2Ideal));
 }
@@ -670,6 +641,6 @@
 //-------------------------------------------------------------------------//
 /////////////////////////////////////////////////////////////////////////////
-//        
-proc isMonomial (ideal I)        
+//
+proc isMonomial (ideal I)
 "USAGE:    isMonomial (I); I ideal.
 RETURN:   1, if I is monomial ideal; 0, otherwise.
@@ -678,33 +649,26 @@
 "
 {
-  // Cambiamos de anillo
-  def R = basering;
-  int nvar = nvars(R);
-  string s = "ring R1 =",charstr(R),",x(1..nvar),dp;";
-  execute(s);        
+  // Si el ideal es cero, no es monomial.
+  if ( size(I) == 0)
+  {
+    return(0);
+  }
+  // Si ya viene dado por sistema de generadores monomiales, devolvemos 1
+  if (checkIdeal (I) == 1)
+  {
+    return(1);
+  }
   // Variables
   int resp,m,k;
   // Queremos la base de Grobner reducida, para uncidad.
-  ideal I = fetch(R,I);
-  option(redSB);        
-  // Si el ideal es cero, no es monomial.
-  if ( size(I) == 0)
-    {
-      return(0);
-    }
-  // Si ya viene dado por sistema de generadores monomiales, devolvemos 1
-  if (checkIdeal (I) == 1)
-    {
-      return(1);
-    }
+  intvec save_opt=option(get);
+  option(redSB);
   // Hallamos GB
   I = std(I);
+  option(set,save_opt);
   // Una vez que tenemos la GB, no es mas que comprobar si el ideal
   // esta generado por monomios.
   resp = checkIdeal(I);
   // Volvemos a dejar el comando "std" devolviendo una GB estandar.
-  option(noredSB);
-  setring R;
-  kill R1;
   return(resp);
 }
@@ -733,44 +697,44 @@
   int control = checkIdeal(I);
   if (control == 0)
-    {
-      return (-1);
-    }
+  {
+    return (-1);
+  }
   // Quitamos los ceros del sistema de generadores.
   I = simplify(I,2);
-  int sizI = size(I);
+  int sizI = ncols(I);
   for (i = 1 ; i <= sizI ; i++)
-    {
-      if (sizI > 1)
-        {
-          if (i == 1)
-            {
-              J = I[2..sizI];
-            }
-          else
-            {
-              if (i > 1 && i < sizI)
-                {
-                  J = I[1..i-1], I[i+1..sizI];
-                }
-              else
-                {
-                  if (i == sizI)
-                    {
-                      J = I[1..sizI-1];
-                    }
-                }
-            }
-          // Si quitamos el generador del lugar "i", luego el que
-          // ocupa ahora el lugar "i" es el "i+1", de ahi que restemos
-          // 1 al i para volver al for de manera que recorramos los
-          // generadores como debemos.        
-          if (membershipMon(I[i],J) == 1)
-            {
-              I = J;
-              i--;
-              sizI = size(I);
-            }
-        }
-    }
+  {
+    if (sizI > 1)
+    {
+      if (i == 1)
+      {
+        J = I[2..sizI];
+      }
+      else
+      {
+        if (i > 1 && i < sizI)
+        {
+          J = I[1..i-1], I[i+1..sizI];
+        }
+        else
+        {
+          if (i == sizI)
+          {
+            J = I[1..sizI-1];
+          }
+        }
+      }
+      // Si quitamos el generador del lugar "i", luego el que
+      // ocupa ahora el lugar "i" es el "i+1", de ahi que restemos
+      // 1 al i para volver al for de manera que recorramos los
+      // generadores como debemos.
+      if (membershipMon(I[i],J) == 1)
+      {
+        I = J;
+        i--;
+        sizI = ncols(I);
+      }
+    }
+  }
   return (I);
 }
@@ -841,26 +805,27 @@
     ERROR ("the input must be 2 monomials.");
   }
-  // Variables.
-  int k;
-  intvec exp;
-  int nvar = nvars(basering);
+  return(f*g/gcd(f,g));
+  //// Variables.
+  //int k;
+  //intvec exp;
+  //int nvar = nvars(basering);
 
-  // No tenemos mas que tomar el mayor exponente.
-  intvec expf = leadexp (f);
-  intvec expg = leadexp (g);
-        
-  for (k = 1 ; k <= nvar ; k ++)
-  {
-    if (expf[k] <= expg[k])
-    {
-      exp[k] = expg[k];
-    }
-    else
-    {
-       exp[k] = expf[k];
-    }
-  }
-  // Transformamos el vector de exponentes al monomio correspondiente.
-  return(monomial (exp));
+  //// No tenemos mas que tomar el mayor exponente.
+  //intvec expf = leadexp (f);
+  //intvec expg = leadexp (g);
+
+  //for (k = 1 ; k <= nvar ; k ++)
+  //{
+  //  if (expf[k] <= expg[k])
+  //  {
+  //    exp[k] = expg[k];
+  //  }
+  //  else
+  //  {
+  //     exp[k] = expf[k];
+  //  }
+  //}
+  //// Transformamos el vector de exponentes al monomio correspondiente.
+  //return(monomial (exp));
 }
 example
@@ -873,5 +838,5 @@
 //////////////////////////////////////////////////////////////////////
 //
-proc membershipMon(poly f,ideal I)        
+proc membershipMon(poly f,ideal I)
 "USAGE:    membershipMon(f,I); f polynomial, I ideal.
 RETURN:   1, if f lies in I; 0 otherwise.
@@ -881,5 +846,4 @@
 "
 {
-  def R = basering;
   // Variables
   int i,j,resp,k,control;
@@ -914,7 +878,7 @@
   // Quitamos ceros.
   I = simplify(I,2);
-  int n = size(I);
+  int n = ncols(I);
   int m = size(f);
-  int nvar = nvars(R);
+  int nvar = nvars(basering);
   for (i=1 ; i<=m ; i++)
   {
@@ -976,5 +940,5 @@
 //////////////////////////////////////////////////////////////////////
 //
-proc intersectMon (ideal I,ideal J)        
+proc intersectMon (ideal I,ideal J)
 "USAGE:    intersectMon (I,J); I,J ideals.
 RETURN:   an ideal, the intersection of I and J.
@@ -991,61 +955,61 @@
   // El ideal trivial no es monomial.
   if ( size(I) == 0 || size(J) == 0)
-    {
-      ERROR("one of the ideals is zero, hence not monomial.");
-    }
+  {
+    ERROR("one of the ideals is zero, hence not monomial.");
+  }
  // COMPROBACIONES
   control = checkIdeal(I);
   if (control == 0)
-    {
-      isMon = isMonomialGB(I);
-      if (isMon[1] == 0)
-        {
-          ERROR ("the first ideal is not monomial.");
-        }
-      else
-        {
-          // Sabemos que I ya viene dado por el sistema minimal de
-          // generadores, aunque aqui no sea necesario.
-          I = isMon[2];
-        }
-    }
+  {
+    isMon = isMonomialGB(I);
+    if (isMon[1] == 0)
+    {
+      ERROR ("the first ideal is not monomial.");
+    }
+    else
+    {
+      // Sabemos que I ya viene dado por el sistema minimal de
+      // generadores, aunque aqui no sea necesario.
+      I = isMon[2];
+    }
+  }
   else
-    {
-      // Los generadores son monomiales, hallamos el sistema minimal
-      I = minbase(I);
-    }
+  {
+    // Los generadores son monomiales, hallamos el sistema minimal
+    I = minbase(I);
+  }
   control = checkIdeal(J);
   if (control == 0)
-    {
-      isMon = isMonomialGB (J);
-      if (isMon[1] == 0)
-        {
-          ERROR ("the second ideal is not monomial.");
-        }
-      else
-        {
-          // Sabemos que J ya viene dado por el sistema minimal de
-          // generadores, aunque aqui no sea necesario.
-          J = isMon[2];
-        }
-    }
+  {
+    isMon = isMonomialGB (J);
+    if (isMon[1] == 0)
+    {
+      ERROR ("the second ideal is not monomial.");
+    }
+    else
+    {
+      // Sabemos que J ya viene dado por el sistema minimal de
+      // generadores, aunque aqui no sea necesario.
+      J = isMon[2];
+    }
+  }
   else
-    {
-      // Los generadores son monomiales,hallamos la base minimal
-      J = minbase(J);
-    }
+  {
+    // Los generadores son monomiales,hallamos la base minimal
+    J = minbase(J);
+  }
   // Hemos asegurado que los ideales sean monomiales.
   // Quitamos ceros de la base para no alargar calculos.
-  int n = size(I);
-  int m = size(J);
+  int n = ncols(I);
+  int m = ncols(J);
   // Hallamos el m.c.m.de cada par de generadores de uno y otro ideal
   // y los a?adimos al ideal interseccion.
   for (i=1 ; i<=n ; i++)
-    {
-      for (j=1 ; j<=m ; j++)
-        {
-          K = K , lcmMon (I[i],J[j]);
-        }
-    }
+  {
+    for (j=1 ; j<=m ; j++)
+    {
+      K = K , lcmMon (I[i],J[j]);
+    }
+  }
   // Devolvemos el ideal ya dado por la base minimal porque sabemos
   // que este procedimiento genera muchos generadores redundantes.
@@ -1061,5 +1025,5 @@
 //////////////////////////////////////////////////////////////////////
 //
-proc quotientMon (ideal I,ideal J)        
+proc quotientMon (ideal I,ideal J)
 "USAGE:    quotientMon (I,J); I,J ideals.
 RETURN:   an ideal, the quotient I:J.
@@ -1076,48 +1040,48 @@
   //COMPROBACIONES
   if (size(I) == 0 || size(J) == 0)
-    {
-      ERROR("one of the ideals is zero, hence not monomial.");
-    }
+  {
+    ERROR("one of the ideals is zero, hence not monomial.");
+  }
   control = checkIdeal(I);
   if (control == 0)
-    {
-      isMon = isMonomialGB (I);
-      if (isMon[1] == 0)
-        {
-          ERROR ("the first ideal is not monomial.");
-        }
-      else
-        {
-          // Sabemos que I ya viene dado por el sistema minimal de
-          // generadores, aunque aqui no sea necesario.
-          I = isMon[2];
-        }
-    }
+  {
+    isMon = isMonomialGB (I);
+    if (isMon[1] == 0)
+    {
+      ERROR ("the first ideal is not monomial.");
+    }
+    else
+    {
+      // Sabemos que I ya viene dado por el sistema minimal de
+      // generadores, aunque aqui no sea necesario.
+      I = isMon[2];
+    }
+  }
   else
-    {
-      // Los generadores son monomiales,hallamos sistema minimal
-      I = minbase(I);
-    }
+  {
+    // Los generadores son monomiales,hallamos sistema minimal
+    I = minbase(I);
+  }
   control = checkIdeal(J);
   if (control == 0)
-    {
-      isMon = isMonomialGB (J);
-      if (isMon[1] == 0)
-        {
-          ERROR ("the second ideal is not monomial.");
-          return (-1);
-        }
-      else
-        {
-          // Sabemos que J ya viene dado por el sistema minimal de
-          // generadores, aunque aqui no sea necesario.
-          J = isMon[2];
-        }
-    }
+  {
+    isMon = isMonomialGB (J);
+    if (isMon[1] == 0)
+    {
+      ERROR ("the second ideal is not monomial.");
+      return (-1);
+    }
+    else
+    {
+      // Sabemos que J ya viene dado por el sistema minimal de
+      // generadores, aunque aqui no sea necesario.
+      J = isMon[2];
+    }
+  }
   else
-    {
-      // Los generadores son monomiales, hallamos el sistema minimal
-      J = minbase(J);
-    }
+  {
+    // Los generadores son monomiales, hallamos el sistema minimal
+    J = minbase(J);
+  }
   // Tenemos los ideales dados por su sistema minimal (aunque no es necesario, ahorra
   // calculos. En K vamos a tener la interseccion de los ideales.
@@ -1126,9 +1090,9 @@
   // Los ideales estan dados por su sistema minimal, con lo que no aparecen ceros.
   // Luego podemos usar size(J).
-  n = size(J);
+  n = ncols(J);
   for (i = 1 ; i <= n ; i++)
-    {
-      K = intersect (K ,quotientIdealMon(I,J[i]));
-    }
+  {
+    K = intersect (K ,quotientIdealMon(I,J[i]));
+  }
   // Aqui tambien surgen muchos generadores que no forman parte de la
   // base minimal del ideal obtenido.
@@ -1154,8 +1118,5 @@
 {
   // Cambiamos de anillo
-  def R = basering;
-  int nvar = nvars(R);
-  string s = "ring R1 =",charstr(R),",x(1..nvar),dp;";
-  execute(s);
+  int nvar = nvars(basering);
   // Variables
   int i,m,j,control;
@@ -1163,5 +1124,4 @@
   intvec v;
   ideal rad_I;
-  ideal I = fetch(R,I);
   // COMPROBACIONES
   control = checkIdeal(I);
@@ -1169,43 +1129,40 @@
   // que comprobar si el ideal es monomial.
   if (control == 0)
-    {
-      list isMon = isMonomialGB (I);
-      if (isMon[1] == 0)
-        {
-          ERROR ("the ideal is not monomial.");
-        }
-      else
-        {
-          I = isMon[2];
-          // Ya lo tenemos con los generadores monomiales minimales
-        }
-    }
+  {
+    list isMon = isMonomialGB (I);
+    if (isMon[1] == 0)
+    {
+      ERROR ("the ideal is not monomial.");
+    }
+    else
+    {
+      I = isMon[2];
+      // Ya lo tenemos con los generadores monomiales minimales
+    }
+  }
   else
-    {
-      // Generadores monomiales, hallamos sistema minimal
-      I = minbase(I);
-    }
+  {
+    // Generadores monomiales, hallamos sistema minimal
+    I = minbase(I);
+  }
   // Ya tenemos el ideal generado por la BASE MINIMAL MONOMIAL
-  m = size(I);
+  m = ncols(I);
   // Solo hay que poner exponente 1 a todas las variables que tengan
   // exponente >1.
   for (i = 1 ; i <= m ; i++)
-    {
-      v = leadexp(I[i]);
-      f = 1;
-      for (j = 1 ; j <= nvar ; j++)
-        {
-          if (v[j] <> 0)
-            {
-              f = f*x(j);
-            }
-        }
-      rad_I = rad_I,f;
-    }
-  setring R;        
+  {
+    v = leadexp(I[i]);
+    f = 1;
+    for (j = 1 ; j <= nvar ; j++)
+    {
+      if (v[j] <> 0)
+      {
+        f = f*var(j);
+      }
+    }
+    rad_I = rad_I,f;
+  }
   // Hay que devolver el ideal dado por la base minimal, pues se
   // producen muchos generadores redundantes.
-  ideal rad_I = fetch(R1,rad_I);
-  kill R1;
   return( minbase (rad_I));
 }
@@ -1218,5 +1175,5 @@
 //////////////////////////////////////////////////////////////////////
 //
-proc isprimeMon (ideal I)        
+proc isprimeMon (ideal I)
 "USAGE:    isprimeMon (I); I ideal
 RETURN:   1, if I is prime; 0, otherwise.
@@ -1234,27 +1191,27 @@
   // que comprobar si el ideal es monomial.
   if (control == 0)
-    {
-      list isMon = isMonomialGB (I);
-      if (isMon[1] == 0)
-        {
-          ERROR ("the ideal is not monomial.");
-        }
-      else
-        {
-          I = isMon[2];
-          // Ya lo tenemos con los generadores minimales
-        }
-    }
+  {
+    list isMon = isMonomialGB (I);
+    if (isMon[1] == 0)
+    {
+      ERROR ("the ideal is not monomial.");
+    }
+    else
+    {
+      I = isMon[2];
+      // Ya lo tenemos con los generadores minimales
+    }
+  }
   else
-    {
-      // Generadores monomiales, hallamos el sistema minimal
-      I = minbase(I);
-    }
+  {
+    // Generadores monomiales, hallamos el sistema minimal
+    I = minbase(I);
+  }
   // Ya tenemos el ideal generado por la BASE MINIMAL
   if (maxdeg1(I) == 1)
-    {
-      return (1);
-    }
-  return (0);                
+  {
+    return (1);
+  }
+  return (0);
 }
 example
@@ -1268,5 +1225,5 @@
 //////////////////////////////////////////////////////////////////////
 //
-proc isprimaryMon (ideal I)        
+proc isprimaryMon (ideal I)
 "USAGE:    isprimaryMon (I); I ideal
 RETURN:   1, if I is primary; 0, otherwise.
@@ -1276,5 +1233,4 @@
 "
 {
-  def R = basering;
   // Variables
   int nvar,control,m,l,sub_in,i,j,k;
@@ -1285,21 +1241,21 @@
   // que comprobar si el ideal es monomial.
   if (control == 0)
-    {
-      list isMon = isMonomialGB (I);
-      if (isMon[1] == 0)
-        {
-          ERROR ("the ideal is not monomial.");
-        }
-      else
-        {
-          I = isMon[2];
-          // Ya lo tenemos con los generadores minimales
-        }
-    }
+  {
+    list isMon = isMonomialGB (I);
+    if (isMon[1] == 0)
+    {
+      ERROR ("the ideal is not monomial.");
+    }
+    else
+    {
+      I = isMon[2];
+      // Ya lo tenemos con los generadores minimales
+    }
+  }
   else
-    {
-      // Generadores monomiales, hallamos el sistema minimal
-      I = minbase(I);
-    }
+  {
+    // Generadores monomiales, hallamos el sistema minimal
+    I = minbase(I);
+  }
   // Ya tenemos el ideal generado por la BASE MINIMAL
   // Usamos la funcion "soporte" que hemos creado, para saber que
@@ -1307,6 +1263,6 @@
   // mismas y tambien cuales son los generadores del ideal donde
   // tenemos que comprobar si aparecen tales variables.
-  nvar = nvars(R);
-  m = size(I);
+  nvar = nvars(basering);
+  m = ncols(I);
   // Inicializo la ultima componente del vector para que contenga a
   // todas las variables (el subindice de la variable es el lugar
@@ -1317,18 +1273,18 @@
   // w = lugar de los generadores de I que son producto de mas de una variable.
   for (i = 1 ; i <= m ; i++)
-    {
-      sub_in = soporte(I[i]);
-      // Si soporte <> 0 la variable aparece sola, en caso contrario
-      // el generador es producto de mas de una variable
-      if (sub_in <> 0)
-        {
-          v[sub_in] = 1;
-        }
-      else
-        {
-          w[k] = i;
-          k++;
-        }
-    }
+  {
+    sub_in = soporte(I[i]);
+    // Si soporte <> 0 la variable aparece sola, en caso contrario
+    // el generador es producto de mas de una variable
+    if (sub_in <> 0)
+    {
+      v[sub_in] = 1;
+    }
+    else
+    {
+      w[k] = i;
+      k++;
+    }
+  }
   // Ahora solo hay que ver que no aparecen variables distintas de
   // las que tenemos marcadas con 1 en v.
@@ -1337,23 +1293,23 @@
   // son producto de una sola variable, luego es primario.
   if (l == 1 && w[1] == 0)
-    {
-      return(1);
-    }
+  {
+    return(1);
+  }
   // Estudiamos el exponente de los generadores de I oportunos (los
   // que nos indica w).
   for (i = 1 ; i <= l ; i++)
-    {
-      exp_gen = leadexp(I[w[i]]);
-      for (j = 1 ; j <= nvar ; j++)
-        {
-          if (v[j] == 0)
-            {
-              if (exp_gen[j] <> 0)
-                {
-                  return (0);
-                }
-            }
-        }
-    }
+  {
+    exp_gen = leadexp(I[w[i]]);
+    for (j = 1 ; j <= nvar ; j++)
+    {
+      if (v[j] == 0)
+      {
+        if (exp_gen[j] <> 0)
+        {
+          return (0);
+        }
+      }
+    }
+  }
   // Si hemos recorrido todo el ideal sin que salte el "for"
   // quiere decir que no se ha contradicho la caracterizacion,
@@ -1386,33 +1342,33 @@
   // que comprobar si el ideal es monomial.
   if (control == 0)
-    {
-      list isMon = isMonomialGB (I);
-      if (isMon[1] == 0)
-        {
-          ERROR ("the ideal is not monomial.");
-        }
-      else
-        {
-          I = isMon[2];
-          // Ya lo tenemos con los generadores minimales
-        }
-    }
+  {
+    list isMon = isMonomialGB (I);
+    if (isMon[1] == 0)
+    {
+      ERROR ("the ideal is not monomial.");
+    }
+    else
+    {
+      I = isMon[2];
+      // Ya lo tenemos con los generadores minimales
+    }
+  }
   else
-    {
-      // Generadores monomiales, hallamos sistema minimal
-      I = minbase(I);
-    }
+  {
+    // Generadores monomiales, hallamos sistema minimal
+    I = minbase(I);
+  }
   // Ya tenemos el ideal generado por la BASE MINIMAL
-  n = size(I);
+  n = ncols(I);
   // La funcion soporte devuelve 0 si el monomio es producto de mas
   // de una variable. Chequeamos generador a generador si el ideal
   // esta generado por potencias de variables.
   for (i = 1 ; i <= n ; i ++)
-    {
-      if (soporte(I[i]) == 0)
-        {
-          return(0);
-        }
-    }
+  {
+    if (soporte(I[i]) == 0)
+    {
+      return(0);
+    }
+  }
   return (1);
 }
@@ -1435,6 +1391,5 @@
 "
 {
-  def R = basering;
-  int  nvar  = nvars(R);
+  int  nvar  = nvars(basering);
   // Declaracion de variables
   int i,j,k,cont,sizI;
@@ -1445,23 +1400,23 @@
   // que comprobar si el ideal es monomial.
   if (control == 0)
-    {
-      list isMon = isMonomialGB (I);
-      if (isMon[1] == 0)
-        {
-          ERROR ("the ideal is not monomial.");
-        }
-      else
-        {
-          I = isMon[2];
-          // Ya lo tenemos con los generadores minimales
-        }
-    }
+  {
+    list isMon = isMonomialGB (I);
+    if (isMon[1] == 0)
+    {
+      ERROR ("the ideal is not monomial.");
+    }
+    else
+    {
+      I = isMon[2];
+      // Ya lo tenemos con los generadores minimales
+    }
+  }
   else
-    {
-      // Generadores monomiales, hallamos sistema minimal
-      I = minbase(I);
-    }
+  {
+    // Generadores monomiales, hallamos sistema minimal
+    I = minbase(I);
+  }
   // Ya tenemos el ideal generado por la BASE MINIMAL
-  sizI = size(I);
+  sizI = ncols(I);
   // Comprobamos que entre los generadores minimales aparece una
   // potencia de cada. Cuando encontramos un generador que es potencia
@@ -1469,18 +1424,18 @@
   cont = 0;
   for (i = 1 ; i <= sizI ; i++)
-    {
-      if (soporte(I[i]) <> 0)
-        {
-          cont ++;
-          // Solo volvemos a evaluar en caso de que hayamos aumentado
-          if (cont == nvar)
-            {
-              // Ya hemos encontrado que todas las variables aparrecen en
-              // el sistema minimal como potencia pura. No queremos seguir
-              // buscando
-              return (1);
-            }
-        }
-    }
+  {
+    if (soporte(I[i]) <> 0)
+    {
+      cont ++;
+      // Solo volvemos a evaluar en caso de que hayamos aumentado
+      if (cont == nvar)
+      {
+        // Ya hemos encontrado que todas las variables aparrecen en
+        // el sistema minimal como potencia pura. No queremos seguir
+        // buscando
+        return (1);
+      }
+    }
+  }
   // Si ha salido, es que faltan variables
   return(0);
@@ -1504,6 +1459,5 @@
 "
 {
-  def R = basering;
-  int nvar = nvars(R);
+  int nvar = nvars(basering);
   // Declaracion de variables
   int sizI,i,j,k;
@@ -1514,46 +1468,46 @@
   // que comprobar si el ideal es monomial.
   if (control == 0)
-    {
-      list isMon = isMonomialGB (I);
-      if (isMon[1] == 0)
-        {
-          ERROR ("the ideal is not monomial.");
-        }
-      else
-        {
-          I = isMon[2];
-          // Ya lo tenemos con los generadores minimales
-        }
-    }
+  {
+    list isMon = isMonomialGB (I);
+    if (isMon[1] == 0)
+    {
+      ERROR ("the ideal is not monomial.");
+    }
+    else
+    {
+      I = isMon[2];
+      // Ya lo tenemos con los generadores minimales
+    }
+  }
   else
-    {
-      // Generadores monomiales, hallamos sistema minimal
-      I = minbase(I);
-    }
+  {
+    // Generadores monomiales, hallamos sistema minimal
+    I = minbase(I);
+  }
   // Ya tenemos el ideal generado por la BASE MINIMAL
-  sizI = size(I);
+  sizI = ncols(I);
   // Creamos una lista que tenga los exponentes de todos los
   // generadores.
   for (i = 1 ; i <= sizI ; i++)
-    {
-      exp[i] = leadexp(I[i]);
-    }
+  {
+    exp[i] = leadexp(I[i]);
+  }
   // Ahora hay que ver si alguno se repite, y si uno de ellos
   // lo hace, ya no es gen?rico.
   for (i = 1 ; i <= nvar ; i++)
-    {
-      for (j = 1 ; j <= sizI-1 ; j++)
-        {
-          for (k = j+1 ; k <= sizI ; k++)
-            {
-              // Notar que no se pueden repetir si la variable realmente
-              // aparece en el generador, es decir, exponente >1.
-              if (exp[j][i] == exp[k][i] & exp[j][i] <> 0)
-                {
-                  return (0);
-                }
-            }
-        }
-    }
+  {
+    for (j = 1 ; j <= sizI-1 ; j++)
+    {
+      for (k = j+1 ; k <= sizI ; k++)
+      {
+        // Notar que no se pueden repetir si la variable realmente
+        // aparece en el generador, es decir, exponente >1.
+        if (exp[j][i] == exp[k][i] & exp[j][i] <> 0)
+        {
+          return (0);
+        }
+      }
+    }
+  }
   return (1);
 }
@@ -1577,91 +1531,91 @@
 "
 {
-  def R = basering;
-  int nvar = nvars(R);
+ // El ideal trivial no es monomial.
+  if ( size(I) == 0 )
+  {
+    ERROR("the ideal is zero, hence not monomial.");
+  }
   // VARIABLES
   int control,sizSum,sumandos,i,j,k,cont;
-  intvec index,indexAux,vaux,w;
-  list sum, sumAux;
-  // La base del ideal tiene que ser la monomial
- // El ideal trivial no es monomial.
-  if ( size(I) == 0 )
-    {
-      ERROR("the ideal is zero, hence not monomial.");
-    }
  // COMPROBACIONES
   control = checkIdeal(I);
   if (control == 0)
-    {
-      list isMon = isMonomialGB (I);
-      if (isMon[1] == 0)
-        {
-          ERROR ("the ideal is not monomial.");
-        }
-      else
-        {
-          // Sabemos que I ya viene dado por el sistema minimal de
-          // generadores, aunque aqui no sea necesario.
-          I = isMon[2];
-        }
-    }
-  // Si el ideal es artiniano, es 0-dimensional
-  if (isartinianMon(I) == 1)
-    {
-      return (0);
-    }
-  int sizI = size(I);
-  // v(i) = vector con sizI entradas y donde cada entrada "j" se corresponde
-  //        con el exponente del generador "i" en la variable "j"
-  for (i = 1 ; i <= nvar ; i++)
-    {
-      intvec v(i);
-      for (j = 1 ; j <= sizI ;j++ )
-        {
-          v(i)[j] = leadexp(I[j])[i];
-        }
-    }
-  // Vamos a guardar en el vector "index" la ultima variable que se ha
-  // sumado y en cada "sum(i)" el vector suma que se corresponde con la
-  // entrada "i" del vector index.
-  // Inicializo los valores de index y de cada sum
-  w[sizI] = 0;
-  sum[1] = w;
-  index[1] = 0;
-  sizSum = 1;
-  while ( 1 )
-    {
-      cont = 1;
-      sumandos ++;
-      for (i = 1 ; i <= sizSum ; i ++)
-        {
-          for (j = index[i] + 1 ; j <= nvar ; j ++)
-            {
-              w = sum[i];
-              vaux = w + v(j);
-              // Comprobamos
-              for (k = 1 ; k <= sizI ; k ++)
-                {
-                  if (vaux[k] == 0)
-                    {
-                      break;
-                    }
-                }
-              if (k == sizI +1)
-                {
-                  return (nvar - sumandos);
-                }
-              if (j <> nvar)
-                {
-                  sumAux[cont] = vaux;
-                  indexAux[cont] = j;
-                  cont ++;
-                }
-            }
-        
-        }
-      index = indexAux;
-      sum = sumAux;
-      sizSum = size(sumAux);
-    }
+  {
+    list isMon = isMonomialGB (I);
+    if (isMon[1] == 0)
+    {
+      ERROR ("the ideal is not monomial.");
+    }
+    else
+    {
+      // Sabemos que I ya viene dado por el sistema minimal de
+      // generadores, aunque aqui no sea necesario.
+      I = isMon[2];
+    }
+  }
+  attrib(I,"isSB",1);
+  return (dim(I));
+//  int nvar = nvars(basering);
+//  intvec index,indexAux,vaux,w;
+//  list sum, sumAux;
+//  // La base del ideal tiene que ser la monomial
+//  // Si el ideal es artiniano, es 0-dimensional
+//  if (isartinianMon(I) == 1)
+//  {
+//    return (0);
+//  }
+//  int sizI = ncols(I);
+//  // v(i) = vector con sizI entradas y donde cada entrada "j" se corresponde
+//  //        con el exponente del generador "i" en la variable "j"
+//  for (i = 1 ; i <= nvar ; i++)
+//  {
+//    intvec v(i);
+//    for (j = 1 ; j <= sizI ;j++ )
+//    {
+//      v(i)[j] = leadexp(I[j])[i];
+//    }
+//  }
+//  // Vamos a guardar en el vector "index" la ultima variable que se ha
+//  // sumado y en cada "sum(i)" el vector suma que se corresponde con la
+//  // entrada "i" del vector index.
+//  // Inicializo los valores de index y de cada sum
+//  w[sizI] = 0;
+//  sum[1] = w;
+//  index[1] = 0;
+//  sizSum = 1;
+//  while ( 1 )
+//  {
+//    cont = 1;
+//    sumandos ++;
+//    for (i = 1 ; i <= sizSum ; i ++)
+//    {
+//      for (j = index[i] + 1 ; j <= nvar ; j ++)
+//      {
+//        w = sum[i];
+//        vaux = w + v(j);
+//        // Comprobamos
+//        for (k = 1 ; k <= sizI ; k ++)
+//        {
+//          if (vaux[k] == 0)
+//          {
+//            break;
+//          }
+//        }
+//        if (k == sizI +1)
+//        {
+//          return (nvar - sumandos);
+//        }
+//        if (j <> nvar)
+//        {
+//          sumAux[cont] = vaux;
+//          indexAux[cont] = j;
+//          cont ++;
+//        }
+//      }
+//    }
+//    index = indexAux;
+//    sum = sumAux;
+//    sizSum = size(sumAux);
+//  }
 }
 example
@@ -1690,9 +1644,4 @@
 static proc irredDec1 (ideal I)
 {
-  // Cambiamos de anillo
-  def R = basering;
-  int nvar = nvars(R);
-  string s = "ring R1 =",charstr(R),",x(1..nvar),dp;";
-  execute(s);
   // Variables
   int i,j,n,resp;
@@ -1700,5 +1649,4 @@
   intvec exp,v;
   ideal J,K;
-  ideal I = fetch(R,I);
   // ----- DESCOMPOSICION IRREDUCIBLE
   // Inicializamos la lista que va a estar formada por los ideales
@@ -1707,57 +1655,54 @@
   l1 = I;
   while (size(l1) > 0)
-    {
-      for (i = 1 ; i <= size(l1) ; i++)
-        {
-          J = l1[i];
-          n = size(J);
-          l1 = delete(l1,i);
-          // Llamamos a la funcion que va a detectar si el ideal es o
-          // no irreducible, y en caso de no serlo sabemos sobre que
-          // generador y con que variables hay que aplicar el
-          // el resultado teorico.
-          v = irredAux (J);
-          // No irreducible
-          if (size(v) > 1)
-            {
-              // En este caso, v[1] nos indica el generador del ideal
-              // que debemos eliminar.
-              exp = leadexp(J[v[1]]);
-              if (v[1] == 1)
-                {
-                  J = J[2..n];
-                }
-              if (v[1] > 1 && v[1] < n)
-                {
-                  J = J[1..v[1]-1],J[v[1]+1..n];
-                }
-              if (v[1] == n)
-                {
-                  J = J[1..n-1];
-                }
-              // Ahora vamos a introducir los nuevos generadores en
-              // cada uno de los nuevos ideales que generamos. Los
-              // ponemos en la lista en la que comprobamos.
-              for (j = 1 ; j <= size(v)-1 ; j++)
-                {
-                  K = J,x(v[j+1])^exp[v[j+1]];
-                  l1 = insert(l1,minbase(K));
-                }
-            }
-          // Si v[1]=0, el ideal es irreducible y lo introducimos en
-          // la lista l2, que es la que finalmente devolvera las
-          // componentes de la descomposicion.
-          else
-            {
-              l2 = insert(l2,J);
-            }
-        }
-    }
+  {
+    for (i = 1 ; i <= size(l1) ; i++)
+    {
+      J = l1[i];
+      n = ncols(J);
+      l1 = delete(l1,i);
+      // Llamamos a la funcion que va a detectar si el ideal es o
+      // no irreducible, y en caso de no serlo sabemos sobre que
+      // generador y con que variables hay que aplicar el
+      // el resultado teorico.
+      v = irredAux (J);
+      // No irreducible
+      if (size(v) > 1)
+      {
+        // En este caso, v[1] nos indica el generador del ideal
+        // que debemos eliminar.
+        exp = leadexp(J[v[1]]);
+        if (v[1] == 1)
+        {
+          J = J[2..n];
+        }
+        if (v[1] > 1 && v[1] < n)
+        {
+          J = J[1..v[1]-1],J[v[1]+1..n];
+        }
+        if (v[1] == n)
+        {
+          J = J[1..n-1];
+        }
+        // Ahora vamos a introducir los nuevos generadores en
+        // cada uno de los nuevos ideales que generamos. Los
+        // ponemos en la lista en la que comprobamos.
+        for (j = 1 ; j <= size(v)-1 ; j++)
+        {
+          K = J,var(v[j+1])^exp[v[j+1]];
+          l1 = insert(l1,minbase(K));
+        }
+      }
+      // Si v[1]=0, el ideal es irreducible y lo introducimos en
+      // la lista l2, que es la que finalmente devolvera las
+      // componentes de la descomposicion.
+      else
+      {
+        l2 = insert(l2,J);
+      }
+    }
+  }
   // ---- IRREDUNDANTE
   l2 = irredundant (l2);
   // La salida es la lista de los ideales irreducibles.
-  setring R;
-  list l2 = fetch(R1,l2);
-  kill R1;
   return (l2);
 }
@@ -1767,5 +1712,6 @@
 //////////////////////////////////////////////////////////////////////
 //
-static proc primDec1 (ideal I)  {
+static proc primDec1 (ideal I)
+{
   // Variables
   list l1,l2;
@@ -1779,5 +1725,5 @@
 // METODO 2: Metodo directo para descomp. primaria (ver Vasconcelos)
 //
-//////////////////////////////////////////////////////////////////////        
+//////////////////////////////////////////////////////////////////////
 // La siguiente funcion va a calcular una descomposicion primaria   //
 // minimal de un ideal monomial, pero esta vez usando la            //
@@ -1786,10 +1732,6 @@
 //////////////////////////////////////////////////////////////////////
 //
-static proc primDec2 (ideal I)  {
-  // Cambiamos de anillo
-  def R = basering;
-  int nvar = nvars(R);
-  string s = "ring R1 =",charstr(R),",x(1..nvar),dp;";
-  execute(s);
+static proc primDec2 (ideal I)
+{
   // Variables en el nuevo anillo
   int i,n,max;
@@ -1797,5 +1739,4 @@
   intvec v;
   ideal J,K;
-  ideal I = fetch(R,I);
   // Vamos a tener dos listas: l1 que va a guardar todos los ideales
   // que vayamos generando con el resultado citado antes, que seran
@@ -1805,42 +1746,39 @@
   l1 = I;
   while (size(l1) > 0)
-    {
-      for (i = 1 ; i <= size(l1) ; i++)
-        {
-          J = l1[i];
-          n = size(J);
-          l1 = delete (l1,i);
-          // Usamos la funcion que hemos creado para saber si el ideal
-          // es primario. Si no lo es devuelve la variable que crea
-          // conflicto y los generadores del ideal que luego hay que
-          // usar (los que tienen productos de mas de una vble).
-          // Se le llama con el sistema minimal de generadores
-          v = primAux (J);
-          // En caso de no ser primario, hay que buscar el maximo
-          // exponente de la variable que aparece en los generadores
-          // del ideal multiplicada siempre por otras variables,
-          // nunca por si misma.
-          if (v[1] == 0)
-            {
-              max = maxExp(J,v);
-              K = J,x(v[2])^max;
-              l1 = insert (l1,minbase(K));
-              K = quotientIdealMon(J,x(v[2])^max);
-              // quotientidealMon devuelve sistema minimal de generadores
-              l1 = insert (l1,minbase(K));
-            }
-          // En caso de ser primario, lo introducimos en la lista
-          // conveniente.
-          else
-            {
-              l2 = insert (l2,J);
-            }
-        }
-    }
+  {
+    for (i = 1 ; i <= size(l1) ; i++)
+    {
+      J = l1[i];
+      n = ncols(J);
+      l1 = delete (l1,i);
+      // Usamos la funcion que hemos creado para saber si el ideal
+      // es primario. Si no lo es devuelve la variable que crea
+      // conflicto y los generadores del ideal que luego hay que
+      // usar (los que tienen productos de mas de una vble).
+      // Se le llama con el sistema minimal de generadores
+      v = primAux (J);
+      // En caso de no ser primario, hay que buscar el maximo
+      // exponente de la variable que aparece en los generadores
+      // del ideal multiplicada siempre por otras variables,
+      // nunca por si misma.
+      if (v[1] == 0)
+      {
+        max = maxExp(J,v);
+        K = J,var(v[2])^max;
+        l1 = insert (l1,minbase(K));
+        K = quotientIdealMon(J,var(v[2])^max);
+        // quotientidealMon devuelve sistema minimal de generadores
+        l1 = insert (l1,minbase(K));
+      }
+      // En caso de ser primario, lo introducimos en la lista
+      // conveniente.
+      else
+      {
+        l2 = insert (l2,J);
+      }
+    }
+  }
 // ------   IRREDUNDANTE
   l2 = irredundant (l2);
-  setring R;
-  list l2 = fetch (R1,l2);
-  kill R1;
   return (l2);
 }
@@ -1854,6 +1792,6 @@
 //////////////////////////////////////////////////////////////////////
 //
-static proc irredDec3 (ideal I)  {
-  def R = basering;
+static proc irredDec3 (ideal I)
+{
   int i,n,j;
   poly lcm;
@@ -1862,10 +1800,10 @@
   list l;
   // Hallamos el m.c.m. de los generadores minimales del ideal.
-  n = size (I);
+  n = ncols (I);
   lcm = I[1];
   for ( i = 2 ; i <= n ; i++ )
-    {
-      lcm = lcmMon (lcm,I[i]);
-    }
+  {
+    lcm = lcmMon (lcm,I[i]);
+  }
   v = leadexp (lcm);
   // Calculamos el dual de Alexander.
@@ -1889,5 +1827,6 @@
 //////////////////////////////////////////////////////////////////////
 //
-static proc primDec3 (ideal I)   {
+static proc primDec3 (ideal I)
+{
   // Variables
   list l1,l2;
@@ -1907,10 +1846,8 @@
 //////////////////////////////////////////////////////////////////////
 //
-static proc irredDec4 (ideal I)  {
+static proc irredDec4 (ideal I)
+{
   // Cambiamos de anillo.
-  def R = basering;
-  int nvar = nvars(R);
-  string s = "ring R1 =",charstr(R),",x(1..nvar),dp;";
-  execute(s);
+  int nvar = nvars(basering);
  // Variables
   int n,i,j,m,resp;
@@ -1919,12 +1856,11 @@
   ideal J,K;
   list L;
-  ideal I = fetch (R,I);
   // Calculamos el l.c.m. de los generadores minimales del ideal.
-  n = size (I);
+  n = ncols (I);
   lcm = I[1];
   for ( i = 2 ; i <= n ; i++ )
-    {
-      lcm = lcmMon (lcm,I[i]);
-    }
+  {
+    lcm = lcmMon (lcm,I[i]);
+  }
   v = leadexp (lcm);
   // Hallamos el ideal J = (x(1)^(l(1)+1),...,x(n)^(l(n)+1)). Como
@@ -1933,7 +1869,7 @@
   // el ideal J.
   for ( i = 1 ; i <= nvar ; i++ )
-    {
-      J[i] = (x(i))^(v[i]+1);
-    }
+  {
+    J[i] = (var(i))^(v[i]+1);
+  }
   // Ahora hacemos el cociente oportuno.
   K = minbase(quotient (J,I));
@@ -1941,13 +1877,13 @@
   // generadores de J. Los generadores que son divisibles los hacemos
   // cero y luego los eliminamos.
-  m = size (K);
+  m = ncols (K);
   for ( i = 1 ; i <= m ; i++ )
-    {
-      resp = membershipMon(K[i],J);
-      if ( resp == 1)
-        {
-          K[i] = 0;
-        }
-    }
+  {
+    resp = membershipMon(K[i],J);
+    if ( resp == 1)
+    {
+      K[i] = 0;
+    }
+  }
   K = simplify (K,2);
   // Ahora obtenemos las componentes de la descomposicion irreducible,
@@ -1956,7 +1892,4 @@
   // Volvemos al anillo de partida y devolvemos la lista de las
   // componentes irreducibles irredundantes.
-  setring R;
-  list L = fetch(R1,L);
-  kill R1;
   return (L);
 }
@@ -1967,5 +1900,6 @@
 //////////////////////////////////////////////////////////////////////
 //
-static proc primDec4 (ideal I) {
+static proc primDec4 (ideal I)
+{
   // Variables
   list l1,l2;
@@ -1987,10 +1921,5 @@
 static proc irredDec5 (ideal I)
 {
-  // New ring
-  def R = basering;
-  int nvar = nvars(R);
-  string s = "ring R1 =",charstr(R),",x(1..nvar),dp;";
-  execute(s);
-  ideal I = fetch (R,I);
+  int nvar = nvars(basering);
   //Variables
   int i,j;
@@ -1999,79 +1928,76 @@
   list artiniano = artinian (I);
   if (artiniano[1] == 0)
-    {
-      I = artiniano[2];
-      intvec elimina = artiniano[3];
-    }
+  {
+    I = artiniano[2];
+    intvec elimina = artiniano[3];
+  }
   // Quotient
-  ideal M = (x(1..nvar));
+  ideal M = maxideal(1);
   ideal J = quotient (I,M);
   // Deleting generators lying in I
-  for (i = 1 ; i <= size(J) ; i ++)
-    {
-      if (membershipMon(J[i],I) == 1)
-        {
-          if (i == 1)
-            {
-              J = J[2..size(J)];
-              i --;
-            }
-          else
-            {
-              if (i == size(J))
-                {
-                  J = J[1..size(J)-1];
-                  i --;
-                }
-              else
-                {
-                  J = J[1..i-1],J[i+1..size(J)];
-                  i --;
-                }
-            }
-        }
-    }
+  for (i = 1 ; i <= ncols(J) ; i ++)
+  {
+    if (membershipMon(J[i],I) == 1)
+    {
+      if (i == 1)
+      {
+        J = J[2..ncols(J)];
+        i --;
+      }
+      else
+      {
+        if (i == ncols(J))
+        {
+          J = J[1..i-1];
+          i --;
+        }
+        else
+        {
+          J = J[1..i-1],J[i+1..ncols(J)];
+          i --;
+        }
+      }
+    }
+  }
   // Exponents of the ideals are going to form the decomposition
-  int sizJ = size(J);
+  int sizJ = ncols(J);
   for (i = 1 ; i <= sizJ ; i ++ )
-    {
-      intvec exp(i) = leadexp(J[i]) + 1;
-    }
+  {
+    intvec exp(i) = leadexp(J[i]) + 1;
+  }
   // Deleting artinianization process
   if (artiniano[1] == 0)
-   {
-     // En elimina estan guardadas las variables que hay que eliminar
-     for (i = 1 ; i <= nvar ; i ++)
-       {
-         if (elimina[i] <> 0)
-           {
-             for (j = 1 ; j <= sizJ ; j ++)
-               {
-                 if (exp(j)[i] == elimina[i])
-                   {
-                     exp(j)[i] = 0;
-                   }
-               }
-           }
-       }
-   }
+  {
+    // En elimina estan guardadas las variables que hay que eliminar
+    for (i = 1 ; i <= nvar ; i ++)
+    {
+      if (elimina[i] <> 0)
+      {
+        for (j = 1 ; j <= sizJ ; j ++)
+        {
+          if (exp(j)[i] == elimina[i])
+          {
+            exp(j)[i] = 0;
+          }
+        }
+      }
+    }
+  }
   // En exp(i) tengo los exponentes de cada variable de las que aparecen
   // en cada ideal.
   list facets;
   for (i = 1 ; i <= sizJ ; i ++)
-    {
-      J = 0;
-      for (j = 1 ; j <= nvar ; j ++)
-        {
-          if (exp(i)[j] <> 0)
-            {
-              J = J,x(j)^exp(i)[j];
-            }
-        }
-      J = simplify(J,2);
-      facets[i] = J;
-    }
-  setring R;
-  list facets = fetch (R1,facets);
-  kill R1;
+  {
+    J = 0;
+    for (j = 1 ; j <= nvar ; j ++)
+    {
+      if (exp(i)[j] <> 0)
+      {
+        J = J,var(j)^exp(i)[j];
+      }
+    }
+    J = simplify(J,2);
+    facets[i] = J;
+  }
   return (facets);
 }
@@ -2082,5 +2008,6 @@
 //////////////////////////////////////////////////////////////////////
 //
-static proc primDec5 (ideal I) {
+static proc primDec5 (ideal I)
+{
   // Variables
   list l1,l2;
@@ -2108,14 +2035,14 @@
   int max,j,k,sizI;
   intvec exp;
-  sizI = size(I);
+  sizI = ncols(I);
   max = 0;
   for (j = 1 ; j <= sizI ; j ++)
-    {
-      exp = leadexp(I[j]);
-      if ( exp[i] > max)
-        {
-          max = exp[i];
-        }
-    }
+  {
+    exp = leadexp(I[j]);
+    if ( exp[i] > max)
+    {
+      max = exp[i];
+    }
+  }
   return(max);
 }
@@ -2130,8 +2057,5 @@
 {
   // Cambiamos de anillo
-  def R = basering;
-  int  nvar  = nvars(R);
-  string s = "ring R1 =",charstr(R),",x(1..nvar),dp;";
-  execute(s);
+  int  nvar  = nvars(basering);
   // Declaracion de variables
   int i,j,k,cont1,cont2,sizI,marcavar,max;
@@ -2139,82 +2063,77 @@
   list nuevo;
   ideal J;
-  ideal I = fetch(R,I);
-  sizI = size(I);
+  sizI = ncols(I);
   // Comprobamos que entre los generadores minimales aparece una
   // potencia de cada
   cont2 = 0;
   for (i = 1 ; i <= sizI ; i++)
-    {
-      v = leadexp(I[i]);
-      marcavar  = 0;
-      cont1 = 0;
-      for (j = 1 ; j <= nvar ; j++)
-        {
-          if (v[j] <> 0)
-            {
-              cont1 ++;
-              marcavar = j;
-            }
-        }
-      // Si cont1=1 hemos encontrado un generador de los que nos
-      // interesa."variablesin" guarda el indice de las que estan.
-      if (cont1 == 1)
-        {
-          cont2 ++;
-          variablesin[cont2] = marcavar;
-        }
-    }
+  {
+    v = leadexp(I[i]);
+    marcavar  = 0;
+    cont1 = 0;
+    for (j = 1 ; j <= nvar ; j++)
+    {
+      if (v[j] <> 0)
+      {
+        cont1 ++;
+        marcavar = j;
+      }
+    }
+    // Si cont1=1 hemos encontrado un generador de los que nos
+    // interesa."variablesin" guarda el indice de las que estan.
+    if (cont1 == 1)
+    {
+      cont2 ++;
+      variablesin[cont2] = marcavar;
+    }
+  }
   // Notar que como el sistema de generadores es minimal no se
   // va a repetir la potencia de la misma variable. Por tanto basta
   // comprobar si cont2 es o no nvar.
   if (cont2 == nvar)
-    {
-      setring R;
-      list output;
-      output[1] = 1;
-      return(output);
-    }
+  {
+    list output;
+    output[1] = 1;
+    return(output);
+  }
   else
-    {
-      J = I;
-      // Buscamos las que no estan
-      if (cont2 == 0)
-        {
-          for (i = 1 ; i <= nvar ; i ++)
-            {
-              max = maximoExp(I,i);
-              cambio[i] = max + 1;
-              J = J,x(i)^(max + 1);
-            }
-        }
-      else
-        {
-          for (i = 1 ; i <= nvar ; i++)
-            {
-              for (j = 1 ; j <= cont2 ; j ++)
-                {
-                  if (i == variablesin[j])
-                    {
-                      cambio[i] = 0;
-                      break;
-                    }
-                }
-              if (j == cont2 + 1)
-                {
-                  max = maximoExp(I,i);
-                  cambio[i] = max + 1;
-                  J = J,x(i)^(max + 1);
-                }
-            }
-        }
-      list output;
-      output[1] = 0;
-      output[2] = J;
-      output[3] = cambio;
-      setring R;
-      list output = fetch (R1,output);
-      kill R1;
-      return(output);
-    }
+  {
+    J = I;
+    // Buscamos las que no estan
+    if (cont2 == 0)
+    {
+      for (i = 1 ; i <= nvar ; i ++)
+      {
+        max = maximoExp(I,i);
+        cambio[i] = max + 1;
+        J = J,var(i)^(max + 1);
+      }
+    }
+    else
+    {
+      for (i = 1 ; i <= nvar ; i++)
+      {
+        for (j = 1 ; j <= cont2 ; j ++)
+        {
+          if (i == variablesin[j])
+          {
+            cambio[i] = 0;
+            break;
+          }
+        }
+        if (j == cont2 + 1)
+        {
+          max = maximoExp(I,i);
+          cambio[i] = max + 1;
+          J = J,var(i)^(max + 1);
+        }
+      }
+    }
+    list output;
+    output[1] = 0;
+    output[2] = J;
+    output[3] = cambio;
+    return(output);
+  }
 }
 //////////////////////////////////////////////////////////////////////
@@ -2227,19 +2146,15 @@
 {
   // New ring
-  def R = basering;
-  int nvar = nvars(R);
-   string s = "ring R1 =",charstr(R),",x(1..nvar),dp;";
-   execute(s);
-   ideal I = fetch(R,I);
+  int nvar = nvars(basering);
   // VARIABLES
   int i,j,k;
   // Cargamos la matriz con los exponentes
-  int sizI = size(I);
+  int sizI = ncols(I);
   intmat EXP[sizI][nvar];
   for (i = 1 ; i <= sizI ; i ++)
-    {
-      // Ordenamos el vector de exponentes oportuno
-      EXP[i,1..nvar] = leadexp(I[i]);
-    }
+  {
+    // Ordenamos el vector de exponentes oportuno
+    EXP[i,1..nvar] = leadexp(I[i]);
+  }
 
   // Ahora tenemos que ordenarla segun la variable que este en conficto.
@@ -2249,47 +2164,45 @@
   int count = 0;
   for (i = 1 ; i <= nvar ; i ++)
-    {
-      // Buscamos conflicto en la variable x(i), para ello tengo que ordenar
-      // la columna i de EXP
-      vari = EXP[1..sizI,i];
-      aux = sort(vari);
-      vari = aux[1];
-      change = aux[2];
-      for (j = 1 ; j <= sizI - 1 ; j ++)
-        {
-          if (vari[j] > 0)
-            {
-              while (NEWEXP[change[j + count] , i] >= vari[j + 1 + count])
-                {
-                  NEWEXP[change[j + 1 + count] , i] = NEWEXP[change[j + count] , i] + 1;
-                  count ++;
-                  if (j + 1 + count > sizI)
-                    {
-                      break;
-                    }
-                }
-            }
-          j = j + count;
-          count = 0;
-        }
-    }
-  setring R;
-  I = fetch(R1,I);
+  {
+    // Buscamos conflicto en la variable x(i), para ello tengo que ordenar
+    // la columna i de EXP
+    vari = EXP[1..sizI,i];
+    aux = sort(vari);
+    vari = aux[1];
+    change = aux[2];
+    for (j = 1 ; j <= sizI - 1 ; j ++)
+    {
+      if (vari[j] > 0)
+      {
+        while (NEWEXP[change[j + count] , i] >= vari[j + 1 + count])
+        {
+          NEWEXP[change[j + 1 + count] , i] = NEWEXP[change[j + count] , i] + 1;
+          count ++;
+          if (j + 1 + count > sizI)
+          {
+            break;
+          }
+        }
+      }
+      j = j + count;
+      count = 0;
+    }
+  }
   // Devolvemos tambien la matriz, pues aqui tengo la biyeccion entre los exponentes
   if (EXP == NEWEXP)
-    {
-      return (1,I);
-    }
+  {
+    return (1,I);
+  }
   else
-    {
-      // Hallamos el ideal con los nuevos exponentes
-      intvec expI;
-      for (i = 1 ; i <= sizI ; i ++)
-        {
-          expI = NEWEXP[i,1..nvar];
-          I[i] = monomial(expI);
-        }
-      return(0,I,EXP,NEWEXP);
-    }
+  {
+    // Hallamos el ideal con los nuevos exponentes
+    intvec expI;
+    for (i = 1 ; i <= sizI ; i ++)
+    {
+      expI = NEWEXP[i,1..nvar];
+      I[i] = monomial(expI);
+    }
+    return(0,I,EXP,NEWEXP);
+  }
 }
 //////////////////////////////////////////////////////////////////////
@@ -2301,6 +2214,5 @@
 static proc nonGeneric (EXP,NEWEXP,Faces,sizI)
 {
-  def R = basering;
-  int nvar = nvars(R);
+  int nvar = nvars(basering);
   int sizFaces = size(Faces);
   // Variables
@@ -2311,25 +2223,25 @@
   newFaces = Faces;
   for (i = 1 ; i <= nvar ; i ++)
-    {
-      // comparamos las matrices de exponentes por columnas
-      exp = EXP[1..sizI,i];
-      newexp = NEWEXP[1..sizI,i];
-      if (exp <> newexp)
-        {
-          for (j = 1 ; j <= sizI ; j ++)
+  {
+    // comparamos las matrices de exponentes por columnas
+    exp = EXP[1..sizI,i];
+    newexp = NEWEXP[1..sizI,i];
+    if (exp <> newexp)
+    {
+      for (j = 1 ; j <= sizI ; j ++)
+      {
+        if (exp[j] <> newexp[j])
+        {
+          for (k = 1 ; k <= sizFaces ; k ++)
+          {
+            if (Faces[k][i] == newexp[j])
             {
-              if (exp[j] <> newexp[j])
-                {
-                  for (k = 1 ; k <= sizFaces ; k ++)
-                    {
-                      if (Faces[k][i] == newexp[j])
-                        {
-                          newFaces[k][i] = exp[j];
-                        }
-                    }
-                }
+              newFaces[k][i] = exp[j];
             }
-        }
-    }
+          }
+        }
+      }
+    }
+  }
   return (newFaces);
 }
@@ -2344,18 +2256,13 @@
   // Cambiamos de anillo
   // Queremos usar x(1)..x(n) como variables.
-  def R = basering;
-  int nvar = nvars(R);
-  string s = "ring R1 =",charstr(R),",x(1..nvar),dp;";
-  execute(s);
+  int nvar = nvars(basering);
   // Declaracion de variables.
   int i,sizJ,j,max,aux,sizK,l, elim;
   intvec v;
   list face;
-  // Traemos al nuevo anillo el ideal de entrada.
-  ideal I = fetch(R,I);
   // Hacemos una copia de I pues ahora modificaremos el sistema
   // de generadores.
   ideal J = I;
-  sizJ = size(J);
+  sizJ = ncols(J);
   // Para cada variable buscamos el maximo exponente, teniendo en
   // cuenta que un mismo generador no puede dar dos exponentes.
@@ -2363,73 +2270,70 @@
   intvec expIni;
   for (i = 1 ; i <= nvar ; i++)
-    {
-      max = 0;
+  {
+    max = 0;
+    for (j = 1 ; j <= sizJ ; j++)
+    {
+      aux = leadexp(J[j])[i];
+      if (aux > max)
+      {
+        max = aux;
+        elim = j;
+      }
+    }
+    // Guardamos el exponente
+    expIni[i] = max;
+    // Ahora tenemos el maximo de la variable x(i), por lo que
+    // eliminamos el generador en el que la encontramos.
+    // Si queda un generador no hay nada que hacer
+    if (sizJ <> 1)
+    {
+      if (elim <> 1 & elim <> sizJ)
+      {
+        J = J[1..elim-1],J[elim+1..sizJ];
+      }
+      else
+      {
+        if (elim == 1)
+        {
+          J = J[2..sizJ];
+        }
+        else
+        {
+          J = J[1..sizJ-1];
+        }
+      }
+      sizJ = ncols(J);
+      // Eliminamos la variable x(i) en todos los generadores.
       for (j = 1 ; j <= sizJ ; j++)
-        {
-          aux = leadexp(J[j])[i];
-          if (aux > max)
-            {
-              max = aux;
-              elim = j;
-            }
-        }
-      // Guardamos el exponente
-      expIni[i] = max;
-      // Ahora tenemos el maximo de la variable x(i), por lo que
-      // eliminamos el generador en el que la encontramos.
-      // Si queda un generador no hay nada que hacer
-      if (sizJ <> 1)
-        {
-          if (elim <> 1 & elim <> sizJ)
-            {
-              J = J[1..elim-1],J[elim+1..sizJ];
-            }
-          else
-            {
-              if (elim == 1)
-                {
-                  J = J[2..sizJ];
-                }
-              else
-                {
-                  J = J[1..sizJ-1];
-                }
-            }
-          sizJ = size(J);
-          // Eliminamos la variable x(i) en todos los generadores.
-          for (j = 1 ; j <= sizJ ; j++)
-            {
-              v = leadexp(J[j]);
-              if (v [i] <> 0)
-                {
-                  v[i] = 0;
-                  J[j] = monomial(v);
-                }
-            }
-          // Hallamos el sistema minimal de generadores que
-          // corresponde al ideal que nos ha quedado.
-          J = minbase(J);
-          sizJ = size(J);
-        }
-    }
+      {
+        v = leadexp(J[j]);
+        if (v [i] <> 0)
+        {
+          v[i] = 0;
+          J[j] = monomial(v);
+        }
+      }
+      // Hallamos el sistema minimal de generadores que
+      // corresponde al ideal que nos ha quedado.
+      J = minbase(J);
+      sizJ = ncols(J);
+    }
+  }
   // En expIni tenemos los exponentes de los monomios que dan la cara
   // inicial, ahora hay que buscar en el ideal original a que
   // generador se corresponde (el ideal es generico)
-  int sizI = size(I);
+  int sizI = ncols(I);
   for (i = 1 ; i <= nvar ; i ++)
-    {
-      for (j = 1 ; j <= sizI ; j ++)
-        {
-          if (expIni[i] == leadexp(I[j])[i])
-            {
-              face = insert(face, I[j]);
-              // Si lo encontramos buscamos el siguiente
-              break;
-            }
-        }
-    }
-  setring R;
-  list face = fetch (R1,face);
-  kill R1;
+  {
+    for (j = 1 ; j <= sizI ; j ++)
+    {
+      if (expIni[i] == leadexp(I[j])[i])
+      {
+        face = insert(face, I[j]);
+        // Si lo encontramos buscamos el siguiente
+        break;
+      }
+    }
+  }
   return (face);
 }
@@ -2443,8 +2347,5 @@
   // Cambiamos de anillo
   // Queremos usar x(1)..x(n) como variables.
-  def R = basering;
-  int nvar = nvars(R);
-  string s = "ring R1 =",charstr(R),",x(1..nvar),dp;";
-  execute(s);
+  int nvar = nvars(basering);
   // Declaracion de variables.
   int i,j,cambio,sizI,k,min,m,generador,max;
@@ -2452,46 +2353,43 @@
   poly LCM,newLCM;
   intvec v,newv,expgen;
-  // Traemos al nuevo anillo las dos entradas.
-  list l1 = fetch(R,l1);
-  ideal I = fetch(R,I);
-  sizI = size(I);
+  sizI = ncols(I);
   // Hallamos el lcm de los elementos, e. d., la faceta del
   // complejo para luego comparar con los nuevos
   LCM = 1;
   for (i = 1 ; i <= nvar ; i++)
-    {
-      LCM = lcmMon(LCM,l1[i]);
-    }
+  {
+    LCM = lcmMon(LCM,l1[i]);
+  }
   v = leadexp(LCM);
   // Calculo los exponentes de los monomios de I
   for (i = 1 ; i <= sizI ; i++)
-    {
-      expI[i] = leadexp(I[i]);
-    }
+  {
+    expI[i] = leadexp(I[i]);
+  }
   // Hay que quitar cada elemento de la lista y comprobar si hay o no
   // cara adyacente al simplice que queda, y en caso de haberla, la
   // calculamos.
   for (i = 1 ; i <= nvar ; i++)
-    {
-      newl1 = delete(l1,i);
-      // Hallamos el lcm de los elementos que hay en la nueva lista.
-      newLCM = 1;
-      for (j = 1 ; j <= nvar - 1 ; j++)
-        {
-          newLCM = lcmMon(newLCM,newl1[j]);
-        }
-      // Ahora hay que detectar si alguna variable ha desaparecido
-      // en este LCM.
-      newv = leadexp(newLCM);
-      for (j = 1 ; j <= nvar ; j++)
-        {
-          if (newv[j] == 0)
-            {
-              l2[i] = 0;
-              break;
-            }
-        }
-      if (j == nvar+1)
-        {
+  {
+    newl1 = delete(l1,i);
+    // Hallamos el lcm de los elementos que hay en la nueva lista.
+    newLCM = 1;
+    for (j = 1 ; j <= nvar - 1 ; j++)
+    {
+      newLCM = lcmMon(newLCM,newl1[j]);
+    }
+    // Ahora hay que detectar si alguna variable ha desaparecido
+    // en este LCM.
+    newv = leadexp(newLCM);
+    for (j = 1 ; j <= nvar ; j++)
+    {
+      if (newv[j] == 0)
+      {
+        l2[i] = 0;
+        break;
+      }
+    }
+    if (j == nvar+1)
+    {
       // Si no ha habido ceros, queremos hallar la cara adyacente,
       // es decir, buscar un generador que introducido en l1 de una
@@ -2499,110 +2397,107 @@
       // Comparamos los lcm entre s?, para comprobar en que variable
       // contribu?a el monomio que hemos eliminado.
-          for (j = 1 ; j <= nvar ; j++)
+      for (j = 1 ; j <= nvar ; j++)
+      {
+        if (v[j] <> newv[j])
+        {
+          cambio = j;
+          // Una vez encontrado no hay mas
+          break;
+        }
+      }
+      // Hallamos los exponentes de los monomios que quedan
+      // para ver cual da el exponente en "newv"
+      for (j = 1 ; j <= nvar - 1 ; j++)
+      {
+        w[j] = leadexp(newl1[j]);
+      }
+      for (j = 1 ; j <= nvar ; j++)
+      {
+        for (k = 1 ; k <= nvar - 1 ; k++)
+        {
+          if (newv[cambio] == w[k][cambio])
+          {
+            cambio = k;
+            break;
+          }
+        }
+        // Si no termino el for con k es que hemos encontrado ya
+        // los que son iguales.
+        if (k <> nvar)
+        {
+          break;
+        }
+      }
+
+      // Donde contribuye antes, e.d., en "v"
+      for (j = 1 ; j <= nvar ; j++)
+      {
+        if (w[cambio][j] == v[j])
+        {
+          cambio = j;
+          break;
+        }
+      }
+      // Ahora ya buscamos entre los generadores el nuevo monomio.
+      // Ponemos de tope para encontrar el minimo el maximo de
+      // las variables en el ideal
+      max = 0;
+      for (m = 1 ; m <= sizI ; m ++)
+      {
+        if (expI[m][cambio] > max)
+        {
+          max = expI[m][cambio];
+        }
+      }
+      min = max;
+      for (j = 1 ; j <= sizI ; j++)
+      {
+        for (k = 1 ; k <= nvar ; k ++)
+        {
+          if (I[j] == l1[k])
+          {
+            break;
+          }
+        }
+        // El generador no esta en la lista, es de los que hay que
+        // comprobar
+        if (k == nvar +1)
+        {
+          for (m = 1 ; m <= nvar ; m++)
+          {
+            if (m <> cambio)
             {
-              if (v[j] <> newv[j])
-                {
-                  cambio = j;
-                  // Una vez encontrado no hay mas
-                  break;
-                }
+              if (expI[j][m] > newv[m])
+              {
+                break;
+              }
             }
-          // Hallamos los exponentes de los monomios que quedan
-          // para ver cual da el exponente en "newv"
-          for (j = 1 ; j <= nvar - 1 ; j++)
+            else
             {
-              w[j] = leadexp(newl1[j]);
+              if (expI[j][m] <= newv[m])
+              {
+                break;
+              }
             }
-          for (j = 1 ; j <= nvar ; j++)
+          }
+          // Si termina el bucle cumple las condiciones
+          // oportunas, solo hay que comparar con el
+          // otro que tengamos.
+          if (m == nvar + 1)
+          {
+            if (expI[j][cambio] <=  min)
             {
-              for (k = 1 ; k <= nvar - 1 ; k++)
-                {
-                  if (newv[cambio] == w[k][cambio])
-                  {
-                    cambio = k;
-                    break;
-                  }
-                }
-              // Si no termino el for con k es que hemos encontrado ya
-              // los que son iguales.
-              if (k <> nvar)
-                {
-                  break;
-                }
+              min = expI[j][cambio];
+              generador = j;
             }
-        
-          // Donde contribuye antes, e.d., en "v"
-          for (j = 1 ; j <= nvar ; j++)
-            {
-              if (w[cambio][j] == v[j])
-                {
-                  cambio = j;
-                  break;
-                }
-            }
-          // Ahora ya buscamos entre los generadores el nuevo monomio.
-          // Ponemos de tope para encontrar el minimo el maximo de
-          // las variables en el ideal
-          max = 0;
-          for (m = 1 ; m <= sizI ; m ++)
-            {
-              if (expI[m][cambio] > max)
-                {
-                  max = expI[m][cambio];
-                }
-            }
-          min = max;        
-          for (j = 1 ; j <= sizI ; j++)
-            {
-              for (k = 1 ; k <= nvar ; k ++)
-                {
-                  if (I[j] == l1[k])
-                    {
-                      break;
-                    }
-                }
-              // El generador no esta en la lista, es de los que hay que
-              // comprobar
-              if (k == nvar +1)
-                {
-                  for (m = 1 ; m <= nvar ; m++)
-                    {
-                      if (m <> cambio)
-                        {
-                          if (expI[j][m] > newv[m])
-                            {
-                              break;
-                            }
-                        }
-                      else
-                        {
-                          if (expI[j][m] <= newv[m])
-                            {
-                              break;
-                            }
-                        }
-                    }
-                  // Si termina el bucle cumple las condiciones
-                  // oportunas, solo hay que comparar con el
-                  // otro que tengamos.
-                  if (m == nvar + 1)
-                    {
-                      if (expI[j][cambio] <=  min)
-                        {
-                          min = expI[j][cambio];
-                          generador = j;
-                        }
-                    }
-                }
-            }
-          // En la lista ponemos en el lugar "i" el generador que
-          // hay que introducir cuando eliminamos el generador
-          // "i" de la lista de entrada.
-          l2[i] = I[generador];
-        }
-    }
-  setring R;
-  list l2 = fetch(R1,l2);
-  kill R1;
+          }
+        }
+      }
+      // En la lista ponemos en el lugar "i" el generador que
+      // hay que introducir cuando eliminamos el generador
+      // "i" de la lista de entrada.
+      l2[i] = I[generador];
+    }
+  }
   return(l2);
 }
@@ -2616,10 +2511,7 @@
   // Cambiamos de anillo
   // Queremos usar x(1)..x(n) como variables.
-  def R = basering;
-  int nvar = nvars(R);
+  int nvar = nvars(basering);
   // Sabemos que dp siempre es mejor para trabajar, auqque luego para
   // comparar I y genI vamos a cambiarlo al lexicografico.
-  string s = "ring R1 =",charstr(R),",x(1..nvar),dp;";
-  execute(s);
   // Variables
   int i,j,k,sizl1,sizl,cont1,cont2;
@@ -2629,5 +2521,4 @@
   intvec v,w,betas;
   ideal J,genI,artgenI;
-  ideal I = fetch(R,I);
   // Comprobamos si el ideal es generico y artiniano, y, en caso de
   // no serlo, obtenemos una modificacion de este ideal que si
@@ -2635,20 +2526,20 @@
   list genericlist = generic(I);
   if (genericlist[1] == 0)
-    {
-      genI = genericlist[2];
-    }
+  {
+    genI = genericlist[2];
+  }
   else
-    {
-      genI = I;
-    }
+  {
+    genI = I;
+  }
   list artinianization = artinian (genI);
   if (artinianization[1] == 0)
-    {
-      artgenI = artinianization[2];
-    }
+  {
+    artgenI = artinianization[2];
+  }
   else
-    {
-      artgenI = genI;
-    }
+  {
+    artgenI = genI;
+  }
   // Una vez tenemos el ideal artiniano y generico, podemos hallar
   // el complejo de Scarf asociado al ideal modificado
@@ -2663,8 +2554,8 @@
   LCM = 1;
   for (i = 1 ; i <= nvar ; i++)
-    {
-      mon = initial[i];
-      LCM = lcmMon(LCM,mon);
-    }
+  {
+    mon = initial[i];
+    LCM = lcmMon(LCM,mon);
+  }
   v = leadexp(LCM);
   // Guardamos la primera faceta
@@ -2677,65 +2568,65 @@
   // Ahora hayamos las posibles caras maximales adyacentes
   while (sizl <> 0)
-    {
-      // Hallamos la lista de monomios que hay que introducir
-      // cuando eliminamos cada monomio.
-      auxl = adyacency(l[1],artgenI);
-      cont1 = 1;
-      cont2 = 0;
-      l1 = 0;
+  {
+    // Hallamos la lista de monomios que hay que introducir
+    // cuando eliminamos cada monomio.
+    auxl = adyacency(l[1],artgenI);
+    cont1 = 1;
+    cont2 = 0;
+    l1 = 0;
+    for (j = 1 ; j <= nvar ; j++)
+    {
+      if (auxl[j] <> 0)
+      {
+        l2 = delete(l[1],j);
+        l1[cont1] = insert(l2,auxl[j],cont1 + cont2 - 1);
+        cont1 ++;
+      }
+      else
+      {
+        cont2 ++;
+      }
+    }
+    // Hallamos los nuevos LCM
+    sizl1 = size(l1);
+    for (i = 1 ; i <= sizl1 ; i++)
+    {
+      newLCM[i] = 1;
       for (j = 1 ; j <= nvar ; j++)
       {
-        if (auxl[j] <> 0)
-          {
-            l2 = delete(l[1],j);
-            l1[cont1] = insert(l2,auxl[j],cont1 + cont2 - 1);
-            cont1 ++;
-          }
-        else
-          {
-            cont2 ++;
-          }
-      }
-      // Hallamos los nuevos LCM
-      sizl1 = size(l1);
-      for (i = 1 ; i <= sizl1 ; i++)
-        {
-          newLCM[i] = 1;
-         for (j = 1 ; j <= nvar ; j++)
-           {
-             newLCM[i] = lcmMon(newLCM[i],l1[i][j]);
-           }
-         expl1[i] = leadexp(newLCM[i]);
-        }
-      // Hallamos los LCM de las nuevas caras y eliminamos las que
-      // ya esten en la lista Faces
-      cont1 = 0;
-      cont2 = 0;
-      for (i = 1 ; i <= sizl1 ; i++)
-        {
-          for (j = 1 ; j <= sizfaces ; j++)
-            {
-              v = expl1[i];
-              w = Faces[j];
-              if (v == w)
-                {
-                  // Si ya esta el LCM en la lista, no queremos
-                  // seguir buscando
-                  break;
-                }
-            }
-          // Si no ha salido del bucle en "j" es que este LCM
-          // no esta en la lista de las caras, la introducimos
-          if (j == sizfaces + 1)
-            {
-              Faces = insert(Faces,expl1[i],sizfaces + cont1);
-              l = insert(l,l1[i]);
-              cont1 ++;
-            }
-        }
-      l = delete(l,cont1 + 1);
-      sizl = size(l);
-      sizfaces = size(Faces);
-    }
+        newLCM[i] = lcmMon(newLCM[i],l1[i][j]);
+      }
+      expl1[i] = leadexp(newLCM[i]);
+    }
+    // Hallamos los LCM de las nuevas caras y eliminamos las que
+    // ya esten en la lista Faces
+    cont1 = 0;
+    cont2 = 0;
+    for (i = 1 ; i <= sizl1 ; i++)
+    {
+      for (j = 1 ; j <= sizfaces ; j++)
+      {
+        v = expl1[i];
+        w = Faces[j];
+        if (v == w)
+        {
+          // Si ya esta el LCM en la lista, no queremos
+          // seguir buscando
+          break;
+        }
+      }
+      // Si no ha salido del bucle en "j" es que este LCM
+      // no esta en la lista de las caras, la introducimos
+      if (j == sizfaces + 1)
+      {
+        Faces = insert(Faces,expl1[i],sizfaces + cont1);
+        l = insert(l,l1[i]);
+        cont1 ++;
+      }
+    }
+    l = delete(l,cont1 + 1);
+    sizl = size(l);
+    sizfaces = size(Faces);
+  }
   // En "Faces" ya tengo los exponentes que luego seran los exponentes
   // de los ideales que forman la descomposicion.
@@ -2743,53 +2634,50 @@
   intvec elimin = artinianization[3];
   if (artinianization[1] == 0)
-   {
-     // En elimina tenemos las variables que hemos introducido
-     // y cual es la potencia
-     // Solo miro las que tengan cambio
-     for (i = 1 ; i <= nvar ; i ++)
-       {
-         if (elimin[i] <> 0)
-           {
-             for (j = 1 ; j <= sizfaces ; j ++)
-               {
-                 if (Faces[j][i] == elimin[i])
-                   {
-                     Faces[j][i] = 0;
-                   }
-               }
-           }
-       }
-   }
+  {
+    // En elimina tenemos las variables que hemos introducido
+    // y cual es la potencia
+    // Solo miro las que tengan cambio
+    for (i = 1 ; i <= nvar ; i ++)
+    {
+      if (elimin[i] <> 0)
+      {
+        for (j = 1 ; j <= sizfaces ; j ++)
+        {
+          if (Faces[j][i] == elimin[i])
+          {
+            Faces[j][i] = 0;
+          }
+        }
+      }
+    }
+  }
   // Generico
   sizI = size(I);
   if (genericlist[1] == 0)
-    {
-      Faces = nonGeneric(genericlist[3],genericlist[4],Faces,sizI);
-    }
+  {
+    Faces = nonGeneric(genericlist[3],genericlist[4],Faces,sizI);
+  }
   // Ya tenemos en Faces los exponentes de las componentes
   // ahora solo hay que obtener los ideales.
- for (i = 1 ; i <= sizfaces ; i ++)
-    {
-      J = 0;
-      for (j = 1 ; j <= nvar ; j ++)
-        {
-          if (Faces[i][j] <> 0)
-            {
-              J = J,x(j)^(Faces[i][j]);
-            }
-        }
-      J = simplify(J,2);
-      Faces[i] = J;
-    }
- // Esta es la parte LENTA computacionalmente si el ideal de partida
- // no es generico
- if (genericlist[1] == 0)
-   {
-     Faces = irredundant(Faces);
-   }
- setring R;
- list components = fetch(R1,Faces);
- kill R1;
- return(components);
+  for (i = 1 ; i <= sizfaces ; i ++)
+  {
+    J = 0;
+    for (j = 1 ; j <= nvar ; j ++)
+    {
+      if (Faces[i][j] <> 0)
+      {
+        J = J,var(j)^(Faces[i][j]);
+      }
+    }
+    J = simplify(J,2);
+    Faces[i] = J;
+  }
+  // Esta es la parte LENTA computacionalmente si el ideal de partida
+  // no es generico
+  if (genericlist[1] == 0)
+  {
+    Faces = irredundant(Faces);
+  }
+  return(Faces);
 }
 //////////////////////////////////////////////////////////////////////
@@ -2821,8 +2709,5 @@
 {
   // Cambiamos de anillo
-  def R = basering;
-  int nvar = nvars(R);
-  string s = "ring R1 =",charstr(R),",x(1..nvar),dp;";
-  execute(s);
+  int nvar = nvars(basering);
   // Variables
   int sizF,i,j;
@@ -2830,5 +2715,4 @@
   list listphi;
   intvec exp,newexp;
-  list F = fetch(R,F);
   // F es una lista de pares, que indica una x(i) etiqueta de una
   // cara del ideal. Suponemos que F tiene ordenados sus elementos
@@ -2836,21 +2720,18 @@
   sizF = size(F);
   for (i = 1 ; i <= sizF ; i ++)
-    {
-      f = F[i];
-      exp = leadexp(f);
-      for (j = 1 ; j <= nvar ; j ++)
-        {
-          if (j <> i)
-            {
-              exp[j] = exp[j] + 1;
-            }
-        }
-      listphi[i] = monomial(exp);
-    }
+  {
+    f = F[i];
+    exp = leadexp(f);
+    for (j = 1 ; j <= nvar ; j ++)
+    {
+      if (j <> i)
+      {
+        exp[j] = exp[j] + 1;
+      }
+    }
+    listphi[i] = monomial(exp);
+  }
   // Ya tenemos la lista de los monomios a los que
   // luego haremos el "lcm"
-  setring R;
-  list listphi = fetch (R1,listphi);
-  kill R1;
   return (listphi);
 }
@@ -2860,23 +2741,16 @@
 {
  // Cambiamos de anillo
-  def R = basering;
-  int nvar = nvars(R);
-  string s = "ring R1 =",charstr(R),",x(1..nvar),dp;";
-  execute(s);
+  int nvar = nvars(basering);
   int i,sizI;
   intvec exp;
-  poly f = fetch (R,f);
   exp = leadexp(f);
-  for (i = 1 ; i <= nvar  ; i ++)
-    {
-      if (exp[i] <> 0)
-        {
-          exp[i] = exp[i] - 1;
-        }
-    }
+  for (i = nvar ; i > 0  ; i --)
+  {
+    if (exp[i] <> 0)
+    {
+      exp[i] = exp[i] - 1;
+    }
+  }
   f = monomial(exp);
-  setring R;
-  f = fetch (R1,f);
-  kill R1;
   return (f);
 }
@@ -2885,6 +2759,5 @@
 static proc conditionComplex (intvec posActual,ideal I,ideal S)
 {
-  def R = basering;
-  int nvar = nvars(R);
+  int nvar = nvars(basering);
   // VARIABLES
   int i,nuevo;
@@ -2893,49 +2766,49 @@
   // ultimo dentro de posActual que es distinto de 0.
   for (i = 1 ; i <= nvar ; i ++)
-    {
-      if (posActual[i] == 0)
-        {
-          break ;
-        }
-    }
+  {
+    if (posActual[i] == 0)
+    {
+      break;
+    }
+  }
   nuevo = i - 1;
   // No se pueden repetir generadores, se mira que el ultimo que se ha
- // ha introducido no sea de los que ya tenemos
+  // ha introducido no sea de los que ya tenemos
   for (i = 1 ; i <= nuevo - 1 ; i ++)
-    {
-      if (posActual[i] == posActual[nuevo])
-        {
-          return (0);
-        }
-    }
+  {
+    if (posActual[i] == posActual[nuevo])
+    {
+      return (0);
+    }
+  }
   // Vemos si la variable oportuna divide al generador
   if (leadexp(I[i]) == 0)
-    {
-      return (0);
-    }
+  {
+    return (0);
+  }
   // Caso de que el LCM sea multiplo de los que ya tenemos
   poly LCM = 1;
   for (i = 1 ; i <= nuevo ; i ++)
-    {
-      F = insert (F,I[posActual[i]],size(F));
-    }
+  {
+    F = insert (F,I[posActual[i]],size(F));
+  }
   list phiF = phi(F);
   for (i = 1 ; i <= nuevo ; i ++)
-    {
-      LCM = lcmMon(phiF[i],LCM);
-    }
+  {
+    LCM = lcmMon(phiF[i],LCM);
+  }
   // Comprobamos si ya tenemos algun divisor del actual
   if (membershipMon(LCM,S) == 1)
-    {
-      return (0);
-    }
+  {
+    return (0);
+  }
   // Ahora vemos si la lista esta en el complejo simplicial
   if (membershipMon(LCM,I) == 1)
-    {
-      if (membershipMon(pi(LCM),I) == 0)
-        {
-          return (1,LCM);
-        }
-    }
+  {
+    if (membershipMon(pi(LCM),I) == 0)
+    {
+      return (1,LCM);
+    }
+  }
   return (0);
 }
@@ -2944,6 +2817,5 @@
 static proc findFaces (ideal I)
 {
-  def R = basering;
-  int nvar = nvars(R);
+  int nvar = nvars(basering);
   // Variables
   int i;
@@ -2956,40 +2828,40 @@
 
   int variable = 1;
-  int sizI = size(I);
+  int sizI = ncols(I);
   while (1)
-    {
-      while (posActual[variable] == sizI)
-        {
-          posActual[variable] = 0;
-          variable --;
-          if (variable == 0)
-            {
-              break;
-            }
-        }
-      // Comprobamos si hemos recorrido todas las posibilidades. Si
-      // es as?, terminamos el while
+  {
+    while (posActual[variable] == sizI)
+    {
+      posActual[variable] = 0;
+      variable --;
       if (variable == 0)
-        {
-          break;
-        }
-      posActual[variable] = posActual[variable] + 1;
-      // Comprobamos las condiciones para saber si los generadores que
-      // tenemos est?n o no en el complejo.
-      condiciones = conditionComplex (posActual,I,S);
+      {
+        break;
+      }
+    }
+    // Comprobamos si hemos recorrido todas las posibilidades. Si
+    // es as?, terminamos el while
+    if (variable == 0)
+    {
+      break;
+    }
+    posActual[variable] = posActual[variable] + 1;
+    // Comprobamos las condiciones para saber si los generadores que
+    // tenemos est?n o no en el complejo.
+    condiciones = conditionComplex (posActual,I,S);
 
-      if (condiciones[1] == 1 )
-        {
-          if (posActual[nvar] <> 0)
-            {
-              S = S,condiciones[2];
-              F = insert (F,condiciones[2]);
-            }
-          if (variable < nvar)
-            {
-              variable ++;
-            }
-        }
-    }
+    if (condiciones[1] == 1 )
+    {
+      if (posActual[nvar] <> 0)
+      {
+        S = S,condiciones[2];
+        F = insert (F,condiciones[2]);
+      }
+      if (variable < nvar)
+      {
+        variable ++;
+      }
+    }
+  }
   return (F);
 }
@@ -3002,9 +2874,5 @@
 static proc labelAlgorithm(ideal I)
 {
-  def R = basering;
-  int nvar = nvars(R);
-  string s = "ring R1 =",charstr(R),",x(1..nvar),dp;";
-  execute(s);
-  ideal I = fetch(R,I);
+  int nvar = nvars(basering);
 
   // Variables
@@ -3016,12 +2884,12 @@
   list artiniano = artinian (I);
   if (artiniano[1] == 0)
-    {
-      artI = artiniano[2];
-      intvec elimina = artiniano[3];
-    }
+  {
+    artI = artiniano[2];
+    intvec elimina = artiniano[3];
+  }
   else
-    {
-      artI = I;
-    }
+  {
+    artI = I;
+  }
   // Llamamos a findFaces para que encuentre las caras maximales del
   // complejo asociado al ideal
@@ -3031,28 +2899,28 @@
   poly f;
   for (i = 1 ; i <= sizComponents ; i ++)
-    {
-      f = components[i];
-      expComponents[i] = leadexp(f);
-    }
+  {
+    f = components[i];
+    expComponents[i] = leadexp(f);
+  }
   // Deshacemos la artinianizacion
   if (artiniano[1] == 0)
-   {
-     // En elimina tenemos las variables que hemos introducido
-     // y cual es la potencia
-     // Solo miro las que tengan cambio
-     for (i = 1 ; i <= nvar ; i ++)
-       {
-         if (elimina[i] <> 0)
-           {
-             for (j = 1 ; j <= sizComponents ; j ++)
-               {
-                 if (expComponents[j][i] == elimina[i])
-                   {
-                     expComponents[j][i] = 0;
-                   }
-               }
-           }
-       }
-   }
+  {
+    // En elimina tenemos las variables que hemos introducido
+    // y cual es la potencia
+    // Solo miro las que tengan cambio
+    for (i = 1 ; i <= nvar ; i ++)
+    {
+      if (elimina[i] <> 0)
+      {
+        for (j = 1 ; j <= sizComponents ; j ++)
+        {
+          if (expComponents[j][i] == elimina[i])
+          {
+            expComponents[j][i] = 0;
+          }
+        }
+      }
+    }
+  }
   // En exp(i) tengo los exponentes de cada variable de las que aparecen
   // en cada ideal.
@@ -3060,19 +2928,16 @@
   list facets;
   for (i = 1 ; i <= sizComponents ; i ++)
-    {
-      J = 0;
-      for (j = 1 ; j <= nvar ; j ++)
-        {
-          if (expComponents[i][j] <> 0)
-            {
-              J = J,x(j)^expComponents[i][j];
-            }
-        }
-      J = simplify(J,2);
-      facets[i] = J;
-    }
-  setring R;
-  list facets = fetch (R1,facets);
-  kill R1;
+  {
+    J = 0;
+    for (j = 1 ; j <= nvar ; j ++)
+    {
+      if (expComponents[i][j] <> 0)
+      {
+        J = J,var(j)^expComponents[i][j];
+      }
+    }
+    J = simplify(J,2);
+    facets[i] = J;
+  }
   return (facets);
 }
@@ -3100,25 +2965,24 @@
 static proc divide (intvec v, intvec w, int k)
 {
-  def R = basering;
-  int nvar = nvars(R);
+  int nvar = nvars(basering);
   // Variables
   int i;
-  for (i = 1 ; i <= nvar ; i ++)
-    {
-      if (i == k)
-        {
-          if (v[i] <> w[i])
-            {
-              return (0);
-            }
-        }
-      else
-        {
-          if (v[i] >= w[i])
-            {
-              return (0);
-            }
-        }
-    }
+  for (i = nvar ; i > 0 ; i --)
+  {
+    if (i == k)
+    {
+      if (v[i] <> w[i])
+      {
+        return (0);
+      }
+    }
+    else
+    {
+      if (v[i] >= w[i])
+      {
+        return (0);
+      }
+    }
+  }
   return (1);
 }
@@ -3129,9 +2993,5 @@
 static proc incrementalAlg (ideal I)
 {
-  def R = basering;
-  int nvar = nvars(R);
-  string s = "ring R1 =",charstr(R),",x(1..nvar),dp;";
-  execute(s);
-  ideal I = fetch(R,I);
+  int nvar = nvars(basering);
   // COMPROBACIONES
   // Variables
@@ -3143,13 +3003,13 @@
   ideal artI;
   if (artiniano[1] == 0)
-    {
-      artI = artiniano[2];
-      elimina = artiniano[3];
-    }
+  {
+    artI = artiniano[2];
+    elimina = artiniano[3];
+  }
   else
-    {
-      artI = I;
-      elimina[nvar] = 0;
-    }
+  {
+    artI = I;
+    elimina[nvar] = 0;
+  }
   // Buscamos la primera componente irreducible o, lo que es lo
   // mismo, aquellos generadores que son potencia de una variable.
@@ -3158,55 +3018,55 @@
   // ideal.
   list MinI,componentes;
-  int sizartI = size(artI);
+  int sizartI = ncols(artI);
   int sizelimina = size(elimina);
   for (i = 1 ; i <= nvar ; i ++)
-    {
-      if (elimina[i] == 0)
-        {
-          // Buscamos en el ideal los generadores que nos interesan
-          for (j = 1 ; j <= sizartI ; j ++)
+  {
+    if (elimina[i] == 0)
+    {
+      // Buscamos en el ideal los generadores que nos interesan
+      for (j = 1 ; j <= sizartI ; j ++)
+      {
+        sop = soporte(artI[j]);
+        if (sop <> 0)
+        {
+          beta[sop] = leadexp(artI[j])[sop];
+          MinI = insert(MinI,leadexp(artI[j]));
+          if (j <> 1 and j <> sizartI)
+          {
+            artI = artI[1..j - 1],artI[j + 1..sizartI];
+          }
+          else
+          {
+            if (j == 1)
             {
-              sop = soporte(artI[j]);
-              if (sop <> 0)
-                {
-                  beta[sop] = leadexp(artI[j])[sop];
-                  MinI = insert(MinI,leadexp(artI[j]));
-                  if (j <> 1 and j <> sizartI)
-                    {
-                      artI = artI[1..j - 1],artI[j + 1..sizartI];
-                    }
-                  else
-                    {
-                      if (j == 1)
-                        {
-                          artI = artI[2..sizartI];
-                        }
-                      else
-                        {
-                          artI = artI[1..sizartI - 1];
-                        }
-                    }
-                  sizartI = size(artI);
-                  break;
-                }
+              artI = artI[2..sizartI];
             }
-        }
-      else
-        {
-          // Buscamos la que esta al final
-          sop = soporte(artI[sizartI]);
-          beta[sop] = leadexp(artI[sizartI])[sop];
-          MinI = insert(MinI,leadexp(artI[sizartI]));
-          if (sizartI <> 1)
+            else
             {
               artI = artI[1..sizartI - 1];
             }
-          else
-            {
-              artI = artI[1];
-            }
-          sizartI = size(artI);
-        }
-    }
+          }
+          sizartI = ncols(artI);
+          break;
+        }
+      }
+    }
+    else
+    {
+      // Buscamos la que esta al final
+      sop = soporte(artI[sizartI]);
+      beta[sop] = leadexp(artI[sizartI])[sop];
+      MinI = insert(MinI,leadexp(artI[sizartI]));
+      if (sizartI <> 1)
+      {
+        artI = artI[1..sizartI - 1];
+      }
+      else
+      {
+        artI = artI[1];
+      }
+      sizartI = ncols(artI);
+    }
+  }
   // En beta tenemos la primera componente
   componentes = insert(componentes,beta);
@@ -3219,105 +3079,105 @@
   intvec expartI;
   for(i = 1 ; i <= sizartI ; i ++)
-    {
-      expartI = leadexp(artI[1]);
-      if (size(artI) <> 1)
-        {
-          artI = artI[2..size(artI)];
-        }
-      // Hay que distinguir T_1 y T_2. Para ello se comparar vectores
-      // de la lista actual de generadores con el que se acaba de
-      // introducir.
-      cont2 = 0;
-      for (j = 1 ; j <= sizcomponents ; j ++)
-        {
-          beta = componentes[1 + cont2];
-          // Si el nuevo generador divide a la componente beta, hay
-          // que buscar las nuevas componentes
-          for (k = 1 ; k <= nvar ; k ++)
+  {
+    expartI = leadexp(artI[1]);
+    if (size(artI) <> 1)
+    {
+      artI = artI[2..size(artI)];
+    }
+    // Hay que distinguir T_1 y T_2. Para ello se comparar vectores
+    // de la lista actual de generadores con el que se acaba de
+    // introducir.
+    cont2 = 0;
+    for (j = 1 ; j <= sizcomponents ; j ++)
+    {
+      beta = componentes[1 + cont2];
+      // Si el nuevo generador divide a la componente beta, hay
+      // que buscar las nuevas componentes
+      for (k = 1 ; k <= nvar ; k ++)
+      {
+        if (expartI[k] >= beta[k])
+        {
+          break;
+        }
+      }
+      // Si el bucle anterior termino, divide y hay que hacer
+      // los cambios.
+      if (k == nvar + 1)
+      {
+        componentes = delete (componentes,1 + cont2);
+        // Buscamos las nuevas componentes calculando las
+        // distancias. Para cada variable busco d(beta,k,l)
+        for (k = 1 ; k <= nvar ; k ++)
+        {
+          betaaux = beta;
+          max = -1;
+          cont = 0;
+          dbeta = 0;
+          for (l = 1 ; l <= nvar ; l ++)
+          {
+            if (l <> k)
             {
-              if (expartI[k] >= beta[k])
+              min = 32767;
+              cont ++;
+              for (m = 1 ; m <= sizMin ; m ++)
+              {
+                // Estos son de los buenos
+                if (divide(MinI[m],beta,l) == 1)
                 {
-                  break;
+                  if (MinI[m][k] < min)
+                  {
+                    min = MinI[m][k];
+                  }
                 }
+              }
+              dbeta[cont] = min;
             }
-          // Si el bucle anterior termino, divide y hay que hacer
-          // los cambios.
-          if (k == nvar + 1)
+          }
+          // Aqui ya tenemos d(beta,k,l) para cada k
+          // Hallamos el maximo cuando terminemos
+          for (l = 1 ; l <= cont ; l ++)
+          {
+            if (dbeta[l] > max)
             {
-              componentes = delete (componentes,1 + cont2);
-              // Buscamos las nuevas componentes calculando las
-              // distancias. Para cada variable busco d(beta,k,l)
-              for (k = 1 ; k <= nvar ; k ++)
-                {
-                  betaaux = beta;
-                  max = -1;
-                  cont = 0;
-                  dbeta = 0;
-                  for (l = 1 ; l <= nvar ; l ++)
-                    {
-                      if (l <> k)
-                        {
-                          min = 32767;
-                          cont ++;
-                          for (m = 1 ; m <= sizMin ; m ++)
-                            {
-                              // Estos son de los buenos
-                              if (divide(MinI[m],beta,l) == 1)
-                                {
-                                  if (MinI[m][k] < min)
-                                    {
-                                      min = MinI[m][k];
-                                    }
-                                }
-                            }
-                          dbeta[cont] = min;
-                        }
-                    }        
-                  // Aqui ya tenemos d(beta,k,l) para cada k
-                  // Hallamos el maximo cuando terminemos
-                  for (l = 1 ; l <= cont ; l ++)
-                    {
-                      if (dbeta[l] > max)
-                        {
-                          max = dbeta[l];
-                        }
-                    }
-                  // Condicion para introducir nueva componente
-                  if (max < expartI[k])
-                    {
-                      betaaux[k] = expartI[k];
-                      componentes = insert(componentes,betaaux,size(componentes));
-                    }
-                }
+              max = dbeta[l];
             }
-          else
-            {
-              cont2 ++;
-            }
-        }
-      MinI = insert(MinI,expartI);
-      sizMin = size(MinI);
-      sizcomponents = size(componentes);
-    }
+          }
+          // Condicion para introducir nueva componente
+          if (max < expartI[k])
+          {
+            betaaux[k] = expartI[k];
+            componentes = insert(componentes,betaaux,size(componentes));
+          }
+        }
+      }
+      else
+      {
+        cont2 ++;
+      }
+    }
+    MinI = insert(MinI,expartI);
+    sizMin = size(MinI);
+    sizcomponents = size(componentes);
+  }
   // Deahacer los cambios de artiniano si se han hecho
   if (artiniano[1] == 0)
-   {
-     // En elimina tenemos las variables que hemos introducido
-     // y cual es la potencia
-     // Solo miro las que tengan cambio
-     for (i = 1 ; i <= nvar ; i ++)
-       {
-         if (elimina[i] <> 0)
-           {
-             for (j = 1 ; j <= sizcomponents ; j ++)
-               {
-                 if (componentes[j][i] == elimina[i])
-                   {
-                     componentes[j][i] = 0;
-                   }
-               }
-           }
-       }
-   }
+  {
+    // En elimina tenemos las variables que hemos introducido
+    // y cual es la potencia
+    // Solo miro las que tengan cambio
+    for (i = 1 ; i <= nvar ; i ++)
+    {
+      if (elimina[i] <> 0)
+      {
+        for (j = 1 ; j <= sizcomponents ; j ++)
+        {
+          if (componentes[j][i] == elimina[i])
+          {
+            componentes[j][i] = 0;
+          }
+        }
+      }
+    }
+  }
   // En exp(i) tengo los exponentes de cada variable de las que aparecen
   // en cada ideal.
@@ -3325,19 +3185,16 @@
   list facets;
   for (i = 1 ; i <= sizcomponents ; i ++)
-    {
-      J = 0;
-      for (j = 1 ; j <= nvar ; j ++)
-        {
-          if (componentes[i][j] <> 0)
-            {
-              J = J,x(j)^componentes[i][j];
-            }
-        }
-      J = simplify(J,2);
-      facets[i] = J;
-    }
-  setring R;
-  list facets = fetch (R1,facets);
-  kill R1;
+  {
+    J = 0;
+    for (j = 1 ; j <= nvar ; j ++)
+    {
+      if (componentes[i][j] <> 0)
+      {
+        J = J,var(j)^componentes[i][j];
+      }
+    }
+    J = simplify(J,2);
+    facets[i] = J;
+  }
   return (facets);
 }
@@ -3364,16 +3221,16 @@
 static proc divideMon (poly f , poly g)
 {
-  def R = basering;
-  int nvar = nvars(R);
-  intvec expf = leadexp(f);
-  intvec expg = leadexp(g);
-  for (int i = 1 ; i <= nvar ; i ++)
-    {
-      if (expf[i] > expg[i])
-        {
-          return (0);
-        }
-    }
-  return (1);
+  return (lead(g)/lead(f)!=0);
+  //int nvar = nvars(basering);
+  //intvec expf = leadexp(f);
+  //intvec expg = leadexp(g);
+  //for (int i = 1 ; i <= nvar ; i ++)
+  //{
+  //  if (expf[i] > expg[i])
+  //  {
+  //    return (0);
+  //  }
+  //}
+  //return (1);
 }
 //////////////////////////////////////////////////////////////////////
@@ -3382,9 +3239,6 @@
 {
   // I is monomial ideal
-  def R = basering;
-  I = fetch (R,I);
-  S = fetch(R,S);
-  int sizI = size(I);
-  int nvar = nvars(R);
+  int sizI = ncols(I);
+  int nvar = nvars(basering);
   intvec explcmMin = leadexp(lcmMin);
   // Variables
@@ -3395,52 +3249,52 @@
   intvec xiexp;
   for (i = 1 ; i <= nvar ; i ++)
-    {
-      if (explcmMin[i] >= 2 )
-        {
-          // Median exponent of x(i) from intersection(minI,x(i))
-          cont = 0;
-          for (j = 1 ; j <= sizI ; j ++)
-            {
-              exp = leadexp(I[j])[i];
-              if (exp > 0)
-                {
-                  cont ++;
-                  xiexp[cont] = exp;
-                }
-            }
-          xiexp = sort(xiexp)[1];
-          sizxi = size(xiexp);
-          if (size(xiexp) == 1)
-            {
-              median = xiexp[1] - 1;
-            }
-          else
-            {
-              if (size(xiexp) == 2)
-                {
-                  median = xiexp[2] - 1;
-                }
-              else
-                {
-                  median = xiexp[(size(xiexp) + 1) / 2];
-                }
-            }
-          p = x(i)^median;
-          // valid pivot??
-          if ( membershipMon(p,S) == 0)
-            {
-              return(p);
-            }
-          else
-            {
-              max = maximoExp(S,i);
-              if ( xiexp[sizxi] == max )
-                {
-                  return(x(i)^(max-1));
-                }
-            }
-          xiexp = 0;
-        }
-    }
+  {
+    if (explcmMin[i] >= 2 )
+    {
+      // Median exponent of x(i) from intersection(minI,x(i))
+      cont = 0;
+      for (j = 1 ; j <= sizI ; j ++)
+      {
+        exp = leadexp(I[j])[i];
+        if (exp > 0)
+        {
+          cont ++;
+          xiexp[cont] = exp;
+        }
+      }
+      xiexp = sort(xiexp)[1];
+      sizxi = size(xiexp);
+      if (size(xiexp) == 1)
+      {
+        median = xiexp[1] - 1;
+      }
+      else
+      {
+        if (size(xiexp) == 2)
+        {
+          median = xiexp[2] - 1;
+        }
+        else
+        {
+          median = xiexp[(size(xiexp) + 1) / 2];
+        }
+      }
+      p = var(i)^median;
+      // valid pivot??
+      if ( membershipMon(p,S) == 0)
+      {
+        return(p);
+      }
+      else
+      {
+        max = maximoExp(S,i);
+        if ( xiexp[sizxi] == max )
+        {
+          return(var(i)^(max-1));
+        }
+      }
+      xiexp = 0;
+    }
+  }
 }
 //////////////////////////////////////////////////////////////////////
@@ -3451,13 +3305,11 @@
   int i, j, k, cont, numdeleted;
   intvec isMaximal;
-  def R = basering;
-  I = fetch(R,I);
-  int sizI = size(I);
-  int nvar = nvars(R);
+  int sizI = ncols(I);
+  int nvar = nvars(basering);
   poly lcmMinI = 1;
   for (i = 1 ; i <= sizI ; i ++)
-    {
-      lcmMinI = lcmMon(I[i],lcmMinI);
-    }
+  {
+    lcmMinI = lcmMon(I[i],lcmMinI);
+  }
   intvec explcmMinI = leadexp(lcmMinI);
   // Buscamos los elementos que son x(i) maximales. En caso de que
@@ -3466,55 +3318,54 @@
   isMaximal[sizI] = 0;
   intvec genexp;
-   for (i = 1 ; i <= sizI ; i ++)
-    {
-      genexp = leadexp(I[i]);
-      cont = 0;
-      for ( j = 1 ; j <= nvar ; j ++)
-        {
-          if (genexp[j] <> 0 && genexp[j] == explcmMinI[j])
+  for (i = 1 ; i <= sizI ; i ++)
+  {
+    genexp = leadexp(I[i]);
+    cont = 0;
+    for ( j = 1 ; j <= nvar ; j ++)
+    {
+      if (genexp[j] <> 0 && genexp[j] == explcmMinI[j])
+      {
+        if (cont == 0)
+        {
+          cont ++;
+          isMaximal[i] = j;
+        }
+        else
+        {
+          // Porque cuando encontramos que era maximal para
+          // la primera variable, lo guardamos
+          isMaximal[i] = 0;
+          // Eliminamos del ideal
+          if (i <> 1 && i <> sizI)
+          {
+            I = I[1..i - 1],I[i + 1..sizI];
+          }
+          else
+          {
+            if (i == 1)
             {
-        
-              if (cont == 0)
-                {
-                  cont ++;
-                  isMaximal[i] = j;
-                }
-              else
-                {
-                  // Porque cuando encontramos que era maximal para
-                  // la primera variable, lo guardamos
-                  isMaximal[i] = 0;
-                  // Eliminamos del ideal
-                  if (i <> 1 && i <> sizI)
-                    {
-                      I = I[1..i - 1],I[i + 1..sizI];
-                    }
-                  else
-                    {
-                      if (i == 1)
-                        {
-                          I = I[2..sizI];
-                        }
-                      else
-                        {
-                          I = I[1..sizI - 1];
-                        }
-                    }
-                  i --;
-                  sizI = size(I);
-                  // Generador i eliminado, miramos el siguiente
-                  break;
-                }
+              I = I[2..sizI];
             }
-        }
-    }
+            else
+            {
+              I = I[1..sizI - 1];
+            }
+          }
+          i --;
+          sizI = ncols(I);
+          // Generador i eliminado, miramos el siguiente
+          break;
+        }
+      }
+    }
+  }
    // En isMaximal[i] tenemos 0 si I[i] no es maximal,
-   // y j si I[i] es maximal en x(j).                                        
+   // y j si I[i] es maximal en x(j).
   // Matriz de exponentes de los generadores del ideal
   intmat expI[sizI][nvar];
   for (i = 1 ; i <= sizI ; i++)
-    {
-      expI[i,1..nvar] = leadexp(I[i]);
-    }
+  {
+    expI[i,1..nvar] = leadexp(I[i]);
+  }
   // Buscamos ahora cota inferior
   poly lcmMi = 1;
@@ -3522,46 +3373,46 @@
   intvec Mi, mincol,expgcd;
   for (i = 1 ; i <= nvar ; i ++)
-    {
-      Mi = 0;
-      cont = 0;
-      for (j = 1 ; j <= sizI ; j ++)
-        {
-          // De isMaximal solo se usan las entradas que se corresponden con elementos del ideal
-          if (expI[j,i] <> 0)
-            {
-              if (isMaximal[j] == 0 or isMaximal[j] == i)
-                {
-                  // Elementos del sistema minimal que estan
-                  // en Mi
-                  cont ++;
-                  Mi[cont] = j;
-                }
-            }
-        }
-      // Si solo hay un elemento en Mi, no hay nada que hacer
-      if (cont > 1)
-        {
-          gcdMi = I[Mi[1]];
-          // Tenemos los generadores a los que hay que hallar el gcd
-          for (j = 2; j <= cont ; j ++)
-            {
-              gcdMi = gcdMon(gcdMi,I[Mi[j]]);
-            }
-        }
+  {
+    Mi = 0;
+    cont = 0;
+    for (j = 1 ; j <= sizI ; j ++)
+    {
+      // De isMaximal solo se usan las entradas que se corresponden con elementos del ideal
+      if (expI[j,i] <> 0)
+      {
+        if (isMaximal[j] == 0 or isMaximal[j] == i)
+        {
+          // Elementos del sistema minimal que estan
+          // en Mi
+          cont ++;
+          Mi[cont] = j;
+        }
+      }
+    }
+    // Si solo hay un elemento en Mi, no hay nada que hacer
+    if (cont > 1)
+    {
+      gcdMi = I[Mi[1]];
+      // Tenemos los generadores a los que hay que hallar el gcd
+      for (j = 2; j <= cont ; j ++)
+      {
+        gcdMi = gcd(gcdMi,I[Mi[j]]);
+      }
+    }
+    else
+    {
+      if (Mi <> 0)
+      {
+        gcdMi = I[Mi[1]];
+      }
       else
-        {
-          if (Mi <> 0)
-            {
-              gcdMi = I[Mi[1]];
-            }
-          else
-            {
-              // Falta alguna variable
-              return (0,I);
-            }
-        }
-      l = gcdMi/x(i);
-      lcmMi = lcmMon(lcmMi,l);
-    }
+      {
+        // Falta alguna variable
+        return (0,I);
+      }
+    }
+    l = gcdMi/var(i);
+    lcmMi = lcmMon(lcmMi,l);
+  }
   // Ahora devolvemos la cota inferior, que luego hay que multiplicar
   // por el monomio que define el corte.
@@ -3573,107 +3424,103 @@
 static proc con (ideal I , ideal S , poly q)
 {
-  def R = basering;
-  int nvar = nvars(R);
-  I = fetch(R,I);
-  S = fetch(R,S);
-  q = fetch(R,q);
+  int nvar = nvars(basering);
   // Variables
   int i;
   poly piI;
-  int sizI = size(I);
+  int sizI = ncols(I);
   // Simplification process
   poly p;
   list sol;
   while (1)
-    {
-      // (I,S,q) normal slice?
-      // Como cada vez que introducimos una cota inferior sabemos
-      // que la slice actual es la inner slice (la otra es vacio),
-      // hay que volver a verificar si es normal
-      if ( S <> 0 )
-        {
-          // m/rad(m) esta en S, para m generador minimal de I??
-          for (i = 1 ; i <= sizI ; i ++)
-            {        
-              piI = pi(I[i]);
-              if (membershipMon(piI,S) == 1)
-                {
-                  if (i == 1)
-                    {
-                      I = I[2..sizI];
-                    }
-                  else
-                    {
-                      if (i == sizI)
-                        {
-                          I = I[1..sizI - 1];
-                        }
-                      else
-                        {
-                          I = I[1..i - 1],I[i + 1..sizI];
-                        }
-                    }
-                  sizI = size(I);
-                  i --;
-                }
+  {
+    // (I,S,q) normal slice?
+    // Como cada vez que introducimos una cota inferior sabemos
+    // que la slice actual es la inner slice (la otra es vacio),
+    // hay que volver a verificar si es normal
+    if ( S <> 0 )
+    {
+      // m/rad(m) esta en S, para m generador minimal de I??
+      for (i = 1 ; i <= sizI ; i ++)
+      {
+        piI = pi(I[i]);
+        if (membershipMon(piI,S) == 1)
+        {
+          if (i == 1)
+          {
+            I = I[2..sizI];
+          }
+          else
+          {
+            if (i == sizI)
+            {
+              I = I[1..sizI - 1];
             }
-        }
-      // Buscamos cota inferior, y si es distinta de 1, simplificamos
-      sol = simplification(I);
-      p = sol[1];
-      if (p == 1)
+            else
+            {
+              I = I[1..i - 1],I[i + 1..sizI];
+            }
+          }
+          sizI = ncols(I);
+          i --;
+        }
+      }
+    }
+    // Buscamos cota inferior, y si es distinta de 1, simplificamos
+    sol = simplification(I);
+    p = sol[1];
+    if (p == 1)
+    {
+      break;
+    }
+    else
+    {
+      if (p == 0)
+      {
+        break;
+      }
+      else
+      {
+        if (membershipMon(p,I) == 1 )
         {
           break;
         }
-      else
-        {
-          if (p == 0)
-            {
-              break;
-            }
-          else
-            {
-              if (membershipMon(p,I) == 1 )
-                {
-                  break;
-                }
-            }
-        }
-      // Changing slice by simplification
-      I = sol[2];
-      I = minbase(quotient(I,p));
-      q = p*q;
-      S = minbase(quotient(S,p));
-      sizI = size(I);
-    }
-  sizI = size(I);
+      }
+    }
+    // Changing slice by simplification
+    I = sol[2];
+    I = minbase(quotient(I,p));
+    q = p*q;
+    S = minbase(quotient(S,p));
+    sizI = ncols(I);
+  }
+  sizI = ncols(I);
   // (I,S,q) base case?
   poly lcmMinI;
   lcmMinI = 1;
   for (i = 1 ; i <= sizI ; i ++)
-    {
-      lcmMinI = lcmMon(lcmMinI,I[i]);
-    }
+  {
+    lcmMinI = lcmMon(lcmMinI,I[i]);
+  }
   // a:b generates an intvec of length b with constant entries a
   intvec one = 1:nvar;
   if (divideMon(monomial(one),lcmMinI) == 0)
-   {
-     return (0);
-   }
+  {
+    return (0);
+  }
   if (equal(radicalMon(I),I) == 1)
-    {
-      if (equal(I, maxideal(1)) == 0)
-        {
-                return (0);
-              }
-       else
-         {
-          for (i = 1 ; i <= nvar ; i ++)
-            {
-              q = q * x(i);
-            }
-          return (q);
-        }
-    }
+  {
+    if (equal(I, maxideal(1)) == 0)
+    {
+      return (0);
+    }
+    else
+    {
+      for (i = 1 ; i <= nvar ; i ++)
+      {
+        q = q * var(i);
+      }
+      return (q);
+    }
+  }
   // Selecting pivot
   p = pivot(I,lcmMinI,S);
@@ -3689,11 +3536,6 @@
 static proc irredDecMonSlice (ideal I)
 {
-  // New ring
-  def R = basering;
-  int nvar = nvars(R);
-  string s = "ring R1 =",charstr(R),",x(1..nvar),dp;";
-  execute(s);
-  ideal I = fetch(R,I);
-  int sizI = size(I);
+  int nvar = nvars(basering);
+  int sizI = ncols(I);
   int i,j;
   // Artinian ideal
@@ -3701,25 +3543,22 @@
   list artinianization = artinian(I);
   if (artinianization[1] == 0)
-    {
-      artI = artinianization[2];
-    }
+  {
+    artI = artinianization[2];
+  }
   else
-    {
-      artI = I;
-    }
+  {
+    artI = I;
+  }
   // Easy case: 2 variables
   if (nvar == 2)
-    {
-      artI = sort(artI)[1];
-      int sizartI = size(artI);
-      for (i = 1 ; i <= sizartI - 1 ; i ++)
-        {
-          components[i] = x(1)^(leadexp[artI[i]][1])*x(2)^(leadexp[artI[i + 1]][2]);
-        }
-      setring R;
-      list components = fetch(R1,components);
-      kill R1;
-      return (components);
-    }
+  {
+    artI = sort(artI)[1];
+    int sizartI = size(artI);
+    for (i = 1 ; i <= sizartI - 1 ; i ++)
+    {
+      components[i] = var(1)^(leadexp[artI[i]][1])*var(2)^(leadexp[artI[i + 1]][2]);
+    }
+    return (components);
+  }
   ideal irredDec = con (artI,0,1);
   // Delelting zeros
@@ -3728,11 +3567,11 @@
   intvec elimina;
   if (artinianization[1] == 0)
-    {
-      elimina = artinianization[3];
-    }
+  {
+    elimina = artinianization[3];
+  }
   else
-    {
-      elimina = 0;
-    }
+  {
+    elimina = 0;
+  }
  // Each generator (monomial) corresponds to an ideal
   list components;
@@ -3742,34 +3581,31 @@
   ideal auxIdeal;
   for (i = 1 ; i <= sizIrred ; i ++)
-    {
-      comp = irredDec[i];
-      exp = leadexp(comp);
-      for (j = 1 ; j <= nvar ; j ++)
-        {
-          if (exp[j] <> 0)
-            {
-              if (elimina <> 0)
-                {
-                  if (exp[j] == elimina[j])
-                    {
-                      auxIdeal[j] = 0;
-                    }
-                  else
-                    {
-                      auxIdeal[j] = x(j)^exp[j];
-                    }
-                }
-              else
-                {
-                  auxIdeal[j] = x(j)^exp[j];
-                }
-            }
-        }
-      components[i] = simplify(auxIdeal,2);
-      auxIdeal = 0;
-    }
-  setring R;
-  list components = fetch(R1,components);
-  kill R1;
+  {
+    comp = irredDec[i];
+    exp = leadexp(comp);
+    for (j = 1 ; j <= nvar ; j ++)
+    {
+      if (exp[j] <> 0)
+      {
+        if (elimina <> 0)
+        {
+          if (exp[j] == elimina[j])
+          {
+            auxIdeal[j] = 0;
+          }
+          else
+          {
+            auxIdeal[j] = var(j)^exp[j];
+          }
+        }
+        else
+        {
+          auxIdeal[j] = var(j)^exp[j];
+        }
+      }
+    }
+    components[i] = simplify(auxIdeal,2);
+    auxIdeal = 0;
+  }
   return (components);
 }
@@ -3820,68 +3656,67 @@
   // que comprobar si el ideal es monomial.
   if (control == 0)
-    {
-      list isMon = isMonomialGB (I);
-      if (isMon[1] == 0)
-        {
-          ERROR ("the ideal is not monomial.");
-        }
-      else
-        {
-          I = isMon[2];
-          // Ya lo tenemos con los generadores minimales
-        }
-    }
+  {
+    list isMon = isMonomialGB (I);
+    if (isMon[1] == 0)
+    {
+      ERROR ("the ideal is not monomial.");
+    }
+    else
+    {
+      I = isMon[2];
+      // Ya lo tenemos con los generadores minimales
+    }
+  }
   else
-    {
-      // Generadores monomiales, hallamos sistema minimal
-      I = minbase(I);
-
-    }
+  {
+    // Generadores monomiales, hallamos sistema minimal
+    I = minbase(I);
+  }
   // Si el ideal es irreducible, devolvemos el mismo
   if (isirreducibleMon(I) == 1)
-    {
-      return (I);
-    }
- // Si no me han dado opcion, elijo una yo.
- if (size(#) == 1)
-   {
-     return (irredDec3(I));
-   }
+  {
+    return (I);
+  }
+  // Si no me han dado opcion, elijo una yo.
+  if (size(#) == 1)
+  {
+    return (irredDec3(I));
+  }
   // Leo la opcion y llamo al procedimiento oportuno
   else
-    {
-      if (#[2] == "vas")
-        {
-          return (irredDec1(I));
-        }
-      if (#[2] == "add")
-        {
-          return (irredDec3(I));
-        }
-      if (#[2] == "ad")
-        {
-          return (irredDec4(I));
-        }
-      if (#[2] == "for")
-        {
-          return (irredDec5(I));
-        }
-      if (#[2] == "mil")
-        {
-          return (ScarfMethod(I));
-        }
-      if (#[2] == "lr")
-        {
-          return (labelAlgorithm(I));
-        }
-      if (#[2] == "gz")
-        {
-          return (incrementalAlg(I));
-        }
-      if (#[2] == "sr")
-        {
-          return (irredDecMonSlice(I));
-        }
-    }
+  {
+    if (#[2] == "vas")
+    {
+      return (irredDec1(I));
+    }
+    if (#[2] == "add")
+    {
+      return (irredDec3(I));
+    }
+    if (#[2] == "ad")
+    {
+      return (irredDec4(I));
+    }
+    if (#[2] == "for")
+    {
+      return (irredDec5(I));
+    }
+    if (#[2] == "mil")
+    {
+      return (ScarfMethod(I));
+    }
+    if (#[2] == "lr")
+    {
+      return (labelAlgorithm(I));
+    }
+    if (#[2] == "gz")
+    {
+      return (incrementalAlg(I));
+    }
+    if (#[2] == "sr")
+    {
+      return (irredDecMonSlice(I));
+    }
+  }
 }
 example
@@ -3935,71 +3770,71 @@
   // que comprobar si el ideal es monomial.
   if (control == 0)
-    {
-      list isMon = isMonomialGB (I);
-      if (isMon[1] == 0)
-        {
-          ERROR ("the ideal is not monomial.");
-        }
-      else
-        {
-          I = isMon[2];
-          // Ya lo tenemos con los generadores minimales
-        }
-    }
+  {
+    list isMon = isMonomialGB (I);
+    if (isMon[1] == 0)
+    {
+      ERROR ("the ideal is not monomial.");
+    }
+    else
+    {
+      I = isMon[2];
+      // Ya lo tenemos con los generadores minimales
+    }
+  }
   else
-    {
-      // Generadores monomiales, hallamos sistema minimal
-      I = minbase(I);
-    }
+  {
+    // Generadores monomiales, hallamos sistema minimal
+    I = minbase(I);
+  }
   // Estudiamos si el ideal es o no primario
   if (isprimaryMon(I) == 1)
-    {
-      return (I);
-    }
+  {
+    return (I);
+  }
   // Si no me han dado opcion, elijo una yo.
   if (size(#) == 1)
-    {
-      return(primDec3(I));
-    }
+  {
+    return(primDec3(I));
+  }
   // Leo la opcion y llamo al procedimiento oportuno
   else
-    {
-      if (#[2] == "vi")
-        {
-          return (primDec1(I));
-        }
-      if (#[2] == "vp")
-        {
-          return (primDec2(I));
-        }
-      if (#[2] == "add")
-        {
-          return (primDec3(I));
-        }
-      if (#[2] == "ad")
-        {
-          return (primDec4(I));
-        }
-      if (#[2] == "for")
-        {
-          return (primDec5(I));
-        }
-      if (#[2] == "mil")
-        {
-          return (scarfMethodPrim(I));
-        }
-      if (#[2] == "lr")
-        {
-          return (labelAlgPrim(I));
-        }
-      if (#[2] == "gz")
-        {
-          return (incrementalAlgPrim(I));
-        }
-      if (#[2] == "sr")
-        {
-          return (primDecMonSlice(I));
-        }
-    }
+  {
+    if (#[2] == "vi")
+    {
+      return (primDec1(I));
+    }
+    if (#[2] == "vp")
+    {
+      return (primDec2(I));
+    }
+    if (#[2] == "add")
+    {
+      return (primDec3(I));
+    }
+    if (#[2] == "ad")
+    {
+      return (primDec4(I));
+    }
+    if (#[2] == "for")
+    {
+      return (primDec5(I));
+    }
+    if (#[2] == "mil")
+    {
+      return (scarfMethodPrim(I));
+    }
+    if (#[2] == "lr")
+    {
+      return (labelAlgPrim(I));
+    }
+    if (#[2] == "gz")
+    {
+      return (incrementalAlgPrim(I));
+    }
+    if (#[2] == "sr")
+    {
+      return (primDecMonSlice(I));
+    }
+  }
 }
 example
