This is Binomials.info, produced by Macaulay2, version 1.22

Binomials -- a package for binomial ideals
******************************************

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

Binomials is a package for binomial ideals with a particular focus on
intersection decompositions and associated primes.  For instance, if the input
is a unital binomial ideal (that is generated by monomials and differences of
monomials) then the functionbinomialPrimaryDecomposition,
computes a primary decomposition into binomial
ideals. To this end a cyclotomic field extension of the coefficient field may
be necessary which is automatically constructed using the package
Cyclotomic. Binomials also implements the data type
partialCharacter, (see [ES96]) and several convenience
functions to transform binomials into exponent vectors and vice versa.  Those
may be useful for manual inspection of binomial ideals.There is no special
datatype for binomial ideals implemented, one just uses ideal (Macaulay2Doc),
s.

Literature
  * [ES96] Binomial ideals (D. Eisenbud, B.Sturmfels, 1996).
  * [DMM10] Combinatorics of binomial primary decomposition (A. Dickenstein, L.
    Matusevich, E.Miller, 2010)
  * [OS00] Cellular Binomial Ideals. Primary Decomposition of Binomial Ideals
    (I. Ojeda, R. Piedra-Sanchez, 2000)
  * [Alt00] The chain property for the associated primes of A-graded ideals (K.
    Altmann, 2000)
  * [KM11] Decompositions of commutative monoid congruences and binomial ideals
    (T. Kahle, E. Miller, 2011)

Author
======

  * Thomas Kahle (see http://www.thomas-kahle.de ) <thomas.kahle@jpberlin.de>

Certification a gold star
=========================

Version 1.0 of this package was accepted for publication in volume 4 (see
http://j-sag.org/Volume4/ ) of The Journal of Software for Algebra and
Geometry: Macaulay2 (see http://j-sag.org/ ) on 2012-02-06, in the article
Decompositions of binomial ideals (see http://j-sag.org/Volume4/jsag-1-2012.pdf
). That version can be obtained from the journal (see
http://j-sag.org/Volume4/Binomials.m2 ) or from the Macaulay2 source code
repository (see https://github.com/Macaulay2/M2/blob/
6c927c4f11724e29840c889e5ac7a426b17685ab/M2/Macaulay2/packages/Binomials.m2 ).

Version
=======

This documentation describes version 1.2.1 of Binomials.

Source code
===========

The source code from which this documentation is derived is in the file
Binomials.m2 (see common/share/Macaulay2/Binomials.m2 ).

Exports
=======

  * Types
      * PartialCharacter -- the class of all partial
        characters
  * Functions and commands
      * BCD -- Binomial Cellular Decomposition
      * binomialAssociatedPrimes -- Associated
        primes of a binomial ideal
      * binomialCellularDecomposition, --
        Binomial Cellular Decomposition
      * binomialIsPrimary -- test for primary
        binomial ideals
      * binomialIsPrime -- test for primeness of a
        binomial ideal
      * binomialMinimalPrimes -- minimal primes
        of a binomial Ideal
      * binomialPrimaryDecomposition, --
        Binomial Primary Decomposition
      * binomialRadical -- Radical of a binomial ideal
      * binomialSolve -- solving zero-dimensional
        binomial Ideals
      * binomialUnmixedDecomposition, --
        Binomial Unmixed Decomposition
      * BPD -- Binomial Primary Decomposition
      * BUD -- Binomial Unmixed Decomposition
      * cellularBinomialAssociatedPrimes
        -- Associated primes of a cellular
        binomial ideal
      * cellularBinomialIsPrimary -- test for
        primaryness of a binomial ideal
      * cellularBinomialPrimaryDecomposition
        -- Primary decomposition of a
        cellular binomial ideal
      * cellularBinomialRadical -- Radical of a
        cellular binomial ideal
      * cellularBinomialUnmixedDecomposition
        -- Unmixed decomposition of a
        cellular binomial ideal
      * extractInclusionMinimalIdeals, --
        Extract inclusion minimal ideals from a list of ideals
      * idealFromCharacter -- Generate a lattice
        ideal from a character.
      * isBinomial -- testing for unital binomial ideals
      * "isUnital" -- see isBinomial, -- testing for unital
        binomial ideals
      * isCellular -- testing for cellular binomial ideals
      * latticeBasisIdeal -- construct the ideal
        whose generators correspond to generators of an integer lattice
      * makeBinomial -- make a binomial from an exponent
        vector and a coefficient
      * partialCharacter -- Computing the partial
        character of a cellular binomial ideal
      * randomBinomialIdeal -- Random Binomial
        Ideals
  * Methods
      * "binomialCellularDecomposition(Ideal)" -- see
        binomialCellularDecomposition, --
        Binomial Cellular Decomposition
      * "binomialIsPrime(Ideal)" -- see binomialIsPrime,
        -- test for primeness of a binomial ideal
      * "binomialMinimalPrimes(Ideal)" -- see binomialMinimalPrimes,
        -- minimal primes of a binomial Ideal
      * "binomialPrimaryDecomposition(Ideal)" -- see
        binomialPrimaryDecomposition, -- Binomial
        Primary Decomposition
      * "binomialUnmixedDecomposition(Ideal)" -- see
        binomialUnmixedDecomposition, -- Binomial
        Unmixed Decomposition
      * "cellularBinomialAssociatedPrimes(Ideal)" -- see
        cellularBinomialAssociatedPrimes, --
        Associated primes of a cellular binomial ideal
      * "cellularBinomialIsPrimary(Ideal)" -- see
        cellularBinomialIsPrimary, -- test for
        primaryness of a binomial ideal
      * "cellularBinomialPrimaryDecomposition(Ideal)" -- see
        cellularBinomialPrimaryDecomposition,
        -- Primary decomposition of a
        cellular binomial ideal
      * "cellularBinomialRadical(Ideal)" -- see cellularBinomialRadical,
        -- Radical of a cellular binomial ideal
      * "cellularBinomialUnmixedDecomposition(Ideal)" -- see
        cellularBinomialUnmixedDecomposition,
        -- Unmixed decomposition of a
        cellular binomial ideal
      * "extractInclusionMinimalIdeals(List)" -- see
        extractInclusionMinimalIdeals, --
        Extract inclusion minimal ideals from a list of ideals
      * "idealFromCharacter(Ring,PartialCharacter)" -- see
        idealFromCharacter, -- Generate a lattice ideal
        from a character.
      * "isCellular(Ideal)" -- see isCellular, -- testing for
        cellular binomial ideals
      * "partialCharacter(Ideal)" -- see partialCharacter,
        -- Computing the partial character of a cellular
        binomial ideal
  * Symbols
      * CellVariables -- cellular variables
      * ReturnCellVars -- return the cellular variables
      * ReturnPChars -- return two partial characters
      * ReturnPrimes -- return two associated primes

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

The object Binomials, is a package (Macaulay2Doc).

BCD -- Binomial Cellular Decomposition
**************************************

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

BCD is a synonym for binomialCellularDecomposition.

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

The object BCD, is a function closure (Macaulay2Doc).

binomialAssociatedPrimes -- Associated primes of a binomial ideal
*****************************************************************

Synopsis
========

  * Usage:
        binomialAssociatedPrimes I
  * Inputs:
      * I, a binomial ideal
  * Outputs:
      * the list of associated primes of I

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

First a cellular decomposition is run, then the associated primes of each
cellular component are determined.
+-----------------------------------------------------------------------------+
|i1 : R = QQ[x,y]                                                             |
|                                                                             |
|o1 = R                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : I = ideal(x^2-y,y^2-x)                                                  |
|                                                                             |
|             2       2                                                       |
|o2 = ideal (x  - y, y  - x)                                                  |
|                                                                             |
|o2 : Ideal of R                                                              |
+-----------------------------------------------------------------------------+
|i3 : binomialAssociatedPrimes I                                              |
|Not yet implemented                                                          |
|I will compute a primary decomposition and take radicals!                    |
|Primary Decomposition found, taking radicals now:                            |
|                                                                             |
|o3 = {ideal (y - 1, x - 1), ideal (y - ww , x + ww  + 1), ideal (y + ww  + 1,|
|                                         3        3                    3     |
|     ------------------------------------------------------------------------|
|     x - ww ), ideal (y, x, x, y)}                                           |
|           3                                                                 |
|                                                                             |
|o3 : List                                                                    |
+-----------------------------------------------------------------------------+

See also
========

  * binomialMinimalPrimes -- minimal primes of a
    binomial Ideal
  * cellularBinomialAssociatedPrimes,
    -- Associated primes of a cellular binomial ideal

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

The object binomialAssociatedPrimes, is a
function closure (Macaulay2Doc).

binomialCellularDecomposition -- Binomial Cellular Decomposition
****************************************************************

Synopsis
========

  * Usage:
        binomialCellularDecomposition I
  * Inputs:
      * I, a binomial ideal
  * Optional inputs (Macaulay2Doc),:
      * ReturnCellVars => ..., default value false
      * Verbose,
        => ..., default value false, generate informative output
  * Outputs:
      * a list of cellular ideals whose intersection is I or a list of pairs of
        these ideals and their cellular variables if the option ReturnCellVars
        => true is used

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

A binomial ideal I is called cellular if modulo I every variable in the
polynomial ring is either a non-zerodivisor or nilpotent. This routine returns
a minimal cellular decomposition of a binomial ideal.
+----------------------------------------------------------------------------+
|i1 : R = QQ[x,y,z]                                                          |
|                                                                            |
|o1 = R                                                                      |
|                                                                            |
|o1 : PolynomialRing                                                         |
+----------------------------------------------------------------------------+
|i2 : I = ideal (x*y-z, x*z-y^2)                                             |
|                                                                            |
|                        2                                                   |
|o2 = ideal (x*y - z, - y  + x*z)                                            |
|                                                                            |
|o2 : Ideal of R                                                             |
+----------------------------------------------------------------------------+
|i3 : bcd = binomialCellularDecomposition I                                  |
|                                                                            |
|              2                  2                                          |
|o3 = {ideal (y  - x*z, x*y - z, x  - y), ideal (z, y)}                      |
|                                                                            |
|o3 : List                                                                   |
+----------------------------------------------------------------------------+
|i4 : intersect bcd == I                                                     |
|                                                                            |
|o4 = true                                                                   |
+----------------------------------------------------------------------------+
|i5 : binomialCellularDecomposition (I, ReturnCellVars=>true, Verbose=>false)|
|                                                                            |
|               2                  2                                         |
|o5 = {{ideal (y  - x*z, x*y - z, x  - y), {x, y, z}}, {ideal (z, y), {x}}}  |
|                                                                            |
|o5 : List                                                                   |
+----------------------------------------------------------------------------+
A synonym for this function is BCD.If the option Verbose (Macaulay2Doc),
is set (default), then output about the number of
components found so far will be generated.

See also
========

  * BCD -- Binomial Cellular Decomposition

Ways to use binomialCellularDecomposition :
===========================================

  * "binomialCellularDecomposition(Ideal)"

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

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

binomialIsPrimary -- test for primary binomial ideals
*****************************************************

Synopsis
========

  * Usage:
        binomialIsPrime I
  * Inputs:
      * I, a binomial ideal
  * Outputs:
      * true or false, depending on whether I is a primary binomial ideal

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

A binomial ideal is prime only if it is cellular. If the cellular variables are
known, the function cellularBinomialIsPrimary,
should be used.
+------------------------+
|i1 : R = QQ[x,y,z]      |
|                        |
|o1 = R                  |
|                        |
|o1 : PolynomialRing     |
+------------------------+
|i2 : I = ideal(x-y,z^3) |
|                        |
|                    3   |
|o2 = ideal (x - y, z )  |
|                        |
|o2 : Ideal of R         |
+------------------------+
|i3 : binomialIsPrimary I|
|                        |
|o3 = true               |
+------------------------+

See also
========

  * cellularBinomialIsPrimary -- test for
    primaryness of a binomial ideal
  * CellVariables -- cellular variables

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

The object binomialIsPrimary, is a function closure (Macaulay2Doc).

binomialIsPrime -- test for primeness of a binomial ideal
*********************************************************

Synopsis
========

  * Usage:
        binomialIsPrime I
  * Inputs:
      * I, a binomial ideal
  * Optional inputs (Macaulay2Doc),:
      * CellVariables, => ..., default value null,
        cellular variables
  * Outputs:
      * true or false, depending on whether I is a binomial prime ideal

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

A binomial ideal is prime only if it is cellular. If the cellular variables are
known they can be given via the CellVariables, option.
+---------------------------+
|i1 : R = QQ[x,y]           |
|                           |
|o1 = R                     |
|                           |
|o1 : PolynomialRing        |
+---------------------------+
|i2 : I = ideal(x^2-y,y^2-x)|
|                           |
|             2       2     |
|o2 = ideal (x  - y, y  - x)|
|                           |
|o2 : Ideal of R            |
+---------------------------+
|i3 : binomialIsPrime I     |
|                           |
|o3 = false                 |
+---------------------------+

See also
========

  * cellularBinomialIsPrimary -- test for
    primaryness of a binomial ideal
  * CellVariables -- cellular variables

Ways to use binomialIsPrime :
=============================

  * "binomialIsPrime(Ideal)"

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

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

binomialMinimalPrimes -- minimal primes of a binomial Ideal
***********************************************************

Synopsis
========

  * Usage:
        binomialMinimalPrimes I
  * Inputs:
      * I, a binomial ideal
  * Optional inputs (Macaulay2Doc),:
      * Verbose,
        => ..., default value false, generate informative output
  * Outputs:
      * the list of minimal primes of I

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

The binomial minimal primes of a binomial ideal over QQ exist only in extension
fields.
+-------------------------------------------------+
|i1 : R = QQ[x,y,z]                               |
|                                                 |
|o1 = R                                           |
|                                                 |
|o1 : PolynomialRing                              |
+-------------------------------------------------+
|i2 : I = ideal(y^3,y^2*z^2-x^3,x*y^2*z,x^3*z-x*y)|
|                                                 |
|             3   2 2    3     2    3             |
|o2 = ideal (y , y z  - x , x*y z, x z - x*y)     |
|                                                 |
|o2 : Ideal of R                                  |
+-------------------------------------------------+
|i3 : binomialMinimalPrimes I                     |
|                                                 |
|o3 = {ideal (y, x)}                              |
|                                                 |
|o3 : List                                        |
+-------------------------------------------------+
If the option Verbose (Macaulay2Doc), is set (default), then
output about the number of components found so far will be generated.

See also
========

  * binomialRadical -- Radical of a binomial ideal

Ways to use binomialMinimalPrimes :
===================================

  * "binomialMinimalPrimes(Ideal)"

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

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

binomialPrimaryDecomposition -- Binomial Primary Decomposition
**************************************************************

Synopsis
========

  * Usage:
        binomialPrimaryDecomposition I
  * Inputs:
      * I, a binomial ideal
  * Optional inputs (Macaulay2Doc),:
      * Verbose,
        => ..., default value false, generate informative output
  * Outputs:
      * a list of binomial primary components of I

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

This routine returns a primary decomposition of I into binomial ideals.
+------------------------------------------------------+
|i1 : R = QQ[x,y,z]                                    |
|                                                      |
|o1 = R                                                |
|                                                      |
|o1 : PolynomialRing                                   |
+------------------------------------------------------+
|i2 : I = ideal (x*y-z, x*z-y^2)                       |
|                                                      |
|                        2                             |
|o2 = ideal (x*y - z, - y  + x*z)                      |
|                                                      |
|o2 : Ideal of R                                       |
+------------------------------------------------------+
|i3 : bpd = binomialPrimaryDecomposition I             |
|                                                      |
|              2                  2                    |
|o3 = {ideal (y  - x*z, x*y - z, x  - y), ideal (z, y)}|
|                                                      |
|o3 : List                                             |
+------------------------------------------------------+
|i4 : intersect bpd == I                               |
|                                                      |
|o4 = true                                             |
+------------------------------------------------------+
A synonym for this function is BPD.

Caveat
======

Currently it can not be guaranteed that the decomposition is irredundant,
although serious attempts are made to reduce redundancy.

See also
========

  * BPD -- Binomial Primary Decomposition

Ways to use binomialPrimaryDecomposition :
==========================================

  * "binomialPrimaryDecomposition(Ideal)"

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

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

binomialPrimaryDecomposition(...,Verbose=>...) -- generate informative output
*****************************************************************************

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

If this option is set, functions will generate additional output. Defaults to
false

Further information
===================

  * Default value: false (Macaulay2Doc),
  * Function: binomialPrimaryDecomposition,
    -- Binomial Primary Decomposition
  * Option key: Verbose (Macaulay2Doc), -- request verbose
    feedback

Functions with optional argument named Verbose :
================================================

  * "binomialCellularDecomposition(...,Verbose=>...)"
  * "binomialMinimalPrimes(...,Verbose=>...)"
  * binomialPrimaryDecomposition(...,Verbose=>...),
    --
    generate informative output
  * "binomialUnmixedDecomposition(...,Verbose=>...)"
  * "cellularBinomialAssociatedPrimes(...,Verbose=>...)"
  * "cellularBinomialPrimaryDecomposition(...,Verbose=>...)"
  * "cellularBinomialUnmixedDecomposition(...,Verbose=>...)"
  * "extractInclusionMinimalIdeals(...,Verbose=>...)"
  * "check(...,Verbose=>...)" -- see check (Macaulay2Doc), --
    perform tests of a package
  * "checkDegrees(...,Verbose=>...)" -- see checkDegrees (Isomorphism),
    -- compares the degrees of generators of two
    modules
  * "copyDirectory(...,Verbose=>...)" -- see
    copyDirectory(String,String) (Macaulay2Doc),
  * "copyFile(...,Verbose=>...)" -- see copyFile(String,String) (Macaulay2Doc),
  * "findProgram(...,Verbose=>...)" -- see findProgram (Macaulay2Doc),
    -- load external program
  * "installPackage(...,Verbose=>...)" -- see installPackage (Macaulay2Doc),
    -- load and install a package and its
    documentation
  * "isIsomorphic(...,Verbose=>...)" -- see isIsomorphic (Isomorphism),
    -- Probabilistic test for isomorphism of modules
  * "moveFile(...,Verbose=>...)" -- see moveFile(String,String) (Macaulay2Doc),
  * "runProgram(...,Verbose=>...)" -- see runProgram (Macaulay2Doc),
    -- run an external program
  * "symlinkDirectory(...,Verbose=>...)" -- see
    symlinkDirectory(String,String) (Macaulay2Doc),
    -- make symbolic links
    for all files in a directory tree

binomialRadical -- Radical of a binomial ideal
**********************************************

Synopsis
========

  * Usage:
        binomialRadical I
  * Inputs:
      * I, a binomial ideal
  * Outputs:
      * the radical of I

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

If the input is a cellular binomial ideal then a very fast algorithm is used.
If one knows this and also the cellular variables then
cellularBinomialRadical, should be used.
+-----------------------------------+
|i1 : R = QQ[x,y]                   |
|                                   |
|o1 = R                             |
|                                   |
|o1 : PolynomialRing                |
+-----------------------------------+
|i2 : I = ideal (y^2, x*y-y, x^2-1) |
|                                   |
|             2            2        |
|o2 = ideal (y , x*y - y, x  - 1)   |
|                                   |
|o2 : Ideal of R                    |
+-----------------------------------+
|i3 : binomialRadical I             |
|                                   |
|             2            2        |
|o3 = ideal (y , x*y - y, x  - 1, y)|
|                                   |
|o3 : Ideal of R                    |
+-----------------------------------+

See also
========

  * cellularBinomialRadical -- Radical of a
    cellular binomial ideal

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

The object binomialRadical, is a function closure (Macaulay2Doc).

binomialSolve -- solving zero-dimensional binomial Ideals
*********************************************************

Synopsis
========

  * Usage:
        binomialSolve I
  * Inputs:
      * I, a unital binomial ideal
  * Outputs:
      * the list of points in the zero locus of I in QQ[ww]

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

The solutions of a set of unital binomial equations exist in a cyclotomic
field. This function will compute the variety of a unital binomial ideal and
construct an appropriate cyclotomic field containing the entire variety (as a
subset of the algebraic closure of QQ).
+-------------------------------------------------------------------+
|i1 : R = QQ[x,y,z,w]                                               |
|                                                                   |
|o1 = R                                                             |
|                                                                   |
|o1 : PolynomialRing                                                |
+-------------------------------------------------------------------+
|i2 : I = ideal (x-y,y-z,z*w-1*w,w^2-x)                             |
|                                                                   |
|                                    2                              |
|o2 = ideal (x - y, y - z, z*w - w, w  - x)                         |
|                                                                   |
|o2 : Ideal of R                                                    |
+-------------------------------------------------------------------+
|i3 : dim I                                                         |
|                                                                   |
|o3 = 0                                                             |
+-------------------------------------------------------------------+
|i4 : binomialSolve I                                               |
|                                                                   |
|o4 = {{1, 1, 1, 1}, {1, 1, 1, -1}, {0, 0, 0, 0}}                   |
|                                                                   |
|o4 : List                                                          |
+-------------------------------------------------------------------+
|i5 : J = ideal (x^3-1,y-x,z-1,w-1)                                 |
|                                                                   |
|             3                                                     |
|o5 = ideal (x  - 1, - x + y, z - 1, w - 1)                         |
|                                                                   |
|o5 : Ideal of R                                                    |
+-------------------------------------------------------------------+
|i6 : binomialSolve J                                               |
|                                                                   |
|o6 = {{1, 1, 1, 1}, {ww , ww , 1, 1}, {- ww  - 1, - ww  - 1, 1, 1}}|
|                       3    3              3          3            |
|                                                                   |
|o6 : List                                                          |
+-------------------------------------------------------------------+

Caveat
======

The current implementation can only handle unital binomial ideals.

See also
========

  * Cyclotomic -- cyclotomic fields

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

The object binomialSolve, is a function closure (Macaulay2Doc).

binomialUnmixedDecomposition -- Binomial Unmixed Decomposition
**************************************************************

Synopsis
========

  * Usage:
        binomialUnmixedDecomposition I
  * Inputs:
      * I, a binomial ideal
  * Optional inputs (Macaulay2Doc),:
      * Verbose,
        => ..., default value false, generate informative output
  * Outputs:
      * a list of unmixed components of I

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

This routine returns an unmixed decomposition of a binomial ideal into binomial
ideals. The implemented algorithm is a variant of Algorithm 4 in [OS00].
+----------------------------------------------------+
|i1 : R = QQ[x,y,z]                                  |
|                                                    |
|o1 = R                                              |
|                                                    |
|o1 : PolynomialRing                                 |
+----------------------------------------------------+
|i2 : I = ideal (x^2, x*y, y^2, x*(z^3-1), y*(z^2-1))|
|                                                    |
|             2        2     3         2             |
|o2 = ideal (x , x*y, y , x*z  - x, y*z  - y)        |
|                                                    |
|o2 : Ideal of R                                     |
+----------------------------------------------------+
|i3 : bud = binomialUnmixedDecomposition I           |
|                                                    |
|              2        2     2         3            |
|o3 = {ideal (y , x*y, x , y*z  - y, x*z  - x)}      |
|                                                    |
|o3 : List                                           |
+----------------------------------------------------+
|i4 : intersect bud == I                             |
|                                                    |
|o4 = true                                           |
+----------------------------------------------------+
A synonym for this function is BUD.

Caveat
======

Apart from unmixedness, properties of the output decomposition are defined only
by the course of the algorithm, in particular it is not mesoprimary
decomposition of [KM11].

See also
========

  * BUD -- Binomial Unmixed Decomposition

Ways to use binomialUnmixedDecomposition :
==========================================

  * "binomialUnmixedDecomposition(Ideal)"

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

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

BPD -- Binomial Primary Decomposition
*************************************

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

BPD is a synonym for binomialPrimaryDecomposition.

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

The object BPD, is a function closure (Macaulay2Doc).

BUD -- Binomial Unmixed Decomposition
*************************************

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

BUD is a synonym for binomialUnmixedDecomposition.

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

The object BUD, is a function closure (Macaulay2Doc).

cellularBinomialAssociatedPrimes -- Associated primes of a cellular binomial ideal
**********************************************************************************

Synopsis
========

  * Usage:
        cellularBinomialAssociatedPrimes I
  * Inputs:
      * I, a cellular binomial ideal
  * Optional inputs (Macaulay2Doc),:
      * CellVariables, => ..., default value null,
        cellular variables
      * Verbose,
        => ..., default value false, generate informative output
  * Outputs:
      * the list of associated primes of I

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

If the cell variables are known, they can be given via the option
CellVariables, otherwise they are computed.
+-----------------------------------------------------------+
|i1 : R = QQ[x,y]                                           |
|                                                           |
|o1 = R                                                     |
|                                                           |
|o1 : PolynomialRing                                        |
+-----------------------------------------------------------+
|i2 : I = ideal(x^2-1,y-x)                                  |
|                                                           |
|             2                                             |
|o2 = ideal (x  - 1, - x + y)                               |
|                                                           |
|o2 : Ideal of R                                            |
+-----------------------------------------------------------+
|i3 : cv = isCellular (I,ReturnCellVars=>true)              |
|                                                           |
|o3 = {x, y}                                                |
|                                                           |
|o3 : List                                                  |
+-----------------------------------------------------------+
|i4 : cellularBinomialAssociatedPrimes (I,CellVariables=>cv)|
|                                                           |
|o4 = {ideal (y - 1, x - 1), ideal (y + 1, x + 1)}          |
|                                                           |
|o4 : List                                                  |
+-----------------------------------------------------------+

See also
========

  * binomialAssociatedPrimes -- Associated
    primes of a binomial ideal

Ways to use cellularBinomialAssociatedPrimes :
==============================================

  * "cellularBinomialAssociatedPrimes(Ideal)"

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

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

cellularBinomialIsPrimary -- test for primaryness of a binomial ideal
*********************************************************************

Synopsis
========

  * Usage:
        cellularBinomialIsPrimary I
  * Inputs:
      * I, a binomial ideal
  * Optional inputs (Macaulay2Doc),:
      * CellVariables, => ..., default value null,
        cellular variables
      * ReturnPChars, => ..., default value false, return
        two partial characters
      * ReturnPrimes, => ..., default value false, return
        two associated primes
  * Outputs:
      * true or false, depending on whether I is a binomial primary ideal

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

A binomial ideal is primary only if it is cellular. If the cellular variables
are known they can be given via the CellVariables, option.
If the ideal is not primary, either 'false' or two distinct associated primes
can be returned. The behaviour can be changed using the options
ReturnPrimes, and ReturnPChars.
+-----------------------------------------------------------+
|i1 : R = QQ[x,y]                                           |
|                                                           |
|o1 = R                                                     |
|                                                           |
|o1 : PolynomialRing                                        |
+-----------------------------------------------------------+
|i2 : I = ideal(x^2-1)                                      |
|                                                           |
|            2                                              |
|o2 = ideal(x  - 1)                                         |
|                                                           |
|o2 : Ideal of R                                            |
+-----------------------------------------------------------+
|i3 : cellularBinomialIsPrimary (I,ReturnPrimes=>true)      |
|The radical is not prime, as the character is not saturated|
|                                                           |
|o3 = {ideal (x - 1, x - 1), ideal(x + 1)}                  |
|                                                           |
|o3 : List                                                  |
+-----------------------------------------------------------+

See also
========

  * cellularBinomialIsPrimary -- test for
    primaryness of a binomial ideal
  * CellVariables -- cellular variables
  * ReturnPrimes -- return two associated primes
  * ReturnPChars -- return two partial characters

Ways to use cellularBinomialIsPrimary :
=======================================

  * "cellularBinomialIsPrimary(Ideal)"

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

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

cellularBinomialPrimaryDecomposition -- Primary decomposition of a cellular binomial ideal
******************************************************************************************

Synopsis
========

  * Usage:
        cellularBinomialPrimaryDecomposition I
  * Inputs:
      * I, a cellular binomial ideal
  * Optional inputs (Macaulay2Doc),:
      * CellVariables, => ..., default value null,
        cellular variables
      * Verbose,
        => ..., default value false, generate informative output
  * Outputs:
      * a binomial primary decomposition of I

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

If the cell variables are known, they can be given via the option
CellVariables, otherwise they are computed.
+-----------------------------------------------------------------------------+
|i1 : R = QQ[x,y]                                                             |
|                                                                             |
|o1 = R                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : I = ideal(x^3-1,y-x)                                                    |
|                                                                             |
|             3                                                               |
|o2 = ideal (x  - 1, - x + y)                                                 |
|                                                                             |
|o2 : Ideal of R                                                              |
+-----------------------------------------------------------------------------+
|i3 : cv = isCellular (I,ReturnCellVars=>true)                                |
|                                                                             |
|o3 = {x, y}                                                                  |
|                                                                             |
|o3 : List                                                                    |
+-----------------------------------------------------------------------------+
|i4 : pd = cellularBinomialPrimaryDecomposition (I,CellVariables=>cv)         |
|                                                                             |
|o4 = {ideal (y - 1, x - 1), ideal (y - ww , x - ww ), ideal (y + ww  + 1, x +|
|                                         3        3                3         |
|     ------------------------------------------------------------------------|
|     ww  + 1)}                                                               |
|       3                                                                     |
|                                                                             |
|o4 : List                                                                    |
+-----------------------------------------------------------------------------+
|i5 : mingens \ pd                                                            |
|                                                                             |
|o5 = {| y-1 x-1 |, | y-ww_3 x-ww_3 |, | y+ww_3+1 x+ww_3+1 |}                 |
|                                                                             |
|o5 : List                                                                    |
+-----------------------------------------------------------------------------+

Caveat
======

This function will not return minimal generators for performance reasons.

See also
========

  * binomialAssociatedPrimes -- Associated
    primes of a binomial ideal

Ways to use cellularBinomialPrimaryDecomposition :
==================================================

  * "cellularBinomialPrimaryDecomposition(Ideal)"

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

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

cellularBinomialRadical -- Radical of a cellular binomial ideal
***************************************************************

Synopsis
========

  * Usage:
        cellularBinomialRadical I
  * Inputs:
      * I, a cellular binomial ideal
  * Optional inputs (Macaulay2Doc),:
      * CellVariables, => ..., default value null,
        cellular variables
  * Outputs:
      * the radical of I

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

The radical of a cellular binomial ideal can be determined very quickly. If the
cellular variables are known they can be given as a list via the option
CellVariables.
+--------------------------------------------------+
|i1 : R = QQ[x,y,z]                                |
|                                                  |
|o1 = R                                            |
|                                                  |
|o1 : PolynomialRing                               |
+--------------------------------------------------+
|i2 : I = ideal(y^3,y^2*z^2-x^3,x*y^2*z,x^3*z-x*y) |
|                                                  |
|             3   2 2    3     2    3              |
|o2 = ideal (y , y z  - x , x*y z, x z - x*y)      |
|                                                  |
|o2 : Ideal of R                                   |
+--------------------------------------------------+
|i3 : cv = isCellular (I,ReturnCellVars=>true)     |
|                                                  |
|o3 = {z}                                          |
|                                                  |
|o3 : List                                         |
+--------------------------------------------------+
|i4 : cellularBinomialRadical (I,CellVariables=>cv)|
|                                                  |
|             3   2 2    3     2    3              |
|o4 = ideal (y , y z  - x , x*y z, x z - x*y, x, y)|
|                                                  |
|o4 : Ideal of R                                   |
+--------------------------------------------------+

See also
========

  * binomialRadical -- Radical of a binomial ideal

Ways to use cellularBinomialRadical :
=====================================

  * "cellularBinomialRadical(Ideal)"

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

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

cellularBinomialUnmixedDecomposition -- Unmixed decomposition of a cellular binomial ideal
******************************************************************************************

Synopsis
========

  * Usage:
        cellularBinomialUnmixedDecomposition I
  * Inputs:
      * I, a cellular binomial ideal
  * Optional inputs (Macaulay2Doc),:
      * CellVariables, => ..., default value null,
        cellular variables
      * Verbose,
        => ..., default value false, generate informative output
  * Outputs:
      * an unmixed decomposition of I

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

If the cell variables are known, they can be given via the option
CellVariables, otherwise they are computed.
+--------------------------------------------------------------------+
|i1 : R = QQ[x,y]                                                    |
|                                                                    |
|o1 = R                                                              |
|                                                                    |
|o1 : PolynomialRing                                                 |
+--------------------------------------------------------------------+
|i2 : I = ideal(x*(y^3-1),x^2)                                       |
|                                                                    |
|               3       2                                            |
|o2 = ideal (x*y  - x, x )                                           |
|                                                                    |
|o2 : Ideal of R                                                     |
+--------------------------------------------------------------------+
|i3 : cv = isCellular (I,ReturnCellVars=>true)                       |
|                                                                    |
|o3 = {y}                                                            |
|                                                                    |
|o3 : List                                                           |
+--------------------------------------------------------------------+
|i4 : ud = cellularBinomialUnmixedDecomposition (I,CellVariables=>cv)|
|                                                                    |
|                3       2                                           |
|o4 = {ideal (x*y  - x, x )}                                         |
|                                                                    |
|o4 : List                                                           |
+--------------------------------------------------------------------+

See also
========

  * binomialUnmixedDecomposition, --
    Binomial Unmixed Decomposition

Ways to use cellularBinomialUnmixedDecomposition :
==================================================

  * "cellularBinomialUnmixedDecomposition(Ideal)"

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

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

CellVariables -- cellular variables
***********************************

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

The cellular variables of a binomial ideal are the variables which are
non-zerodivisors modulo that ideal. With this option these variables, if known
in advance, can be handed over to specialized functions for cellular ideals.

See also
========

  * cellularBinomialPrimaryDecomposition
    -- Primary decomposition of a
    cellular binomial ideal
  * cellularBinomialAssociatedPrimes,
    -- Associated primes of a cellular binomial ideal

Functions with optional argument named CellVariables :
======================================================

  * "binomialIsPrime(...,CellVariables=>...)"
  * "cellularBinomialAssociatedPrimes(...,CellVariables=>...)"
  * "cellularBinomialIsPrimary(...,CellVariables=>...)"
  * "cellularBinomialPrimaryDecomposition(...,CellVariables=>...)"
  * "cellularBinomialRadical(...,CellVariables=>...)"
  * "cellularBinomialUnmixedDecomposition(...,CellVariables=>...)"
  * "partialCharacter(...,CellVariables=>...)"

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

The object CellVariables, is a symbol (Macaulay2Doc).

extractInclusionMinimalIdeals -- Extract inclusion minimal ideals from a list of ideals
***************************************************************************************

Synopsis
========

  * Usage:
        extractInclusionMinimalIdeals L
  * Inputs:
      * L, a list of ideals
  * Optional inputs (Macaulay2Doc),:
      * Verbose,
        => ..., default value false, generate informative output
  * Outputs:
      * the list with some redundant ideals removed

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

+---------------------------------------------------------+
|i1 : R = QQ[a,b]                                         |
|                                                         |
|o1 = R                                                   |
|                                                         |
|o1 : PolynomialRing                                      |
+---------------------------------------------------------+
|i2 : L = {ideal(a^4),ideal(a^3),ideal(a^5),ideal(b^2*a) }|
|                                                         |
|             4         3         5           2           |
|o2 = {ideal a , ideal a , ideal a , ideal(a*b )}         |
|                                                         |
|o2 : List                                                |
+---------------------------------------------------------+
|i3 : extractInclusionMinimalIdeals L                     |
|                                                         |
|             5           2                               |
|o3 = {ideal a , ideal(a*b )}                             |
|                                                         |
|o3 : List                                                |
+---------------------------------------------------------+
This function is mostly for internal purposes.

Caveat
======

The resulting list may be not irredundant, because I_1 \subset I_2 \cap I_3 is
not checked.

Ways to use extractInclusionMinimalIdeals :
===========================================

  * "extractInclusionMinimalIdeals(List)"

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

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

idealFromCharacter -- Generate a lattice ideal from a character.
****************************************************************

Synopsis
========

  * Usage:
        idealFromCharacter (R, rho)
  * Inputs:
      * R, a ring to contain the output ideal
      * rho, a partialCharacter,
  * Outputs:
      * the lattice ideal corresponding to rho

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

+------------------------------------------------+
|i1 : R = QQ[x,y]                                |
|                                                |
|o1 = R                                          |
|                                                |
|o1 : PolynomialRing                             |
+------------------------------------------------+
|i2 : I = ideal(x^3-1,y-x)                       |
|                                                |
|             3                                  |
|o2 = ideal (x  - 1, - x + y)                    |
|                                                |
|o2 : Ideal of R                                 |
+------------------------------------------------+
|i3 : cv = isCellular (I,ReturnCellVars=>true)   |
|                                                |
|o3 = {x, y}                                     |
|                                                |
|o3 : List                                       |
+------------------------------------------------+
|i4 : pc = partialCharacter (I,CellVariables=>cv)|
|                                                |
|o4 = PartialCharacter{"c" => {1, 1}  }          |
|                      "J" => {x, y}             |
|                      "L" => | 1  0 |           |
|                             | -1 3 |           |
|                                                |
|o4 : PartialCharacter                           |
+------------------------------------------------+
|i5 : idealFromCharacter (R,pc) == I             |
|                                                |
|o5 = true                                       |
+------------------------------------------------+

Caveat
======

The variables occurring in rho#"J" must be variables of R.

Ways to use idealFromCharacter :
================================

  * "idealFromCharacter(Ring,PartialCharacter)"

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

The object idealFromCharacter, is a method function (Macaulay2Doc).

isBinomial -- testing for unital binomial ideals
************************************************

Synopsis
========

  * Usage:
        isBinomial I; isUnital I
  * Inputs:
      * I, an ideal
  * Outputs:
      * true if I is binomial, or unital respectively.

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

+------------------------------+
|i1 : R = QQ[x,y,z]            |
|                              |
|o1 = R                        |
|                              |
|o1 : PolynomialRing           |
+------------------------------+
|i2 : isBinomial ideal(x^2)    |
|                              |
|o2 = true                     |
+------------------------------+
|i3 : isBinomial ideal(x-y+z,z)|
|                              |
|o3 = true                     |
+------------------------------+
|i4 : isBinomial ideal(x^3-x)  |
|                              |
|o4 = true                     |
+------------------------------+
|i5 : isUnital ideal (x-z,z-y) |
|                              |
|o5 = true                     |
+------------------------------+
|i6 : isUnital ideal (x+z)     |
|                              |
|o6 = false                    |
+------------------------------+
|i7 : isUnital ideal (x^2)     |
|                              |
|o7 = true                     |
+------------------------------+

See also
========

  * isCellular -- testing for cellular binomial ideals

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

The object isBinomial, is a function closure (Macaulay2Doc).

isCellular -- testing for cellular binomial ideals
**************************************************

Synopsis
========

  * Usage:
        isCellular I
  * Inputs:
      * I, a binomial ideal
  * Optional inputs (Macaulay2Doc),:
      * ReturnCellVars, => ..., default value false,
        return the cellular variables
  * Outputs:
      * true, or the list of cell variables if I is cellular, false otherwise.

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

This function is the standard way to compute the cellular variables.
+-----------------------------------------+
|i1 : R = QQ[x,y,z]                       |
|                                         |
|o1 = R                                   |
|                                         |
|o1 : PolynomialRing                      |
+-----------------------------------------+
|i2 : I = ideal (x-z^2,y^4)               |
|                                         |
|               2       4                 |
|o2 = ideal (- z  + x, y )                |
|                                         |
|o2 : Ideal of R                          |
+-----------------------------------------+
|i3 : isCellular I                        |
|                                         |
|o3 = true                                |
+-----------------------------------------+
|i4 : isCellular (I, ReturnCellVars=>true)|
|                                         |
|o4 = {x, z}                              |
|                                         |
|o4 : List                                |
+-----------------------------------------+

See also
========

  * cellularBinomialAssociatedPrimes,
    -- Associated primes of a cellular binomial ideal
  * binomialCellularDecomposition, --
    Binomial Cellular Decomposition

Ways to use isCellular :
========================

  * "isCellular(Ideal)"

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

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

latticeBasisIdeal -- construct the ideal whose generators correspond to generators of an integer lattice
********************************************************************************************************

Synopsis
========

  * Usage:
        latticeBasisIdeal (R,L)
  * Inputs:
      * R, a ring
      * L, an integer matrix whose columns span the lattice.
  * Outputs:
      * The unital lattice basis ideal in R, defined by L

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

This function is only a very simple wrapper around makeBinomial,
+------------------------------------+
|i1 : R = QQ[x,y,z]                  |
|                                    |
|o1 = R                              |
|                                    |
|o1 : PolynomialRing                 |
+------------------------------------+
|i2 : L = matrix {{1,1},{-3,0},{0,1}}|
|                                    |
|o2 = | 1  1 |                       |
|     | -3 0 |                       |
|     | 0  1 |                       |
|                                    |
|              3        2            |
|o2 : Matrix ZZ  <--- ZZ             |
+------------------------------------+
|i3 : latticeBasisIdeal (R, L)       |
|                                    |
|               3                    |
|o3 = ideal (- y  + x, x*z - 1)      |
|                                    |
|o3 : Ideal of R                     |
+------------------------------------+

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

The object latticeBasisIdeal, is a function closure (Macaulay2Doc).

makeBinomial -- make a binomial from an exponent vector and a coefficient
*************************************************************************

Synopsis
========

  * Usage:
        makeBinomial (R,m,c)
  * Inputs:
      * R, a ring
      * m, a vector of exponents, one for each generator of R
      * c, an element of the coefficient ring of R
  * Outputs:
      * The binomial defined by the input data, as an element of R.

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

+------------------------------------+
|i1 : R = QQ[x,y,z]                  |
|                                    |
|o1 = R                              |
|                                    |
|o1 : PolynomialRing                 |
+------------------------------------+
|i2 : makeBinomial (R, [1,-1,-2], 10)|
|                                    |
|            2                       |
|o2 = - 10y*z  + x                   |
|                                    |
|o2 : R                              |
+------------------------------------+

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

The object makeBinomial, is a function closure (Macaulay2Doc).

PartialCharacter -- the class of all partial characters
*******************************************************

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

In Binomials, the partial character of a cellular binomial ideal is
represented as an object of class PartialCharacter.
It contains the following three data:
  * J -- the cellular variables
  * L -- a matrix whose columns are generators for the lattice
  * c -- the list of values the character takes on the generators

Methods that use an object of class PartialCharacter :
======================================================

  * "idealFromCharacter(Ring,PartialCharacter)" -- see
    idealFromCharacter, -- Generate a lattice ideal from a
    character.

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

The object PartialCharacter, is a type (Macaulay2Doc),
with ancestor classes HashTable (Macaulay2Doc),
< Thing (Macaulay2Doc).

partialCharacter -- Computing the partial character of a cellular binomial ideal
********************************************************************************

Synopsis
========

  * Usage:
        partialCharacter I
  * Inputs:
      * I, a cellular binomial ideal
  * Optional inputs (Macaulay2Doc),:
      * CellVariables, => ..., default value null,
        cellular variables
  * Outputs:
      * the PartialCharacter,

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

If the cell variables are known, they can be given via the option
CellVariables, otherwise they are computed.
+------------------------------------------------+
|i1 : R = QQ[x,y]                                |
|                                                |
|o1 = R                                          |
|                                                |
|o1 : PolynomialRing                             |
+------------------------------------------------+
|i2 : I = ideal(x^3-1,y-x)                       |
|                                                |
|             3                                  |
|o2 = ideal (x  - 1, - x + y)                    |
|                                                |
|o2 : Ideal of R                                 |
+------------------------------------------------+
|i3 : cv = isCellular (I,ReturnCellVars=>true)   |
|                                                |
|o3 = {x, y}                                     |
|                                                |
|o3 : List                                       |
+------------------------------------------------+
|i4 : pc = partialCharacter (I,CellVariables=>cv)|
|                                                |
|o4 = PartialCharacter{"c" => {1, 1}  }          |
|                      "J" => {x, y}             |
|                      "L" => | 1  0 |           |
|                             | -1 3 |           |
|                                                |
|o4 : PartialCharacter                           |
+------------------------------------------------+

Caveat
======

If the input is not cellular the behaviour is undefined. Cellularity is not
checked.

Ways to use partialCharacter :
==============================

  * "partialCharacter(Ideal)"

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

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

randomBinomialIdeal -- Random Binomial Ideals
*********************************************

Synopsis
========

  * Usage:
        randomBinomialIdeal (R,n,d,w,h)
  * Inputs:
      * I, a ring for the output
      * n, number of generators of the output
      * d, maximum degree of each variable
      * w, number of variables in each generator
      * h, should the generators be 'as homogeneous as possible'
  * Outputs:
      * a random ideal

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

The exponents are drawn at random from {-d,...,d}. All coefficients are set to
1.
+-----------------------------------------------------------------------------+
|i1 : R = QQ[a..x]                                                            |
|                                                                             |
|o1 = R                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : randomBinomialIdeal (R,6,2,4,true)                                      |
|                                                                             |
|                          2    2    2     2      2     2   2 2      2        |
|o2 = ideal (g*n - c*p, g*t  - r u, b c - h p, f*u x - a , a k  - b*o ,       |
|     ------------------------------------------------------------------------|
|        2          2 2 2                                                     |
|     h*j m*w - 1, p r u v - 1)                                               |
|                                                                             |
|o2 : Ideal of R                                                              |
+-----------------------------------------------------------------------------+
|i3 : randomBinomialIdeal (R,3,4,10,false)                                    |
|                                                                             |
|             4 3 4   3    2 3 2 3 3   4   4 2 3 4 2    3 3 3   4 3 2 3 2 3 4 |
|o3 = ideal (e i l m*s  - j k p q r , b k*o p u v x  - a g q , d j n o q t w  |
|     ------------------------------------------------------------------------|
|        2 3 4   3 3 2 2 3 2 3 3 3    3                                       |
|     - g i l , b d e f l o q s t  - p )                                      |
|                                                                             |
|o3 : Ideal of R                                                              |
+-----------------------------------------------------------------------------+
This function is mostly for internal testing purposes. Don't expect anything
from it.

Caveat
======

Minimal generators are produced. These can be less than n and of higher degree.
They also need not be homogeneous.

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

The object randomBinomialIdeal, is a function closure (Macaulay2Doc).

ReturnCellVars -- return the cellular variables
***********************************************

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

The cellular variables of a binomial ideal are the variables which are
non-zerodivisors module that ideal. If this option is set to 'true' then
binomialCellularDecomposition will return the set of variables for each of its
outputs
+--------------------------------------------------------------------------+
|i1 : R = QQ[x,y,z]                                                        |
|                                                                          |
|o1 = R                                                                    |
|                                                                          |
|o1 : PolynomialRing                                                       |
+--------------------------------------------------------------------------+
|i2 : I = ideal (x*y-z, x*z-y^2)                                           |
|                                                                          |
|                        2                                                 |
|o2 = ideal (x*y - z, - y  + x*z)                                          |
|                                                                          |
|o2 : Ideal of R                                                           |
+--------------------------------------------------------------------------+
|i3 : bcd = binomialCellularDecomposition (I,ReturnCellVars=>true)         |
|                                                                          |
|               2                  2                                       |
|o3 = {{ideal (y  - x*z, x*y - z, x  - y), {x, y, z}}, {ideal (z, y), {x}}}|
|                                                                          |
|o3 : List                                                                 |
+--------------------------------------------------------------------------+

Functions with optional argument named ReturnCellVars :
=======================================================

  * "binomialCellularDecomposition(...,ReturnCellVars=>...)" -- see
    binomialCellularDecomposition, -- Binomial
    Cellular Decomposition
  * "isCellular(...,ReturnCellVars=>...)"

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

The object ReturnCellVars, is a symbol (Macaulay2Doc).

ReturnPChars -- return two partial characters
*********************************************

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

If cellularBinomialIsPrimary does not return true it can either return 'false'
or two associated primes. If this option is set then two partial characters of
distinct associated primes are returned. If ReturnPrimes is set too, then
partial characters will be returned.
+-----------------------------------------------------------+
|i1 : R = QQ[x]                                             |
|                                                           |
|o1 = R                                                     |
|                                                           |
|o1 : PolynomialRing                                        |
+-----------------------------------------------------------+
|i2 : I = ideal (x^2-1)                                     |
|                                                           |
|            2                                              |
|o2 = ideal(x  - 1)                                         |
|                                                           |
|o2 : Ideal of R                                            |
+-----------------------------------------------------------+
|i3 : cellularBinomialIsPrimary (I,ReturnPChars=>true)      |
|The radical is not prime, as the character is not saturated|
|                                                           |
|o3 = {{{x}, | 1 |, {1}}, {{x}, | 1 |, {-1}}}               |
|                                                           |
|o3 : List                                                  |
+-----------------------------------------------------------+

See also
========

  * ReturnPrimes -- return two associated primes
  * cellularBinomialIsPrimary -- test for
    primaryness of a binomial ideal

Functions with optional argument named ReturnPChars :
=====================================================

  * "cellularBinomialIsPrimary(...,ReturnPChars=>...)"

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

The object ReturnPChars, is a symbol (Macaulay2Doc).

ReturnPrimes -- return two associated primes
********************************************

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

If cellularBinomialIsPrimary does not return true it can either return 'false'
or two associated primes. If this option is set then two associated primes are
returned. If ReturnPChars is set too, then partial characters will be returned.
+-----------------------------------------------------------+
|i1 : R = QQ[x,y,z]                                         |
|                                                           |
|o1 = R                                                     |
|                                                           |
|o1 : PolynomialRing                                        |
+-----------------------------------------------------------+
|i2 : I = ideal (x^2-1)                                     |
|                                                           |
|            2                                              |
|o2 = ideal(x  - 1)                                         |
|                                                           |
|o2 : Ideal of R                                            |
+-----------------------------------------------------------+
|i3 : cellularBinomialIsPrimary (I,ReturnPrimes=>true)      |
|The radical is not prime, as the character is not saturated|
|                                                           |
|o3 = {ideal (x - 1, x - 1), ideal(x + 1)}                  |
|                                                           |
|o3 : List                                                  |
+-----------------------------------------------------------+

See also
========

  * ReturnPChars -- return two partial characters
  * cellularBinomialIsPrimary -- test for
    primaryness of a binomial ideal

Functions with optional argument named ReturnPrimes :
=====================================================

  * "cellularBinomialIsPrimary(...,ReturnPrimes=>...)"

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

The object ReturnPrimes, is a symbol (Macaulay2Doc).