primaryDecomposition -- irredundant primary decomposition of an ideal

Usage:

primaryDecomposition I
Inputs:
- I, an ideal, in a (quotient of a) polynomial ring R
Optional inputs:
- MinimalGenerators => a Boolean value, default value true, if false, the components will not be minimalized
- Strategy => ..., default value null,
Outputs:
- a list, containing a minimal list of primary ideals whose intersection is I

Description

This routine returns an irredundant primary decomposition for the ideal I. The specific algorithm used varies depending on the characteristics of the ideal, and can also be specified using the Strategy option. In all cases, the radical of each entry of the output is equal to the corresponding entry of the output of associatedPrimes.

Primary decomposition algorithms are very sensitive to the input. Some algorithms work very well on certain classes of ideals, but poorly on other classes. If this function seems to be taking too long, try another algorithm using primaryDecomposition(...,Strategy=>...).

i1 : R = QQ[a..i];

i2 : I = permanents(2,genericMatrix(R,a,3,3))

o2 = ideal (b*d + a*e, c*d + a*f, c*e + b*f, b*g + a*h, c*g + a*i, c*h + b*i,
     ------------------------------------------------------------------------
     e*g + d*h, f*g + d*i, f*h + e*i)

o2 : Ideal of R

i3 : C = primaryDecomposition I;

i4 : I == intersect C

o4 = true

i5 : #C

o5 = 16

This function has one optional input Strategy, which accepts three possible values used to determine the algorithm for finding embedded components.

The available values are Res, which is closest to the original Eisenbud-Huneke-Vasconcelos method, together with Hom and Sat.

If you want to specify the Strategy to be used by localize as well, this can be specified by passing a Hybrid Strategy in the form: Hybrid{primaryDecomposition.Strategy, localize.Strategy}.

i6 : kk = ZZ/3

o6 = kk

o6 : QuotientRing

i7 : R = kk[a,b]

o7 = R

o7 : PolynomialRing

i8 : I = ideal {a^2, a*b}

             2
o8 = ideal (a , a*b)

o8 : Ideal of R

i9 : primaryDecomposition(I, Strategy => Hybrid{Res, 1})

o9 = {ideal a, ideal (b, a)}

o9 : List

While the default (and typically fastest) strategy is Sat, it is recommended to try different Strategy values if the computation of a particular embedded component is taking too long. One can start the computation with one strategy, and interrupt and resume with a different strategy (even multiple times) if desired.

Recall that List / Function applies a function to each element of a list, returning the results as a list. This is often useful with lists of ideals, such as the list C of primary components.

i10 : C / toString / print;
ideal(i,h,g,f,e,d)
ideal(i,h,g,f,c,b*d+a*e)
ideal(i,h,g,e,b,c*d+a*f)
ideal(i,h,g,d,a,c*e+b*f)
ideal(i,h,g,c,b,a)
ideal(i,h,f,e,c,b)
ideal(i,g,f,d,c,a)
ideal(i,f,e,d,c,b*g+a*h)
ideal(i,f,c,b,a,e*g+d*h)
ideal(h,g,e,d,b,a)
ideal(h,f,e,d,b,c*g+a*i)
ideal(h,e,c,b,a,f*g+d*i)
ideal(g,f,e,d,a,c*h+b*i)
ideal(g,d,c,b,a,f*h+e*i)
ideal(f,e,d,c,b,a)
ideal(i^2,f*h+e*i,c*h+b*i,f*g+d*i,e*g+d*h,c*g+a*i,b*g+a*h,c*e+b*f,c*d+a*f,b*d+a*e,a^2,g*h*i,c*f*i,h^3,g*h^2,e*h^2,d*h^2,b*h^2,a*h^2,b*e*h,g^3,d*g^2,a*g^2,a*d*g,f^3,e*f^2,d*f^2,c*f^2,b*f^2,a*f^2,d*e*f,e^3,d*e^2,b*e^2,a*e^2,d^3,a*d^2,c^3,b*c^2,a*c^2,a*b*c,b^3,a*b^2)

i11 : C / codim

o11 = {6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 9}

o11 : List

i12 : C / degree

o12 = {1, 2, 2, 2, 1, 1, 1, 2, 2, 1, 2, 2, 2, 2, 1, 82}

o12 : List

The corresponding list of associated prime ideals is cached and can be obtained by using associatedPrimes(Ideal).

i13 : associatedPrimes I / print;
ideal a
ideal (b, a)

Some strategies require the ground ring to be a prime field but results can be obtained in some cases even for more general ground rings.

i14 : kk = GF(9)

o14 = kk

o14 : GaloisField

i15 : R = kk[a,b]

o15 = R

o15 : PolynomialRing

i16 : I = ideal {a^2, a*b}

              2
o16 = ideal (a , a*b)

o16 : Ideal of R

i17 : primaryDecomposition(I)

                           2
o17 = {ideal a, ideal (b, a )}

o17 : List

Ways to use primaryDecomposition:

primaryDecomposition(Ideal)
primaryDecomposition(Module) -- irredundant primary decomposition of a module
primaryDecomposition(Ring) -- see primaryDecomposition(Module) -- irredundant primary decomposition of a module

For the programmer

The object primaryDecomposition is a method function with options.

The source of this document is in PrimaryDecomposition/doc.m2:771:0.

primaryDecomposition -- irredundant primary decomposition of an ideal

Description

See also

Ways to use primaryDecomposition:

For the programmer