Context Navigation

← Previous Changeset
Next Changeset →

Changeset abbd22 in git

Timestamp:

Aug 10, 2010, 2:17:49 PM (14 years ago)

Author:

Hans Schoenemann <hannes@…>

Branches:

(u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')

Children:

71ea75859d658e8bb0cf07f0242fb4ef13f452a1

Parents:

7f8587b3752e6d6a92df017bafdfb3d03198e66b

Message:

optimized version

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

File:

: 1 edited

Singular/LIB/monomial.lib (modified) (119 diffs)

Legend:

: Unmodified
: Added
: Removed

Singular/LIB/monomial.lib

-                      r7f8587
+                      rabbd22
 ";
 LIB "poly.lib";  // Para "maxdeg1" en "isprimeMon"
 //---------------------------------------------------------------------------
+//---------------------------------------------------------------------------
 //-----------------------   INTERNOS    -------------------------------------
 //---------------------------------------------------------------------------
+//---------------------------------------------------------------------------
 /////////////////////////////////////////////////////////////////////////////
 //
 …
   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);
+}
 …
   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) );
 …
+"
+{
-  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);
+}
 …
+"
+{
-  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);
+}
 …
   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);
+}
 …
   // 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);
+}
 /////////////////////////////////////////////////////////////////////////////
 …
+{
   // 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);
+}
 …
+"
+{
-  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;
 …
   // 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.
 …
   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);
+}
 …
   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);
+}
 …
+{
   // 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;
 …
   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);
+}
 /////////////////////////////////////////////////////////////////////////////
 …
   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;
 …
   // 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.
 …
   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.
 …
+"
+{
-  // 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);
+  }
+}
 /////////////////////////////////////////////////////////////////////////////
 …
 proc areEqual(list l1,list l2)
+{
-  def R = basering;
-  l1 = fetch(R,l1);
-  l2 = fetch(R,l2);
   int i,j,sizIdeal;
   poly generator;
 …
   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));
+}
 …
 //-------------------------------------------------------------------------//
 /////////////////////////////////////////////////////////////////////////////
 //
 proc isMonomial (ideal I)
+//
+proc isMonomial (ideal I)
 "USAGE:    isMonomial (I); I ideal.
 RETURN:   1, if I is monomial ideal; 0, otherwise.
 …
+"
+{
+  // 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);
+}
 …
   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);
+}
 …
     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
 …
 //////////////////////////////////////////////////////////////////////
 //
 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.
 …
