This is MinimalPrimes.info, produced by Macaulay2, version 1.25.11

MinimalPrimes -- minimal primes and radical routines for ideals
***************************************************************

Description
===========

Find the minimal primes of an ideal, in a
polynomial ring over a prime field, or a quotient ring of that. These are the
geometric components of the corresponding algebraic set.

Multiple strategies are implemented via hooks (Macaulay2Doc).
In many cases the default Birational strategy is much faster, although
there are cases when the Legacy strategy does better. For a monomial ideal (Macaulay2Doc),
a more efficient algorithm is used
instead.

minprimes and decompose are synonyms for minimalPrimes.

Caveat
======

Only works for ideals in (commutative) polynomial rings or quotients of
polynomial rings over a prime field, might have bugs in small characteristic
and larger degree (although, many of these cases are caught correctly).

Authors
=======

  * Frank Moore (see https://users.wfu.edu/moorewf ) <moorewf@wfu.edu>
  * Mike Stillman (see https://www.math.cornell.edu/~mike )
    <mike@math.cornell.edu>
  * Franziska Hinkelmann
  * Justin Chen <justin.chen@math.gatech.edu>
  * Mahrud Sayrafi (see https://math.umn.edu/~mahrud ) <mahrud@umn.edu>

Version
=======

This documentation describes version 0.10 of MinimalPrimes, released November
12, 2020.

Citation
========

If you have used this package in your research, please cite it as follows:

+-----------------------------------------------------------------------------+
|@misc{MinimalPrimesSource,                                                   |
|  title = {{MinimalPrimes: minimal primes and radical routines for           |
|  author = {Frank Moore and Mike Stillman and Franziska Hinkelmann           |
|  howpublished = {A \emph{Macaulay2} package available at                    |
|    \url{https://github.com/Macaulay2/M2/tree/stable/M2/Macaulay2/           |
|}                                                                            |
|-----------------------------------------------------------------------------|
| ideals. Version~0.10}},                                                     |
| and Justin Chen and Mahrud Sayrafi},                                        |
|                                                                             |
|packages}}                                                                   |
+-----------------------------------------------------------------------------+

Exports
=======

  * Types
      * Hybrid -- the class of lists encapsulating hybrid
        strategies
  * Functions and commands
      * minimalPrimes -- minimal primes of an ideal
      * radical -- the radical of an ideal
      * radicalContainment -- whether an element is
        contained in the radical of an ideal
  * Methods
      * isPrime(Ideal) -- whether an ideal is prime
      * "decompose(Ideal)" -- see minimalPrimes, --
        minimal primes of an ideal
      * "minimalPrimes(Ideal)" -- see minimalPrimes, --
        minimal primes of an ideal
      * "radical(Ideal)" -- see radical, -- the radical of an
        ideal
      * "radicalContainment(Ideal,Ideal)" -- see radicalContainment,
        -- whether an element is contained in the radical
        of an ideal
      * "radicalContainment(RingElement,Ideal)" -- see
        radicalContainment, -- whether an element is
        contained in the radical of an ideal

For the programmer
==================

The object MinimalPrimes, is a package (Macaulay2Doc),
defined in MinimalPrimes.m2, with auxiliary files in
MinimalPrimes/.

-------------------------------------------------------------------------------

The source of this document is in MinimalPrimes/doc.m2:310:0.

minimalPrimes -- minimal primes of an ideal
*******************************************

  * Usage:
        minimalPrimes I
        minprimes I
        decompose I
  * Inputs:
      * I, an ideal (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * Verbosity => an integer (Macaulay2Doc), default value 0, a
        larger number will print more information during the computation
      * Strategy => a string (Macaulay2Doc), default value null,
        specifies the computation strategy to use. If it is slow, try Legacy,
        Birational, or NoBirational. The strategies might change in the future,
        and there are other undocumented ways to fine-tune the algorithm.
      * CodimensionLimit => an integer (Macaulay2Doc), default value
        infinity, stop after finding primes of codimension less than or equal
        to this value
      * MinimalGenerators => a Boolean value (Macaulay2Doc),
        default value true, if false, the minimal primes will not be
        minimalized
      * CheckPrimeOnly
      * SquarefreeFactorSize
  * Outputs:
      * a list (Macaulay2Doc), with entries the minimal associated
        primes of I

Description
===========

Given an ideal in a polynomial ring, or a quotient of a polynomial ring whose
base ring is either QQ or ZZ/p, this function computes the minimal associated
primes of the ideal I. Geometrically, it decomposes the algebraic set defined
by I.

+------------------------------------------------+
|i1 : R = ZZ/32003[a..e]                         |
|                                                |
|o1 = R                                          |
|                                                |
|o1 : PolynomialRing                             |
+------------------------------------------------+
|i2 : I = ideal"a2b-c3,abd-c2e,ade-ce2"          |
|                                                |
|             2     3           2              2 |
|o2 = ideal (a b - c , a*b*d - c e, a*d*e - c*e )|
|                                                |
|o2 : Ideal of R                                 |
+------------------------------------------------+
|i3 : C = minprimes I;                           |
+------------------------------------------------+
|i4 : netList C                                  |
|                                                |
|     +---------------------------+              |
|o4 = |ideal (c, a)               |              |
|     +---------------------------+              |
|     |              2     3      |              |
|     |ideal (e, d, a b - c )     |              |
|     +---------------------------+              |
|     |ideal (e, c, b)            |              |
|     +---------------------------+              |
|     |ideal (d, c, b)            |              |
|     +---------------------------+              |
|     |ideal (d - e, b - c, a - c)|              |
|     +---------------------------+              |
|     |ideal (d + e, b - c, a + c)|              |
|     +---------------------------+              |
+------------------------------------------------+
+-----------------------------------------------------------------------------+
|i5 : C2 = minprimes(I, Strategy=>"NoBirational", Verbosity=>2)               |
|                                                                             |
|                                  2     3                                    |
|o5 = {ideal (c, a), ideal (e, d, a b - c ), ideal (e, c, b), ideal (d, c, b),|
|     ------------------------------------------------------------------------|
|     ideal (d - e, b - c, a - c), ideal (d + e, b - c, a + c)}               |
|                                                                             |
|o5 : List                                                                    |
+-----------------------------------------------------------------------------+
|i6 : C1 = minprimes(I, Strategy=>"Birational", Verbosity=>2)                 |
|                                                                             |
|                                  2     3                                    |
|o6 = {ideal (c, a), ideal (e, d, a b - c ), ideal (e, c, b), ideal (d, c, b),|
|     ------------------------------------------------------------------------|
|     ideal (d - e, b - c, a - c), ideal (d + e, b - c, a + c)}               |
|                                                                             |
|o6 : List                                                                    |
+-----------------------------------------------------------------------------+

Example. The homogenized equations of the affine twisted cubic curve define the
union of the projective twisted cubic curve and a line at infinity:

+----------------------------------------------------------+
|i7 : R = QQ[w,x,y,z];                                     |
+----------------------------------------------------------+
|i8 : I=ideal(x^2-y*w, x^3-z*w^2)                          |
|                                                          |
|             2         3    2                             |
|o8 = ideal (x  - w*y, x  - w z)                           |
|                                                          |
|o8 : Ideal of R                                           |
+----------------------------------------------------------+
|i9 : minimalPrimes I                                      |
|                                                          |
|                            2                    2        |
|o9 = {ideal (x, w), ideal (y  - x*z, x*y - w*z, x  - w*y)}|
|                                                          |
|o9 : List                                                 |
+----------------------------------------------------------+

Note that the ideal is decomposed over the given field of coefficients and not
over the extension field where the decomposition into absolutely irreducible
factors occurs:

+--------------------------+
|i10 : I = ideal(x^2 + y^2)|
|                          |
|             2    2       |
|o10 = ideal(x  + y )      |
|                          |
|o10 : Ideal of R          |
+--------------------------+
|i11 : minimalPrimes I     |
|                          |
|              2    2      |
|o11 = {ideal(x  + y )}    |
|                          |
|o11 : List                |
+--------------------------+

For monomial ideals, the method used is essentially what is shown in the
example.

+-----------------------------------------------------------------------------+
|i12 : I = monomialIdeal ideal"wxy,xz,yz"                                     |
|                                                                             |
|o12 = monomialIdeal (w*x*y, x*z, y*z)                                        |
|                                                                             |
|o12 : MonomialIdeal of R                                                     |
+-----------------------------------------------------------------------------+
|i13 : minimalPrimes I                                                        |
|                                                                             |
|o13 = {monomialIdeal (x, y), monomialIdeal (w, z), monomialIdeal (x, z),     |
|      -----------------------------------------------------------------------|
|      monomialIdeal (y, z)}                                                  |
|                                                                             |
|o13 : List                                                                   |
+-----------------------------------------------------------------------------+
|i14 : P = intersect(monomialIdeal(w,x,y), monomialIdeal(x,z),                |
|                                                                             |
|o14 = monomialIdeal (x*y, w*z, x*z, y*z)                                     |
|                                                                             |
|o14 : MonomialIdeal of R                                                     |
|-----------------------------------------------------------------------------|
|monomialIdeal(y,z))                                                          |
+-----------------------------------------------------------------------------+
|i15 : minI = apply(P_*, monomialIdeal @@ support)                            |
|                                                                             |
|o15 = {monomialIdeal (x, y), monomialIdeal (w, z), monomialIdeal (x, z),     |
|      -----------------------------------------------------------------------|
|      monomialIdeal (y, z)}                                                  |
|                                                                             |
|o15 : List                                                                   |
+-----------------------------------------------------------------------------+

It is sometimes useful to compute P instead, where each generator encodes a
single minimal prime. This can be obtained directly, as in the following code.

+----------------------------------------+
|i16 : dual radical I                    |
|                                        |
|o16 = monomialIdeal (x*y, w*z, x*z, y*z)|
|                                        |
|o16 : MonomialIdeal of R                |
+----------------------------------------+
|i17 : P == oo                           |
|                                        |
|o17 = true                              |
+----------------------------------------+

See also
========

  * isPrime(Ideal) (missing documentation)
  * topComponents (PrimaryDecomposition) -- compute top
    dimensional component of an ideal or module
  * removeLowestDimension (PrimaryDecomposition),
    -- remove components of lowest dimension
  * radical -- the radical of an ideal
  * irreducibleCharacteristicSeries (Macaulay2Doc)
    -- irreducible
    characteristic series of an ideal
  * dual(MonomialIdeal) (Macaulay2Doc) -- the
    Alexander dual of a monomial ideal

Ways to use minimalPrimes:
==========================

  * "minimalPrimes(Ideal)"

For the programmer
==================

The object minimalPrimes, is a method function with options (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in MinimalPrimes/doc.m2:310:0.

isPrime(Ideal) -- whether an ideal is prime
*******************************************

  * Function: isPrime (Macaulay2Doc),
  * Usage:
        isPrime I
  * Inputs:
      * I, an ideal (Macaulay2Doc), in a polynomial ring or
        quotient of one
  * Optional inputs (Macaulay2Doc),:
      * Strategy => a string (Macaulay2Doc), default value null,
        See minimalPrimes(...,Strategy=>...),
      * Verbosity => an integer (Macaulay2Doc), default value 0, See
        minimalPrimes(...,Verbosity=>...),
      * SquarefreeFactorSize
  * Outputs:
      * a Boolean value (Macaulay2Doc), true (Macaulay2Doc),
        if I is a prime ideal, or false (Macaulay2Doc),
        otherwise

Description
===========

This function determines whether an ideal in a polynomial ring is prime.

+----------------------------------------------------------------------+
|i1 : R = QQ[a..d];                                                    |
+----------------------------------------------------------------------+
|i2 : I = monomialCurveIdeal(R, {1, 5, 8})                             |
|                                                                      |
|               2    2      3    2 2   3     3    5        3   5    4  |
|o2 = ideal (a*c  - b d, b*c  - a d , b c - a d, c  - a*b*d , b  - a c)|
|                                                                      |
|o2 : Ideal of R                                                       |
+----------------------------------------------------------------------+
|i3 : isPrime I                                                        |
|                                                                      |
|o3 = true                                                             |
+----------------------------------------------------------------------+

See also
========

  * minimalPrimes -- minimal primes of an ideal

Ways to use this method:
========================

  * isPrime(Ideal) -- whether an ideal is prime
-------------------------------------------------------------------------------

The source of this document is in MinimalPrimes/doc.m2:310:0.

radical -- the radical of an ideal
**********************************

  * Usage:
        radical I
  * Inputs:
      * I, an ideal (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * Unmixed => a Boolean value (Macaulay2Doc), default value
        false, whether it is known that the ideal I is unmixed. The ideal $I$
        is said to be unmixed if all associated primes of $R/I$ have the same
        dimension. In this case the algorithm tends to be much faster.
      * Strategy => a symbol (Macaulay2Doc), default value null,
        the strategy to use, either Decompose or Unmixed
      * CompleteIntersection => an ideal (Macaulay2Doc), default
        value null, an ideal J of the same height as I whose generators form a
        maximal regular sequence contained in I. Providing this option as a
        hint allows a separate, often faster, algorithm to be used to compute
        the radical. This option should only be used if J is nice in some way.
        For example, if J is randomly generated, but I is relatively sparse,
        then this will most likely run slower than just giving the Unmixed
        (missing documentation) option.
  * Outputs:
      * an ideal (Macaulay2Doc), the radical of I

Description
===========

If I is an ideal in an affine ring (i.e. a quotient of a polynomial ring over a
field), and if the characteristic of this field is large enough (see below),
then this routine yields the radical of the ideal I. The method used is the
Eisenbud-Huneke-Vasconcelos algorithm.

The algorithms used generally require that the characteristic of the ground
field is larger than the degree of each primary component. In practice, this
means that if the characteristic is something like 32003, rather than, for
example, 5, the methods used will produce the radical of I. Of course, you may
do the computation over QQ (Macaulay2Doc), but it will often run much
slower. In general, this routine still needs to be tuned for speed.

+----------------------------------+
|i1 : R = QQ[x, y]                 |
|                                  |
|o1 = R                            |
|                                  |
|o1 : PolynomialRing               |
+----------------------------------+
|i2 : I = ideal((x^2+1)^2*y, y+1)  |
|                                  |
|             4      2             |
|o2 = ideal (x y + 2x y + y, y + 1)|
|                                  |
|o2 : Ideal of R                   |
+----------------------------------+
|i3 : radical I                    |
|                                  |
|                    2             |
|o3 = ideal (y + 1, x  + 1)        |
|                                  |
|o3 : Ideal of R                   |
+----------------------------------+

If I is a monomial ideal (Macaulay2Doc), a faster,
combinatorial algorithm is used.

+---------------------------------------------------------+
|i4 : R = ZZ/101[a..d]                                    |
|                                                         |
|o4 = R                                                   |
|                                                         |
|o4 : PolynomialRing                                      |
+---------------------------------------------------------+
|i5 : I = intersect(ideal(a^2,b^2,c), ideal(a,b^3,c^2))   |
|                                                         |
|             2        2   3     2                        |
|o5 = ideal (c , a*c, a , b , a*b )                       |
|                                                         |
|o5 : Ideal of R                                          |
+---------------------------------------------------------+
|i6 : elapsedTime radical(ideal I_*, Strategy => Monomial)|
| -- .000646731s elapsed                                  |
|                                                         |
|o6 = ideal (a, b, c)                                     |
|                                                         |
|o6 : Ideal of R                                          |
+---------------------------------------------------------+
|i7 : elapsedTime radical(ideal I_*, Unmixed => true)     |
| -- .0163357s elapsed                                    |
|                                                         |
|o7 = ideal (c, b, a)                                     |
|                                                         |
|o7 : Ideal of R                                          |
+---------------------------------------------------------+

For another example, see PrimaryDecomposition.

References
==========

Eisenbud, Huneke, Vasconcelos, Invent. Math. 110 207-235 (1992).

Caveat
======

The current implementation requires that the characteristic of the ground field
is either zero or a large prime (unless I is a monomial ideal (Macaulay2Doc)).

See also
========

  * minimalPrimes -- minimal primes of an ideal
  * topComponents (PrimaryDecomposition) -- compute top
    dimensional component of an ideal or module
  * removeLowestDimension (PrimaryDecomposition),
    -- remove components of lowest dimension
  * saturate (Saturation) -- saturation of ideal or submodule
  * Ideal _colon_ Ideal (Saturation), --
    ideal or submodule quotient

Ways to use radical:
====================

  * "radical(Ideal)"

For the programmer
==================

The object radical, is a method function with options (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in MinimalPrimes/doc.m2:310:0.

radicalContainment -- whether an element is contained in the radical of an ideal
********************************************************************************

  * Usage:
        radicalContainment(g, I)
  * Inputs:
      * g, a ring element (Macaulay2Doc),
      * I, an ideal (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * Strategy => ..., default value "Rabinowitsch"
  * Outputs:
      * a Boolean value (Macaulay2Doc), true if g is in the
        radical of I, and false otherwise

Description
===========

This method determines if a given element g is contained in the radical of a
given ideal I. There are 2 algorithms implemented for doing so: the first
(default) uses the Rabinowitsch trick in the proof of the Nullstellensatz, and
is called with Strategy => "Rabinowitsch". The second algorithm, for
homogeneous ideals, uses a theorem of Kollar to obtain an effective upper bound
on the required power to check containment, together with repeated squaring,
and is called with Strategy => "Kollar". The latter algorithm is generally
quite fast if a Grobner basis of I has already been computed. A recommended way
to do so is to check ordinary containment, i.e. g % I == 0, before calling this
function.

+-----------------------------------------------------------------------------+
|i1 : d = (4,5,6,7)                                                           |
|                                                                             |
|o1 = (4, 5, 6, 7)                                                            |
|                                                                             |
|o1 : Sequence                                                                |
+-----------------------------------------------------------------------------+
|i2 : n = #d                                                                  |
|                                                                             |
|o2 = 4                                                                       |
+-----------------------------------------------------------------------------+
|i3 : R = QQ[x_0..x_n]                                                        |
|                                                                             |
|o3 = R                                                                       |
|                                                                             |
|o3 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i4 : I = ideal homogenize(matrix{{x_1^(d#0)} | apply(toList(1..n-2), i -> x_i|
|                                                                             |
|             4     5      4     6      5     7      6                        |
|o4 = ideal (x , - x  + x x , - x  + x x , - x  + x x )                       |
|             1     2    1 4     3    2 4     0    3 4                        |
|                                                                             |
|o4 : Ideal of R                                                              |
|-----------------------------------------------------------------------------|
|- x_(i+1)^(d#i)) | {x_(n-1) - x_0^(d#-1)}}, x_n)                             |
+-----------------------------------------------------------------------------+
|i5 : D = product(I_*/degree/sum)                                             |
|                                                                             |
|o5 = 840                                                                     |
+-----------------------------------------------------------------------------+
|i6 : x_0^(D-1) % I != 0 and x_0^D % I == 0                                   |
|                                                                             |
|o6 = true                                                                    |
+-----------------------------------------------------------------------------+
|i7 : elapsedTime radicalContainment(x_0, I)                                  |
| -- .0908927s elapsed                                                        |
|                                                                             |
|o7 = true                                                                    |
+-----------------------------------------------------------------------------+
|i8 : elapsedTime radicalContainment(x_0, I, Strategy => "Kollar")            |
| -- .00222665s elapsed                                                       |
|                                                                             |
|o8 = true                                                                    |
+-----------------------------------------------------------------------------+
|i9 : elapsedTime radicalContainment(x_n, I, Strategy => "Kollar")            |
| -- .00182811s elapsed                                                       |
|                                                                             |
|o9 = false                                                                   |
+-----------------------------------------------------------------------------+

See also
========

  * radical -- the radical of an ideal

Ways to use radicalContainment:
===============================

  * "radicalContainment(Ideal,Ideal)"
  * "radicalContainment(RingElement,Ideal)"

For the programmer
==================

The object radicalContainment, is a method function with options (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in MinimalPrimes/doc.m2:310:0.

minimal primes of an ideal
**************************

using { t minimalPrimes}
========================

To obtain a list of the minimal associated primes for an ideal I (i.e. the
smallest primes containing I), use the function minimalPrimes.

+---------------------------------------------------------------------+
|i1 : R = QQ[w,x,y,z];                                                |
+---------------------------------------------------------------------+
|i2 : I = ideal(w*x^2-42*y*z, x^6+12*w*y+x^3*z, w^2-47*x^4*z-47*x*z^2)|
|                                                                     |
|               2           6    3                4         2    2    |
|o2 = ideal (w*x  - 42y*z, x  + x z + 12w*y, - 47x z - 47x*z  + w )   |
|                                                                     |
|o2 : Ideal of R                                                      |
+---------------------------------------------------------------------+
|i3 : minimalPrimes I                                                 |
|                                                                     |
|                                                      3              |
|o3 = {ideal (z, x, w), ideal (y, x, w), ideal (y, w, x  + z)}        |
|                                                                     |
|o3 : List                                                            |
+---------------------------------------------------------------------+

If the ideal given is a prime ideal then minimalPrimes,
will return the ideal given.

+-----------------------------------------------------------------------------+
|i4 : R = ZZ/101[w..z];                                                       |
+-----------------------------------------------------------------------------+
|i5 : I = ideal(w*x^2-42*y*z, x^6+12*w*y+x^3*z, w^2-47*x^4*z-47*x*z^2);       |
|                                                                             |
|o5 : Ideal of R                                                              |
+-----------------------------------------------------------------------------+
|i6 : minimalPrimes I                                                         |
|                                                                             |
|                2           2   2          2      3   2   2      2 3      4  |
|o6 = {ideal (w*x  - 42y*z, x y*z  - 12w*x*z  + 11w , w x*z  + 47y z  - 43w , |
|     ------------------------------------------------------------------------|
|      4       2      2   6    3                                              |
|     x z + x*z  - 43w , x  + x z + 12w*y)}                                   |
|                                                                             |
|o6 : List                                                                    |
+-----------------------------------------------------------------------------+

See associated primes (PrimaryDecomposition), for
information on finding associated prime ideals and primary decomposition (PrimaryDecomposition),
for more information about finding
the full primary decomposition of an ideal.

-------------------------------------------------------------------------------

The source of this document is in MinimalPrimes/doc.m2:310:0.

radical of an ideal
*******************

There are two main ways to find the radical of an ideal. On some large examples
the second method is faster.

using radical,
=============================

+-------------------------------+
|i1 : S = ZZ/101[x,y,z]         |
|                               |
|o1 = S                         |
|                               |
|o1 : PolynomialRing            |
+-------------------------------+
|i2 : I = ideal(x^3-y^2,y^2*z^2)|
|                               |
|             3    2   2 2      |
|o2 = ideal (x  - y , y z )     |
|                               |
|o2 : Ideal of S                |
+-------------------------------+
|i3 : radical I                 |
|                               |
|                       3    2  |
|o3 = ideal (y*z, x*z, x  - y ) |
|                               |
|o3 : Ideal of S                |
+-------------------------------+

using theminimal primes of an ideal,
======================================================================

An alternate way to find the radical of an ideal I is to take the intersection
of its minimal prime ideals. To find the minimal primes of an ideal,
I use the function minimalPrimes.
Then use intersect (Macaulay2Doc).

+------------------------------+
|i4 : intersect minimalPrimes I|
|                              |
|                       3    2 |
|o4 = ideal (y*z, x*z, x  - y )|
|                              |
|o4 : Ideal of S               |
+------------------------------+
-------------------------------------------------------------------------------

The source of this document is in MinimalPrimes/doc.m2:310:0.

Hybrid -- the class of lists encapsulating hybrid strategies
************************************************************

Description
===========

This class is used to encapsulate hybrid strategies for certain method
functions.

This example demonstrates an example of what is meant by a hybrid strategy.

+-----------------------------------------------------------------------------+
|i1 : debug MinimalPrimes                                                     |
+-----------------------------------------------------------------------------+
|i2 : R = ZZ/101[w..z];                                                       |
+-----------------------------------------------------------------------------+
|i3 : I = ideal(w*x^2-42*y*z, x^6+12*w*y+x^3*z, w^2-47*x^4*z-47*x*z^2);       |
|                                                                             |
|o3 : Ideal of R                                                              |
+-----------------------------------------------------------------------------+
|i4 : elapsedTime minimalPrimes(                                              |
|  Strategy: Linear            (                                              |
|  Strategy: Birational        (                                              |
|  Strategy: Factorization     (                                              |
|  Strategy: DecomposeMonomials(                                              |
| -- Converting annotated ideals                                              |
| --  Time taken : .000899338                                                 |
| -- .0332524s elapsed                                                        |
|-----------------------------------------------------------------------------|
|ideal I_*, Strategy => Hybrid{Linear,Birational,Factorization,               |
|time .00132019)  #primes = 0 #prunedViaCodim = 0                             |
|time .0163082)  #primes = 0 #prunedViaCodim = 0                              |
|time .000380981)  #primes = 0 #prunedViaCodim = 0                            |
|time .000020008)  #primes = 1 #prunedViaCodim = 0                            |
| to ideals and selecting minimal primes...                                   |
|-----------------------------------------------------------------------------|
|DecomposeMonomials}, Verbosity => 2);                                        |
+-----------------------------------------------------------------------------+

See also
========

  * primaryDecomposition(...,Strategy=>...) (PrimaryDecomposition)

For the programmer
==================

The object Hybrid, is a self initializing type (Macaulay2Doc),
with ancestor classes List (Macaulay2Doc),
< VisibleList (Macaulay2Doc) <
BasicList (Macaulay2Doc) < Thing (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in MinimalPrimes/doc.m2:310:0.