Stable set algorithm

A routine to compute the stable set of associated prime ideals of a monomial ideal

In the paper On the stable set of associated prime ideals of a monomial ideal by Shamila Bayati, Juergen Herzog and Giancarlo Rinaldo, (section 2), the authors describe an algorithm to compute Ass^∞(I) for a monomial ideal I. Here is a preprint of the article.

In this page we give an example of this computation by the routines that we implemented in Macaulay 2 which are downloadable from here. We refer to the article for an in-depth description of the algorithm.

As done in the article we want to see if the prime ideal P=(a,b,c,e,f)⊂K[a,b,c,d,e,f] is in Ass^∞(I) where I=(a³b²e,bc³d,b⁴de²f, ab²cf³). For this purpose we have to load the file isInAssInfinity.m2 and after defining the ambient ring, the ideal I and the set of generators of P, we call the function isInAssInfinity(P,I) that returns true or false. We show the input and the output in the console.


load "isInAssInfinity.m2"; 
S=QQ[a..f];
I=monomialIdeal(a^3*b^2*e,b*c^3*d,b^4*d*e^2*f, a*b^2*c*f^3);
P={a,b,c,e,f};
isInAssInfinity(P,I)


true

Now we describe a way to compute all the prime ideals in Ass^∞(I). Let Min(I)=Ass(rad(I)). Since rad(I)=rad(I^k) for all k, we have to consider all the monomial prime ideals P in K[a,b,c,d,e,f] such that there exists Q in Min(I) with P⊃Q. Hence it is useful to have a routine, called candidates(I), that calculates such candidates depending on the monomial ideal I. In the above example we get:


C=candidates(I)


     {{b}, {a, b}, {b, c}, {a, b, c}, {a, d}, {b, d}, {a, b, d}, {a, c, d}, {b,
     --------------------------------------------------------------------------
     c, d}, {a, b, c, d}, {b, e}, {a, b, e}, {c, e}, {a, c, e}, {b, c, e}, {a,
     --------------------------------------------------------------------------
     b, c, e}, {a, d, e}, {b, d, e}, {a, b, d, e}, {c, d, e}, {a, c, d, e}, {b,
     --------------------------------------------------------------------------
     c, d, e}, {a, b, c, d, e}, {b, f}, {a, b, f}, {a, c, f}, {b, c, f}, {a, b,
     --------------------------------------------------------------------------
     c, f}, {a, d, f}, {b, d, f}, {a, b, d, f}, {a, c, d, f}, {b, c, d, f}, {a,
     --------------------------------------------------------------------------
     b, c, d, f}, {b, e, f}, {a, b, e, f}, {c, e, f}, {a, c, e, f}, {b, c, e,
     --------------------------------------------------------------------------
     f}, {a, b, c, e, f}, {d, e, f}, {a, d, e, f}, {b, d, e, f}, {a, b, d, e,
     --------------------------------------------------------------------------
     f}, {c, d, e, f}, {a, c, d, e, f}, {b, c, d, e, f}, {a, b, c, d, e, f}}

Then we scan within the candidates the ones that are in Ass^∞(I).


scan(C, P-> if isInAssInfinity(P,I) then print P);


{b}
{b, c}
{a, b, c}
{a, d}
{b, d}
{a, c, d}
{a, b, c, d}
{c, e}
{a, c, e}
{b, c, e}
{a, c, f}
{a, b, c, f}
{a, d, f}
{a, c, d, f}
{a, b, c, d, f}
{c, e, f}
{a, c, e, f}
{a, b, c, e, f}
{d, e, f}