+"
+{
-  def R = basering;
   // Variables
   int i,j,resp,k,control;
 …
   // 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++)
+  {
 …
 //////////////////////////////////////////////////////////////////////
 //
 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.
 …
   // 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.
 …
 //////////////////////////////////////////////////////////////////////
 //
 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.
 …
   //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.
 …
   // 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.
 …
+{
   // 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;
 …
   intvec v;
   ideal rad_I;
-  ideal I = fetch(R,I);
   // COMPROBACIONES
   control = checkIdeal(I);
 …
   // 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));
+}
 …
 //////////////////////////////////////////////////////////////////////
 //
 proc isprimeMon (ideal I)
+proc isprimeMon (ideal I)
 "USAGE:    isprimeMon (I); I ideal
 RETURN:   1, if I is prime; 0, otherwise.
 …
   // 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
 …
 //////////////////////////////////////////////////////////////////////
 //
 proc isprimaryMon (ideal I)
+proc isprimaryMon (ideal I)
 "USAGE:    isprimaryMon (I); I ideal
 RETURN:   1, if I is primary; 0, otherwise.
 …
+"
+{
-  def R = basering;
   // Variables
   int nvar,control,m,l,sub_in,i,j,k;
 …
   // 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
 …
   // 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
 …
   // 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.
 …
   // 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,
 …
   // 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);
+}
 …
+"
+{
+  def R = basering;
+  int  nvar  = nvars(R);
+  int  nvar  = nvars(basering);
   // Declaracion de variables
   int i,j,k,cont,sizI;
 …
   // 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
 …
   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);
 …
+"
+{
+  def R = basering;
+  int nvar = nvars(R);
+  int nvar = nvars(basering);
   // Declaracion de variables
   int sizI,i,j,k;
 …
   // 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);
+}
 …
+"
+{
+  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
 …
 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;
 …
   intvec exp,v;
   ideal J,K;
-  ideal I = fetch(R,I);
   // ----- DESCOMPOSICION IRREDUCIBLE
   // Inicializamos la lista que va a estar formada por los ideales
 …
   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);
+}
 …
 //////////////////////////////////////////////////////////////////////
 //
+static proc primDec1 (ideal I)  {
+static proc primDec1 (ideal I)
+{
   // Variables
   list l1,l2;
 …
 // 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            //
 …
 //////////////////////////////////////////////////////////////////////
 //
+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;
 …
   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
 …
   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);
+}
 …
 //////////////////////////////////////////////////////////////////////
 //
 static proc irredDec3 (ideal I)  {
+  def R = basering;
+static proc irredDec3 (ideal I)
+{
   int i,n,j;
   poly lcm;
 …
   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.
 …
 //////////////////////////////////////////////////////////////////////
 //
+static proc primDec3 (ideal I)   {
+static proc primDec3 (ideal I)
+{
   // Variables
   list l1,l2;
 …
 //////////////////////////////////////////////////////////////////////
 //
+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;
 …
   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
 …
   // 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));
 …
   // 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,
 …
   // 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);
+}
 …
 //////////////////////////////////////////////////////////////////////
 //
+static proc primDec4 (ideal I) {
+static proc primDec4 (ideal I)
+{
   // Variables
   list l1,l2;
 …
 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;
 …
   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);
+}
 …
 //////////////////////////////////////////////////////////////////////
 //
+static proc primDec5 (ideal I) {
+static proc primDec5 (ideal I)
+{
   // Variables
   list l1,l2;
 …
   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);
+}
 …
+{
   // 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;
 …
   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);
+  }
+}
 //////////////////////////////////////////////////////////////////////
 …
+{
   // 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.
 …
   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);
+  }
+}
 //////////////////////////////////////////////////////////////////////
 …
 static proc nonGeneric (EXP,NEWEXP,Faces,sizI)
+{
+  def R = basering;
+  int nvar = nvars(R);
+  int nvar = nvars(basering);
   int sizFaces = size(Faces);
   // Variables
 …
   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);
+}
 …
   // 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.
 …
   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);
+}
 …
   // 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;
 …
   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
 …
       // 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);
+}
 …
   // 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;
 …
   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
 …
   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
 …
   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
 …
   // 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.
 …
   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);
+}
 //////////////////////////////////////////////////////////////////////
 …
+{
   // 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;
 …
   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
 …
   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);
+}
 …
+{
  // 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);
+}
 …
 static proc conditionComplex (intvec posActual,ideal I,ideal S)
+{
+  def R = basering;
+  int nvar = nvars(R);
+  int nvar = nvars(basering);
   // VARIABLES
   int i,nuevo;
 …
   // 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);
+}
 …
 static proc findFaces (ideal I)
+{
+  def R = basering;
+  int nvar = nvars(R);
+  int nvar = nvars(basering);
   // Variables
   int i;
 …
   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);
+}
 …
 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
 …
   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
 …
   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.
 …
   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);
+}
 …
 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);
+}
 …
 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
 …
   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.
 …
   // 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);
 …
   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.
 …
   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);
+}
 …
 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);
+}
 //////////////////////////////////////////////////////////////////////
 …
+{
   // 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
 …
   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;
+    }
+  }
+}
 //////////////////////////////////////////////////////////////////////
 …
   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
 …
   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;
 …
   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.
 …
 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);
 …
 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
 …
   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
 …
   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;
 …
   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);
+}
 …
   // 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
 …
   // 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

Note: See TracChangeset for help on using the changeset viewer.

Context Navigation

Changeset abbd22 in git

Legend:

Singular/LIB/monomial.lib

Download in other formats: