This is MixedMultiplicity.info, produced by Macaulay2, version 1.20

MixedMultiplicity -- Calculate mixed multiplicities, mixed volume and sectional Milnor numbers
**********************************************************************************************

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

P. B. Bhattacharya and J. J. Risler - B. Teissier proved that if
$I_0,I_1,...,I_r$ are $m$-primary ideals in a Noetherian local ring $(R,m)$ of
dimension $d$, then the function $B(u_0,u_1,...,u_r) =
l(R/I_0^{u_0}I_1^{u_1}...I_r^{u_r})$ is a polynomial function in
$u_0,u_1,...,u_r$ of degree $d.$ The coefficients of the top degree term are
called the mixed multiplicities of the ideals $I_0,I_1,...,I_r.$ This result
was generalized for ideals of positive height in the works of D. Katz, J. K.
Verma and N. V. Trung. D. Rees studied these numbers using complete and joint
reductions of ideals.

Our algorithm requires computation of the defining ideal of the multi-Rees
algebra of ideals. An expression of the defining ideal of the multi-Rees
algebra of monomial ideals over a polynomial ring was given by D. Cox, K.-i.
Lin and G. Sosa in (Multi-Rees algebras and toric dynamical systems. Proc.
Amer. Math. Soc., 147(11):4605-4616, 2019). We use a generalization of their
result for ideals over a polynomial ring.

The computation of mixed multiplicities helps compute mixed volume of a
collection of lattice polytopes and also the sectional Milnor numbers of
hypersurfaces with an isolated singularity.

Let $Q_1,...,Q_n$ be a collection of lattice polytopes in $\mathbb{R}^n$ and
$t_1,...,t_n \in \mathbb{R}_+$. Minkowski proved that the $n$-dimensional
volume, $vol_n(t_1Q_1 + ... + t_nQ_n)$ is a homogeneous polynomial of degree
$n$ in $t_1,...,t_n.$ The coefficient of $t_1...t_n$ is called the mixed volume
of $Q_1,...,Q_n.$ N. V. Trung and J. K. Verma proved that the mixed volume of
lattice polytopes in the above setup can be realized as a mixed multiplicity of
the homogeneous ideals corresponding to the lattice polytopes.

Let origin be an isolated singular point of a complex analytic hypersurface $H
= V(f).$ The $\mathbb{C}$-vector space dimension of
$\mathbb{C}\{x_0,...,x_n\}/(f_{x_0},...,f_{x_n})$ is called the Milnor number
of the hypersurface $H$ at the origin. Let $(X, x)$ be a germ of a hypersurface
in $\mathbb{C}^{n+1}$ with an isolated singularity. The Milnor number of $X
\cap E$, where $E$ is a general linear subspace of dimension $i$ passing
through $x$ is called the $i$-th sectional Milnor number of $X$. B. Teissier
identified the $i$-th sectional Milnor number with the $i$-th mixed
multiplicity of the maximal homogeneous ideal of the polynomial ring and the
Jacobian ideal of $f.$

Authors
=======

  * Kriti Goel (see https://sites.google.com/view/kritigoel )
    <kritigoel.maths@gmail.com>
  * Sudeshna Roy (see https://sites.google.com/site/sudeshnaroy11 )
    <sudeshnaroy@math.iitb.ac.in>
  * J. K. Verma (see https://sites.google.com/site/profjkvermaiitbombay/ )
    <jkv@math.iitb.ac.in>

Version
=======

This documentation describes version 1.0 of MixedMultiplicity.

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

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

Exports
=======

  * Functions and commands
      * homIdealPolytope -- Compute the homogeneous
        ideal corresponding to the vertices of a lattice polytope in
        $\mathbb{R}^n$.
      * mixedMultiplicity -- Compute a given mixed
        multiplicity of ideals in a polynomial ring.
      * mixedVolume -- Compute the mixed volume of a
        collection of lattice polytopes
      * multiReesIdeal -- Compute the defining ideal of
        multi-Rees algebra of ideals
      * secMilnorNumbers -- Compute the sectional
        Milnor numbers of a hypersurface with an isolated singularity

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

The object MixedMultiplicity, is a package (Macaulay2Doc).

homIdealPolytope -- Compute the homogeneous ideal corresponding to the vertices of a lattice polytope in $\mathbb{R}^n$.
************************************************************************************************************************

Synopsis
========

  * Usage:
        homIdealPolytope W
  * Inputs:
      * W, a list (Macaulay2Doc), list ${p_1,...,p_r}$, where
        $p_1,...,p_r$ are vertices of the polytope.
  * Optional inputs (Macaulay2Doc),:
      * CoefficientRing,
        => ...,
        default value QQ, Choose a coefficient ring of the (output) ideal
      * VariableBaseName,
        => ...,
        default value "X", Choose a base name for variables in the created ring
  * Outputs:
      * an ideal (Macaulay2Doc), A homogeneous ideal of
        $k[x_1,...,x_{n+1}].$

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

Given a list of vertices of a lattice polytope, the command outputs a
homogeneous ideal of $k[x_1,...,x_{n+1}]$ such that the polytope is the convex
hull of the lattice points of the dehomogenization of a set of monomials that
generates the ideal in $k[x_1,...,x_n]$. The following example computes the
homogeneous ideal corresponding to a 2-cross polytope.

+---------------------------------------------------+
|i1 : I = homIdealPolytope {(0,1),(1,0),(2,1),(1,2)}|
|                                                   |
|             2       2     2     2                 |
|o1 = ideal (X X , X X , X X , X X )                |
|             1 2   1 2   1 3   2 3                 |
|                                                   |
|o1 : Ideal of QQ[X ..X ]                           |
|                  1   3                            |
+---------------------------------------------------+

Ways to use homIdealPolytope :
==============================

  * homIdealPolytope(List) (missing documentation)

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

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

homIdealPolytope(...,CoefficientRing=>...) -- Choose a coefficient ring of the (output) ideal
*********************************************************************************************

Synopsis
========

  * Usage:
        homIdealPolytope(..., CoefficientRing => QQ)
        mixedVolume(..., CoefficientRing => QQ)

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

The function homIdealPolytope, creates a new ring of
the form $k[X_0,\ldots, X_r]$, where $k$ is the coefficient ring of the output
ideal. This option allows the user to chose the coefficient ring $k.$ The
default ring is QQ.

+-----------------------------------------------------------------------------+
|i1 : I = homIdealPolytope ({(0,1),(1,0),(2,1),(1,2)}, CoefficientRing =>     |
|                                                                             |
|             2       2     2     2                                           |
|o1 = ideal (X X , X X , X X , X X )                                          |
|             1 2   1 2   1 3   2 3                                           |
|                                                                             |
|              ZZ                                                             |
|o1 : Ideal of --[X ..X ]                                                     |
|               2  1   3                                                      |
|-----------------------------------------------------------------------------|
|ZZ/2)                                                                        |
+-----------------------------------------------------------------------------+

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

  * Default value: QQ (Macaulay2Doc),
  * Function: homIdealPolytope, -- Compute the
    homogeneous ideal corresponding to the vertices of a lattice polytope in
    $\mathbb{R}^n$.
  * Option key: CoefficientRing (Macaulay2Doc), -- an
    optional argument

Functions with optional argument named CoefficientRing :
========================================================

  * flattenRing(...,CoefficientRing=>...) (Macaulay2Doc),
    --
    optionally specify the desired coefficient ring of the flattened ring
  * "generators(...,CoefficientRing=>...)" -- see generators(Ring) (Macaulay2Doc),
    -- the list of generators of a ring
  * "Grassmannian(...,CoefficientRing=>...)" -- see Grassmannian(ZZ,ZZ) (Macaulay2Doc),
    -- the Grassmannian of linear
    subspaces of a vector space
  * homIdealPolytope(...,CoefficientRing=>...)
    -- Choose a
    coefficient ring of the (output) ideal
  * "mixedVolume(...,CoefficientRing=>...)"
  * "Schubert(...,CoefficientRing=>...)" -- see
    Schubert(ZZ,ZZ,VisibleList) (Macaulay2Doc),
    -- find the Plücker
    ideal of a Schubert variety

mixedMultiplicity -- Compute a given mixed multiplicity of ideals in a polynomial ring.
***************************************************************************************

Synopsis
========

  * Usage:
        mixedMultiplicity (W1, W2)
  * Inputs:
      * W1, a sequence (Macaulay2Doc), sequence of ideals
        $I_0,...,I_r$ over a polynomial ring.
      * W2, a sequence (Macaulay2Doc), tuple $a=(a_0,...,a_r)$
        at which the mixed multiplicity is calculated
  * Optional inputs (Macaulay2Doc),:
      * BasisElementLimit,
        => ...,
        default value infinity, Bound the number of Groebner basis elements to
        compute in the saturation step
      * DegreeLimit,
        => ..., default value {}, Bound the degrees considered in the
        saturation step.
      * MinimalGenerators,
        => ...,
        default value true, Whether the saturation step returns minimal
        generators
      * PairLimit,
        => ..., default value infinity, Bound the number of s-pairs considered
        in the saturation step
      * Strategy, =>
        ..., default value null, Choose a strategy for the saturation step
  * Outputs:
      * an integer (Macaulay2Doc), mixed multiplicity $e_a$ of ideals
        $I_0,...,I_r$.

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

Given the ideals $I_0,...,I_r$ in a polynomial ring $R$ and the tuple $a =
(a_0,...,a_r) \in \mathbb{N}^{r+1}$ such that $I_0$ is primary to the maximal
homogeneous ideal of $R$, $I_1,...,I_r$ have positive height and $a_0+...+a_r =
dim R -1$, the command computes the mixed multiplicity $e_a$ of the ideals.

+-------------------------------------------------+
|i1 : R = QQ[x,y,z,w]                             |
|                                                 |
|o1 = R                                           |
|                                                 |
|o1 : PolynomialRing                              |
+-------------------------------------------------+
|i2 : I = ideal(x*y*w^3,x^2*y*w^2,x*y^3*w,x*y*z^3)|
|                                                 |
|                 3   2   2     3        3        |
|o2 = ideal (x*y*w , x y*w , x*y w, x*y*z )       |
|                                                 |
|o2 : Ideal of R                                  |
+-------------------------------------------------+
|i3 : m = ideal vars R;                           |
|                                                 |
|o3 : Ideal of R                                  |
+-------------------------------------------------+
|i4 : mixedMultiplicity ((m,I,I,I),(0,1,1,1))     |
|                                                 |
|o4 = 6                                           |
+-------------------------------------------------+

The function computes the Hilbert polynomial of the graded ring $\oplus
I_0^{u_0}I_1^{u_1}...I_r^{u_r}/I_0^{u_0+1}I_1^{u_1}...I_r^{u_r}$ to calculate
the mixed multiplicity. This setup enforces $a_0 \neq 0.$ Due to the same
reason, to compute the $(a_0+1, a_1,..., a_r)$-th mixed multiplicity, one needs
to enter the sequence ${a_0,a_1,...,a_r}$ in the function. The same is
illustrated in the following example.

+---------------------------------------------+
|i5 : R = QQ[x,y,z]                           |
|                                             |
|o5 = R                                       |
|                                             |
|o5 : PolynomialRing                          |
+---------------------------------------------+
|i6 : m = ideal vars R                        |
|                                             |
|o6 = ideal (x, y, z)                         |
|                                             |
|o6 : Ideal of R                              |
+---------------------------------------------+
|i7 : f = z^5 + x*y^7 + x^15                  |
|                                             |
|      15      7    5                         |
|o7 = x   + x*y  + z                          |
|                                             |
|o7 : R                                       |
+---------------------------------------------+
|i8 : I = ideal(apply(0..2, i -> diff(R_i,f)))|
|                                             |
|               14    7      6    4           |
|o8 = ideal (15x   + y , 7x*y , 5z )          |
|                                             |
|o8 : Ideal of R                              |
+---------------------------------------------+
|i9 : mixedMultiplicity ((m,I),(2,0))         |
|                                             |
|o9 = 1                                       |
+---------------------------------------------+
|i10 : mixedMultiplicity ((m,I),(1,1))        |
|                                             |
|o10 = 4                                      |
+---------------------------------------------+

Ways to use mixedMultiplicity :
===============================

  * mixedMultiplicity(Sequence,Sequence) (missing documentation)

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

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

mixedVolume -- Compute the mixed volume of a collection of lattice polytopes
****************************************************************************

Synopsis
========

  * Usage:
        mixedVolume W
  * Inputs:
      * W, a list (Macaulay2Doc), list of homogeneous ideals
        $I_1,...,I_n$ over a polynomial ring, or a list of lists of vertices of
        the polytopes
  * Optional inputs (Macaulay2Doc),:
      * BasisElementLimit,
        => ...,
        default value infinity, Bound the number of Groebner basis elements to
        compute in the saturation step
      * CoefficientRing,
        => ...,
        default value QQ, Choose a coefficient ring of the (output) ideal
      * DegreeLimit,
        => ..., default value {}, Bound the degrees considered in the
        saturation step.
      * MinimalGenerators,
        => ...,
        default value true, Whether the saturation step returns minimal
        generators
      * PairLimit,
        => ..., default value infinity, Bound the number of s-pairs considered
        in the saturation step
      * Strategy, =>
        ..., default value null, Choose a strategy for the saturation step
      * VariableBaseName,
        => ...,
        default value "X", Choose a base name for variables in the created ring
  * Outputs:
      * an integer (Macaulay2Doc), mixed volume

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

Let $Q_1,...,Q_n$ be a collection of lattice polytopes in $\mathbb{R}^n$ and
let $I_1,...,I_n$ be homogeneous ideals in a polynomial ring over the field of
rational numbers, corresponding to the given polytopes. These ideals can be
obtained using the command homIdealPolytope. The mixed
volume is calculated by computing a mixed multiplicity of these ideals.

The following example computes the mixed volume of three 3-cross polytopes.

+---------------------------------------------------------------------------+
|i1 : I = homIdealPolytope {(0,1,1),(1,0,1),(1,1,0),(2,1,1),(1,2,1),(1,1,2)}|
|                                                                           |
|             2         2         2       2       2       2                 |
|o1 = ideal (X X X , X X X , X X X , X X X , X X X , X X X )                |
|             1 2 3   1 2 3   1 2 3   1 2 4   1 3 4   2 3 4                 |
|                                                                           |
|o1 : Ideal of QQ[X ..X ]                                                   |
|                  1   4                                                    |
+---------------------------------------------------------------------------+
|i2 : mixedVolume {I,I,I}                                                   |
|                                                                           |
|o2 = 8                                                                     |
+---------------------------------------------------------------------------+

One can also compute the mixed volume of a collection of lattice polytopes by
directly entering the vertices of the polytopes. Mixed Volume in the above
example can also be computed as follows.

+-----------------------------------------------------------------------+
|i3 : C = {(0,1,1),(1,0,1),(1,1,0),(2,1,1),(1,2,1),(1,1,2)}             |
|                                                                       |
|o3 = {(0, 1, 1), (1, 0, 1), (1, 1, 0), (2, 1, 1), (1, 2, 1), (1, 1, 2)}|
|                                                                       |
|o3 : List                                                              |
+-----------------------------------------------------------------------+
|i4 : mixedVolume {C,C,C}                                               |
|                                                                       |
|o4 = 8                                                                 |
+-----------------------------------------------------------------------+

Ways to use mixedVolume :
=========================

  * mixedVolume(List) (missing documentation)

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

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

multiReesIdeal -- Compute the defining ideal of multi-Rees algebra of ideals
****************************************************************************

Synopsis
========

  * Usage:
        multiReesIdeal W
  * Inputs:
      * W, a list (Macaulay2Doc), list of ideals $I_1,...,I_n$ over
        a polynomial ring.
  * Optional inputs (Macaulay2Doc),:
      * BasisElementLimit,
        => ...,
        default value infinity, Bound the number of Groebner basis elements to
        compute in the saturation step
      * DegreeLimit,
        => ..., default value {}, Bound the degrees considered in the
        saturation step.
      * MinimalGenerators,
        => ...,
        default value true, Whether the saturation step returns minimal
        generators
      * PairLimit,
        => ..., default value infinity, Bound the number of s-pairs considered
        in the saturation step
      * Strategy, =>
        ..., default value null, Choose a strategy for the saturation step
      * VariableBaseName,
        => ...,
        default value "X", Choose a base name for variables in the created ring
  * Outputs:
      * an ideal (Macaulay2Doc), defining ideal of the multi-Rees
        algebra of $I_1,...,I_n$.

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

The function computes the defining ideal of the multi-Rees algebra of a set of
ideals over a polynomial ring by computing the saturation of a binomial ideal
with respect to a polynomial. The technique is a generalization of a result of
D. Cox, K.-i. Lin and G. Sosa for monomial ideals over a polynomial ring.

+-----------------------------------------------------------------------------+
|i1 : S = QQ[x_0..x_3]                                                        |
|                                                                             |
|o1 = S                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : C = trim monomialCurveIdeal(S,{2,3,5})                                  |
|                                                                             |
|                          3    2     3      2                                |
|o2 = ideal (x x  - x x , x  - x x , x  - x x )                               |
|             1 2    0 3   2    1 3   1    0 2                                |
|                                                                             |
|o2 : Ideal of S                                                              |
+-----------------------------------------------------------------------------+
|i3 : multiReesIdeal {C}                                                      |
|                                                                             |
|             2                   2                    3      2          3    |
|o3 = ideal (x X  - x X  - x X , x X  - x X  - x X , (x  - x x )X  + (- x  +  |
|             2 1    1 2    3 3   1 1    0 2    2 3    1    0 2  2       2    |
|     ------------------------------------------------------------------------|
|      2                                                                      |
|     x x )X )                                                                |
|      1 3  3                                                                 |
|                                                                             |
|o3 : Ideal of S[X ..X ]                                                      |
|                 1   3                                                       |
+-----------------------------------------------------------------------------+
|i4 : multiReesIdeal {C,C}                                                    |
|                                                                             |
|                                                    2                   2    |
|o4 = ideal (X X  - X X , X X  - X X , X X  - X X , x X  - x X  - x X , x X  -|
|             3 5    2 6   3 4    1 6   2 4    1 5   2 4    1 5    3 6   1 4  |
|     ------------------------------------------------------------------------|
|                   2                   2                    3      2         |
|     x X  - x X , x X  - x X  - x X , x X  - x X  - x X , (x  - x x )X  + (- |
|      0 5    2 6   2 1    1 2    3 3   1 1    0 2    2 3    1    0 2  5      |
|     ------------------------------------------------------------------------|
|      3    2         3      2          3    2                                |
|     x  + x x )X , (x  - x x )X  + (- x  + x x )X )                          |
|      2    1 3  6    1    0 2  2       2    1 3  3                           |
|                                                                             |
|o4 : Ideal of S[X ..X ]                                                      |
|                 1   6                                                       |
+-----------------------------------------------------------------------------+

Ways to use multiReesIdeal :
============================

  * multiReesIdeal(List) (missing documentation)

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

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

multiReesIdeal(...,BasisElementLimit=>...) -- Bound the number of Groebner basis elements to compute in the saturation step
***************************************************************************************************************************

Synopsis
========

  * Usage:
        multiReesIdeal(..., BasisElementLimit => X)
        mixedMultiplicity(..., BasisElementLimit => X)
        mixedVolume(..., BasisElementLimit => X)
        secMilnorNumbers(..., BasisElementLimit => X)

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

Here X is a positive integer. Each of these functions computes the Rees ideal
using a saturation step, and the optional argument causes the saturation
process to stop after that number of s-pairs is found. This is described in the
documentation node for saturate (Saturation).

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

  * Default value: infinity (Macaulay2Doc),
  * Function: multiReesIdeal, -- Compute the defining
    ideal of multi-Rees algebra of ideals
  * Option key: BasisElementLimit (Macaulay2Doc), -- an
    optional argument

See also
========

  * multiReesIdeal -- Compute the defining ideal of
    multi-Rees algebra of ideals
  * mixedMultiplicity -- Compute a given mixed
    multiplicity of ideals in a polynomial ring.
  * mixedVolume -- Compute the mixed volume of a collection
    of lattice polytopes
  * secMilnorNumbers -- Compute the sectional Milnor
    numbers of a hypersurface with an isolated singularity

Functions with optional argument named BasisElementLimit :
==========================================================

  * "gb(...,BasisElementLimit=>...)" -- see gb (Macaulay2Doc), --
    compute a Gröbner basis
  * intersectInP(...,BasisElementLimit=>...) (ReesAlgebra),
    --
    Option for intersectInP
  * "analyticSpread(...,BasisElementLimit=>...)" -- see
    minimalReduction(...,BasisElementLimit=>...) (ReesAlgebra),
    -- Bound the number of Groebner basis elements to compute in the
    saturation step
  * "distinguished(...,BasisElementLimit=>...)" -- see
    minimalReduction(...,BasisElementLimit=>...) (ReesAlgebra),
    -- Bound the number of Groebner basis elements to compute in the
    saturation step
  * "isLinearType(...,BasisElementLimit=>...)" -- see
    minimalReduction(...,BasisElementLimit=>...) (ReesAlgebra),
    -- Bound the number of Groebner basis elements to compute in the
    saturation step
  * "isReduction(...,BasisElementLimit=>...)" -- see
    minimalReduction(...,BasisElementLimit=>...) (ReesAlgebra),
    -- Bound the number of Groebner basis elements to compute in the
    saturation step
  * minimalReduction(...,BasisElementLimit=>...) (ReesAlgebra)
    -- Bound the number of Groebner basis elements to compute in the
    saturation step
  * "multiplicity(...,BasisElementLimit=>...)" -- see
    minimalReduction(...,BasisElementLimit=>...) (ReesAlgebra),
    -- Bound the number of Groebner basis elements to compute in the
    saturation step
  * "normalCone(...,BasisElementLimit=>...)" -- see
    minimalReduction(...,BasisElementLimit=>...) (ReesAlgebra),
    -- Bound the number of Groebner basis elements to compute in the
    saturation step
  * "reesAlgebra(...,BasisElementLimit=>...)" -- see
    minimalReduction(...,BasisElementLimit=>...) (ReesAlgebra),
    -- Bound the number of Groebner basis elements to compute in the
    saturation step
  * "reesIdeal(...,BasisElementLimit=>...)" -- see
    minimalReduction(...,BasisElementLimit=>...) (ReesAlgebra),
    -- Bound the number of Groebner basis elements to compute in the
    saturation step
  * "specialFiber(...,BasisElementLimit=>...)" -- see
    minimalReduction(...,BasisElementLimit=>...) (ReesAlgebra),
    -- Bound the number of Groebner basis elements to compute in the
    saturation step
  * "specialFiberIdeal(...,BasisElementLimit=>...)" -- see
    minimalReduction(...,BasisElementLimit=>...) (ReesAlgebra),
    -- Bound the number of Groebner basis elements to compute in the
    saturation step
  * "mixedMultiplicity(...,BasisElementLimit=>...)"
  * "mixedVolume(...,BasisElementLimit=>...)"
  * multiReesIdeal(...,BasisElementLimit=>...)
    -- Bound the
    number of Groebner basis elements to compute in the saturation step
  * "secMilnorNumbers(...,BasisElementLimit=>...)"
  * quotient(...,BasisElementLimit=>...) (Saturation)
  * "saturate(...,BasisElementLimit=>...)" -- see
    quotient(...,BasisElementLimit=>...) (Saturation),
  * "syz(...,BasisElementLimit=>...)" -- see syz(Matrix) (Macaulay2Doc),
    -- compute the syzygy matrix

multiReesIdeal(...,DegreeLimit=>...) -- Bound the degrees considered in the saturation step.
********************************************************************************************

Synopsis
========

  * Usage:
        multiReesIdeal(..., DegreeLimit => X)
        mixedMultiplicity(..., DegreeLimit => X)
        mixedVolume(..., DegreeLimit => X)
        secMilnorNumbers(..., DegreeLimit => X)

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

where X is a non-negative integer. Stop computation at degree X. This is
described in the documentation node for saturate (Saturation).

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

  * Default value: {}
  * Function: multiReesIdeal, -- Compute the defining
    ideal of multi-Rees algebra of ideals
  * Option key: DegreeLimit (Macaulay2Doc), -- an optional
    argument

See also
========

  * multiReesIdeal -- Compute the defining ideal of
    multi-Rees algebra of ideals
  * mixedMultiplicity -- Compute a given mixed
    multiplicity of ideals in a polynomial ring.
  * mixedVolume -- Compute the mixed volume of a collection
    of lattice polytopes
  * secMilnorNumbers -- Compute the sectional Milnor
    numbers of a hypersurface with an isolated singularity

Functions with optional argument named DegreeLimit :
====================================================

  * "gb(...,DegreeLimit=>...)" -- see gb (Macaulay2Doc), -- compute a
    Gröbner basis
  * "intersectInP(...,DegreeLimit=>...)" -- see
    intersectInP(...,BasisElementLimit=>...) (ReesAlgebra),
    --
    Option for intersectInP
  * "minimalBetti(...,DegreeLimit=>...)" -- see minimalBetti (Macaulay2Doc),
    -- minimal betti numbers of (the mininimal free
    resolution of) a homogeneous ideal or module
  * "mixedMultiplicity(...,DegreeLimit=>...)"
  * "mixedVolume(...,DegreeLimit=>...)"
  * multiReesIdeal(...,DegreeLimit=>...)
    -- Bound the
    degrees considered in the saturation step.
  * "secMilnorNumbers(...,DegreeLimit=>...)"
  * "pushForward(...,DegreeLimit=>...)" -- see
    pushForward(RingMap,Module) (Macaulay2Doc),
  * quotient(...,DegreeLimit=>...) (Saturation)
  * "saturate(...,DegreeLimit=>...)" -- see
    quotient(...,DegreeLimit=>...) (Saturation),
  * "analyticSpread(...,DegreeLimit=>...)" -- see
    reesIdeal(...,DegreeLimit=>...) (ReesAlgebra),
    -- Bound
    the degrees considered in the saturation step. Defaults to infinity
  * "distinguished(...,DegreeLimit=>...)" -- see
    reesIdeal(...,DegreeLimit=>...) (ReesAlgebra),
    -- Bound
    the degrees considered in the saturation step. Defaults to infinity
  * "isLinearType(...,DegreeLimit=>...)" -- see
    reesIdeal(...,DegreeLimit=>...) (ReesAlgebra),
    -- Bound
    the degrees considered in the saturation step. Defaults to infinity
  * "isReduction(...,DegreeLimit=>...)" -- see
    reesIdeal(...,DegreeLimit=>...) (ReesAlgebra),
    -- Bound
    the degrees considered in the saturation step. Defaults to infinity
  * "minimalReduction(...,DegreeLimit=>...)" -- see
    reesIdeal(...,DegreeLimit=>...) (ReesAlgebra),
    -- Bound
    the degrees considered in the saturation step. Defaults to infinity
  * "multiplicity(...,DegreeLimit=>...)" -- see
    reesIdeal(...,DegreeLimit=>...) (ReesAlgebra),
    -- Bound
    the degrees considered in the saturation step. Defaults to infinity
  * "normalCone(...,DegreeLimit=>...)" -- see
    reesIdeal(...,DegreeLimit=>...) (ReesAlgebra),
    -- Bound
    the degrees considered in the saturation step. Defaults to infinity
  * "reesAlgebra(...,DegreeLimit=>...)" -- see
    reesIdeal(...,DegreeLimit=>...) (ReesAlgebra),
    -- Bound
    the degrees considered in the saturation step. Defaults to infinity
  * reesIdeal(...,DegreeLimit=>...) (ReesAlgebra)
    -- Bound
    the degrees considered in the saturation step. Defaults to infinity
  * "specialFiber(...,DegreeLimit=>...)" -- see
    reesIdeal(...,DegreeLimit=>...) (ReesAlgebra),
    -- Bound
    the degrees considered in the saturation step. Defaults to infinity
  * "specialFiberIdeal(...,DegreeLimit=>...)" -- see
    reesIdeal(...,DegreeLimit=>...) (ReesAlgebra),
    -- Bound
    the degrees considered in the saturation step. Defaults to infinity
  * resolution(...,DegreeLimit=>...) (Macaulay2Doc),
    --
    compute only up to this degree
  * "syz(...,DegreeLimit=>...)" -- see syz(Matrix) (Macaulay2Doc),
    -- compute the syzygy matrix

multiReesIdeal(...,MinimalGenerators=>...) -- Whether the saturation step returns minimal generators
****************************************************************************************************

Synopsis
========

  * Usage:
        multiReesIdeal(..., MinimalGenerators => X)
        mixedMultiplicity(..., MinimalGenerators => X)
        mixedVolume(..., MinimalGenerators => X)
        secMilnorNumbers(..., MinimalGenerators => X)

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

Here X is of type boolean. Each of these functions involves the computation of
a Rees ideal, which involves a saturation step. This optional argument
determines whether or not the output of the saturation step will be forced to
have a minmimal generating set. This is described in the documentation node for
saturate (Saturation).

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

  * Default value: true (Macaulay2Doc),
  * Function: multiReesIdeal, -- Compute the defining
    ideal of multi-Rees algebra of ideals
  * Option key: MinimalGenerators (Macaulay2Doc), --
    whether to compute minimal generators and return a trimmed set of
    generators

See also
========

  * multiReesIdeal -- Compute the defining ideal of
    multi-Rees algebra of ideals
  * mixedMultiplicity -- Compute a given mixed
    multiplicity of ideals in a polynomial ring.
  * mixedVolume -- Compute the mixed volume of a collection
    of lattice polytopes
  * secMilnorNumbers -- Compute the sectional Milnor
    numbers of a hypersurface with an isolated singularity

Functions with optional argument named MinimalGenerators :
==========================================================

  * "associatedPrimes(...,MinimalGenerators=>...)" -- see
    associatedPrimes (PrimaryDecomposition), -- find
    associated primes
  * "intersect(Ideal,Ideal,MinimalGenerators=>...)" -- see
    intersect(Ideal,Ideal) (Macaulay2Doc), --
    compute an intersection of a sequence of ideals or modules
  * "intersect(Module,Module,MinimalGenerators=>...)" -- see
    intersect(Ideal,Ideal) (Macaulay2Doc), --
    compute an intersection of a sequence of ideals or modules
  * "intersectInP(...,MinimalGenerators=>...)" -- see
    intersectInP(...,BasisElementLimit=>...) (ReesAlgebra),
    --
    Option for intersectInP
  * "decompose(Ideal,MinimalGenerators=>...)" -- see minimalPrimes (MinimalPrimes),
    -- minimal primes of an ideal
  * "minimalPrimes(...,MinimalGenerators=>...)" -- see minimalPrimes (MinimalPrimes),
    -- minimal primes of an ideal
  * "mixedMultiplicity(...,MinimalGenerators=>...)"
  * "mixedVolume(...,MinimalGenerators=>...)"
  * multiReesIdeal(...,MinimalGenerators=>...)
    -- Whether
    the saturation step returns minimal generators
  * "secMilnorNumbers(...,MinimalGenerators=>...)"
  * "primaryDecomposition(...,MinimalGenerators=>...)" -- see
    primaryDecomposition (PrimaryDecomposition), --
    irredundant primary decomposition of an ideal
  * "quotient(...,MinimalGenerators=>...)" -- see
    quotient(Module,Module) (Saturation), --
    ideal or submodule quotient
  * "analyticSpread(...,MinimalGenerators=>...)" -- see
    reesIdeal(...,MinimalGenerators=>...) (ReesAlgebra),
    --
    Whether the saturation step returns minimal generators
  * "distinguished(...,MinimalGenerators=>...)" -- see
    reesIdeal(...,MinimalGenerators=>...) (ReesAlgebra),
    --
    Whether the saturation step returns minimal generators
  * "isLinearType(...,MinimalGenerators=>...)" -- see
    reesIdeal(...,MinimalGenerators=>...) (ReesAlgebra),
    --
    Whether the saturation step returns minimal generators
  * "isReduction(...,MinimalGenerators=>...)" -- see
    reesIdeal(...,MinimalGenerators=>...) (ReesAlgebra),
    --
    Whether the saturation step returns minimal generators
  * "minimalReduction(...,MinimalGenerators=>...)" -- see
    reesIdeal(...,MinimalGenerators=>...) (ReesAlgebra),
    --
    Whether the saturation step returns minimal generators
  * "multiplicity(...,MinimalGenerators=>...)" -- see
    reesIdeal(...,MinimalGenerators=>...) (ReesAlgebra),
    --
    Whether the saturation step returns minimal generators
  * "normalCone(...,MinimalGenerators=>...)" -- see
    reesIdeal(...,MinimalGenerators=>...) (ReesAlgebra),
    --
    Whether the saturation step returns minimal generators
  * "reesAlgebra(...,MinimalGenerators=>...)" -- see
    reesIdeal(...,MinimalGenerators=>...) (ReesAlgebra),
    --
    Whether the saturation step returns minimal generators
  * reesIdeal(...,MinimalGenerators=>...) (ReesAlgebra),
    --
    Whether the saturation step returns minimal generators
  * "specialFiber(...,MinimalGenerators=>...)" -- see
    reesIdeal(...,MinimalGenerators=>...) (ReesAlgebra),
    --
    Whether the saturation step returns minimal generators
  * "specialFiberIdeal(...,MinimalGenerators=>...)" -- see
    reesIdeal(...,MinimalGenerators=>...) (ReesAlgebra),
    --
    Whether the saturation step returns minimal generators
  * "saturate(...,MinimalGenerators=>...)" -- see saturate (Saturation),
    -- saturation of ideal or submodule

multiReesIdeal(...,PairLimit=>...) -- Bound the number of s-pairs considered in the saturation step
***************************************************************************************************

Synopsis
========

  * Usage:
        multiReesIdeal(..., PairLimit => X)
        mixedMultiplicity(..., PairLimit => X)
        mixedVolume(..., PairLimit => X)
        secMilnorNumbers(..., PairLimit => X)

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

Here X is a positive integer. The calculation of Rees ideal requires a
saturation step, and the optional argument causes the saturation process to
stop after that number of s-pairs is found. This is described in the
documentation node for saturate (Saturation).

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

  * Default value: infinity (Macaulay2Doc),
  * Function: multiReesIdeal, -- Compute the defining
    ideal of multi-Rees algebra of ideals
  * Option key: PairLimit (Macaulay2Doc), -- an optional
    argument

See also
========

  * multiReesIdeal -- Compute the defining ideal of
    multi-Rees algebra of ideals
  * mixedMultiplicity -- Compute a given mixed
    multiplicity of ideals in a polynomial ring.
  * mixedVolume -- Compute the mixed volume of a collection
    of lattice polytopes
  * secMilnorNumbers -- Compute the sectional Milnor
    numbers of a hypersurface with an isolated singularity

Functions with optional argument named PairLimit :
==================================================

  * "gb(...,PairLimit=>...)" -- see gb (Macaulay2Doc), -- compute a
    Gröbner basis
  * "intersectInP(...,PairLimit=>...)" -- see
    intersectInP(...,BasisElementLimit=>...) (ReesAlgebra),
    --
    Option for intersectInP
  * "mixedMultiplicity(...,PairLimit=>...)"
  * "mixedVolume(...,PairLimit=>...)"
  * multiReesIdeal(...,PairLimit=>...)
    -- Bound the number
    of s-pairs considered in the saturation step
  * "secMilnorNumbers(...,PairLimit=>...)"
  * "pushForward(...,PairLimit=>...)" -- see pushForward(RingMap,Module) (Macaulay2Doc),
  * quotient(...,PairLimit=>...) (Saturation)
  * "saturate(...,PairLimit=>...)" -- see quotient(...,PairLimit=>...) (Saturation),
  * "analyticSpread(...,PairLimit=>...)" -- see
    reesIdeal(...,PairLimit=>...) (ReesAlgebra),
    -- Bound the
    number of s-pairs considered in the saturation step
  * "distinguished(...,PairLimit=>...)" -- see
    reesIdeal(...,PairLimit=>...) (ReesAlgebra),
    -- Bound the
    number of s-pairs considered in the saturation step
  * "isLinearType(...,PairLimit=>...)" -- see
    reesIdeal(...,PairLimit=>...) (ReesAlgebra),
    -- Bound the
    number of s-pairs considered in the saturation step
  * "isReduction(...,PairLimit=>...)" -- see
    reesIdeal(...,PairLimit=>...) (ReesAlgebra),
    -- Bound the
    number of s-pairs considered in the saturation step
  * "minimalReduction(...,PairLimit=>...)" -- see
    reesIdeal(...,PairLimit=>...) (ReesAlgebra),
    -- Bound the
    number of s-pairs considered in the saturation step
  * "multiplicity(...,PairLimit=>...)" -- see
    reesIdeal(...,PairLimit=>...) (ReesAlgebra),
    -- Bound the
    number of s-pairs considered in the saturation step
  * "normalCone(...,PairLimit=>...)" -- see
    reesIdeal(...,PairLimit=>...) (ReesAlgebra),
    -- Bound the
    number of s-pairs considered in the saturation step
  * "reesAlgebra(...,PairLimit=>...)" -- see
    reesIdeal(...,PairLimit=>...) (ReesAlgebra),
    -- Bound the
    number of s-pairs considered in the saturation step
  * reesIdeal(...,PairLimit=>...) (ReesAlgebra)
    -- Bound the
    number of s-pairs considered in the saturation step
  * "specialFiber(...,PairLimit=>...)" -- see
    reesIdeal(...,PairLimit=>...) (ReesAlgebra),
    -- Bound the
    number of s-pairs considered in the saturation step
  * "specialFiberIdeal(...,PairLimit=>...)" -- see
    reesIdeal(...,PairLimit=>...) (ReesAlgebra),
    -- Bound the
    number of s-pairs considered in the saturation step
  * resolution(...,PairLimit=>...) (Macaulay2Doc)
    -- stop
    when this number of pairs has been handled
  * "syz(...,PairLimit=>...)" -- see syz(Matrix) (Macaulay2Doc),
    -- compute the syzygy matrix

multiReesIdeal(...,Strategy=>...) -- Choose a strategy for the saturation step
******************************************************************************

Synopsis
========

  * Usage:
        multiReesIdeal(..., Strategy => X)
        mixedMultiplicity(..., Strategy => X)
        mixedVolume(..., Strategy => X)
        secMilnorNumbers(..., Strategy => X)

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

where X is one of Iterate (Macaulay2Doc), Linear (Macaulay2Doc),
see Bayer (Macaulay2Doc), Eliminate (Macaulay2Doc).
These are described in the documentation node for
saturate (Saturation).

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

  * Default value: null
  * Function: multiReesIdeal, -- Compute the defining
    ideal of multi-Rees algebra of ideals
  * Option key: Strategy (Macaulay2Doc), -- an optional argument

See also
========

  * multiReesIdeal -- Compute the defining ideal of
    multi-Rees algebra of ideals
  * mixedMultiplicity -- Compute a given mixed
    multiplicity of ideals in a polynomial ring.
  * mixedVolume -- Compute the mixed volume of a collection
    of lattice polytopes
  * secMilnorNumbers -- Compute the sectional Milnor
    numbers of a hypersurface with an isolated singularity

Functions with optional argument named Strategy :
=================================================

  * "addHook(...,Strategy=>...)" -- see addHook (Macaulay2Doc),
    -- add a hook function to an object for later processing
  * "annihilator(...,Strategy=>...)" -- see annihilator (Saturation),
    -- the annihilator ideal
  * "associatedPrimes(...,Strategy=>...)" -- see associatedPrimes (PrimaryDecomposition),
    -- find associated primes
  * "basis(...,Strategy=>...)" -- see basis (Macaulay2Doc), --
    basis or generating set of all or part of a ring, ideal or module
  * "mingens(...,Strategy=>...)" -- see Complement (Macaulay2Doc),
    -- a Strategy option value
  * "trim(...,Strategy=>...)" -- see Complement (Macaulay2Doc),
    -- a Strategy option value
  * determinant(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss and Cofactor algorithms
  * "dual(MonomialIdeal,List,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * "dual(MonomialIdeal,RingElement,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc)
  * exteriorPower(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss and Cofactor algorithms
  * "gb(...,Strategy=>...)" -- see gb (Macaulay2Doc), -- compute a
    Gröbner basis
  * gcdLLL(...,Strategy=>...) (missing documentation)
  * "GF(...,Strategy=>...)" -- see GF (Macaulay2Doc), -- make a finite
    field
  * "groebnerBasis(...,Strategy=>...)" -- see groebnerBasis (Macaulay2Doc),
    -- Gröbner basis, as a matrix
  * hermite(...,Strategy=>...) (missing documentation)
  * "hooks(...,Strategy=>...)" -- see hooks (Macaulay2Doc), -- list
    hooks attached to a key
  * "idealizer(...,Strategy=>...)" -- see idealizer (IntegralClosure),
    -- compute Hom(I,I) as a quotient ring
  * integralClosure(...,Strategy=>...) (IntegralClosure),
    --
    control the algorithm used
  * "intersect(Ideal,Ideal,Strategy=>...)" -- see intersect(Ideal,Ideal) (Macaulay2Doc),
    -- compute an intersection of a
    sequence of ideals or modules
  * "intersect(Module,Module,Strategy=>...)" -- see
    intersect(Ideal,Ideal) (Macaulay2Doc), --
    compute an intersection of a sequence of ideals or modules
  * "intersectInP(...,Strategy=>...)" -- see
    intersectInP(...,BasisElementLimit=>...) (ReesAlgebra),
    --
    Option for intersectInP
  * "isPrimary(...,Strategy=>...)" -- see isPrimary (PrimaryDecomposition),
    -- determine whether a submodule is
    primary
  * "isPrime(Ideal,Strategy=>...)" -- see isPrime(Ideal) (MinimalPrimes),
    -- whether an ideal is prime
  * LLL(...,Strategy=>...) (LLLBases)
    -- choose among
    different algorithms
  * "localize(...,Strategy=>...)" -- see localize (PrimaryDecomposition),
    -- localize an ideal at a prime ideal
  * "match(...,Strategy=>...)" -- see match (Macaulay2Doc), --
    regular expression matching
  * "decompose(Ideal,Strategy=>...)" -- see minimalPrimes (MinimalPrimes),
    -- minimal primes of an ideal
  * "minimalPrimes(...,Strategy=>...)" -- see minimalPrimes (MinimalPrimes),
    -- minimal primes of an ideal
  * minors(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss and Cofactor algorithms
  * "mixedMultiplicity(...,Strategy=>...)"
  * "mixedVolume(...,Strategy=>...)"
  * multiReesIdeal(...,Strategy=>...)
    -- Choose a strategy
    for the saturation step
  * "secMilnorNumbers(...,Strategy=>...)"
  * "primaryComponent(...,Strategy=>...)" -- see primaryComponent (PrimaryDecomposition),
    -- find a primary component
    corresponding to an associated prime
  * pushForward(...,Strategy=>...) (missing documentation)
  * quotient(...,Strategy=>...) (Saturation)
  * "radical(...,Strategy=>...)" -- see radical (MinimalPrimes),
    -- the radical of an ideal
  * "radicalContainment(...,Strategy=>...)" -- see radicalContainment (MinimalPrimes),
    -- whether an element is contained in
    the radical of an ideal
  * "analyticSpread(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "distinguished(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "isLinearType(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "isReduction(...,Strategy=>...)" -- see reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "minimalReduction(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "multiplicity(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "normalCone(...,Strategy=>...)" -- see reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "reesAlgebra(...,Strategy=>...)" -- see reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * reesIdeal(...,Strategy=>...) (ReesAlgebra)
    -- Choose a
    strategy for the saturation step
  * "specialFiber(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "specialFiberIdeal(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "regSeqInIdeal(...,Strategy=>...)" -- see regSeqInIdeal (PrimaryDecomposition),
    -- a regular sequence contained in an
    ideal
  * resolution(...,Strategy=>...) (Macaulay2Doc)
  * saturate(...,Strategy=>...) (Saturation)
  * "primaryDecomposition(...,Strategy=>...)" -- see strategies for computing primary decomposition (PrimaryDecomposition),
  * "syz(...,Strategy=>...)" -- see syz(Matrix) (Macaulay2Doc),
    -- compute the syzygy matrix
  * "tangentCone(...,Strategy=>...)" -- see tangentCone(Ideal) (TangentCone),

multiReesIdeal(...,VariableBaseName=>...) -- Choose a base name for variables in the created ring
*************************************************************************************************

Synopsis
========

  * Usage:
        multiReesIdeal(..., VariableBaseName => X)
        homIdealPolytope(..., VariableBaseName => X)
        mixedVolume(..., VariableBaseName => X)

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

Each of these functions creates a new ring of the form $R[X_0,\ldots, X_r]$ or
$k[X_0,\ldots, X_r]$, where $R$ is the ring of the input ideal and $k$ is the
coefficient ring of the output ideal. This option allows the user to change the
base names of the new variables in this ring. The default variable is X.

+-----------------------------------------------------------------------------+
|i1 : S = QQ[x_0..x_3]                                                        |
|                                                                             |
|o1 = S                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : C = trim monomialCurveIdeal(S,{2,3,5})                                  |
|                                                                             |
|                          3    2     3      2                                |
|o2 = ideal (x x  - x x , x  - x x , x  - x x )                               |
|             1 2    0 3   2    1 3   1    0 2                                |
|                                                                             |
|o2 : Ideal of S                                                              |
+-----------------------------------------------------------------------------+
|i3 : multiReesIdeal ({C}, VariableBaseName => "T")                           |
|                                                                             |
|             2                   2                    3      2          3    |
|o3 = ideal (x T  - x T  - x T , x T  - x T  - x T , (x  - x x )T  + (- x  +  |
|             2 1    1 2    3 3   1 1    0 2    2 3    1    0 2  2       2    |
|     ------------------------------------------------------------------------|
|      2                                                                      |
|     x x )T )                                                                |
|      1 3  3                                                                 |
|                                                                             |
|o3 : Ideal of S[T ..T ]                                                      |
|                 1   3                                                       |
+-----------------------------------------------------------------------------+
+--------------------------------------------------------------------------+
|i4 : homIdealPolytope ({(0,1),(1,0),(2,1),(1,2)}, VariableBaseName => "T")|
|                                                                          |
|             2       2     2     2                                        |
|o4 = ideal (T T , T T , T T , T T )                                       |
|             1 2   1 2   1 3   2 3                                        |
|                                                                          |
|o4 : Ideal of QQ[T ..T ]                                                  |
|                  1   3                                                   |
+--------------------------------------------------------------------------+

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

  * Default value: X
  * Function: multiReesIdeal, -- Compute the defining
    ideal of multi-Rees algebra of ideals
  * Option key: VariableBaseName (Macaulay2Doc), -- make or
    retrieve a monoid

Functions with optional argument named VariableBaseName :
=========================================================

  * "graphIdeal(...,VariableBaseName=>...)" -- see graphIdeal(RingMap) (Macaulay2Doc),
    -- the ideal of the graph of the
    regular map corresponding to a ring map
  * "graphRing(...,VariableBaseName=>...)" -- see graphRing(RingMap) (Macaulay2Doc),
    -- the coordinate ring of the graph
    of the regular map corresponding to a ring map
  * "monoid(...,VariableBaseName=>...)" -- see monoid (Macaulay2Doc),
    -- make or retrieve a monoid
  * "homIdealPolytope(...,VariableBaseName=>...)"
  * "mixedVolume(...,VariableBaseName=>...)"
  * multiReesIdeal(...,VariableBaseName=>...)
    -- Choose a
    base name for variables in the created ring
  * "newRing(...,VariableBaseName=>...)" -- see newRing (Macaulay2Doc),
    -- make a copy of a ring, with some features changed
  * "polarize(...,VariableBaseName=>...)" -- see polarize (Macaulay2Doc),
    -- given a monomial ideal, computes the squarefree
    monomial ideal obtained via polarization
  * "symmetricAlgebra(...,VariableBaseName=>...)" -- see
    symmetricAlgebra (Macaulay2Doc), -- the symmetric algebra
    of a module
  * "symmetricAlgebraIdeal(...,VariableBaseName=>...)" -- see
    symmetricAlgebraIdeal (ReesAlgebra), -- Ideal of the
    symmetric algebra of an ideal or module
  * "tensor(Monoid,Monoid,VariableBaseName=>...)" -- see
    tensor(Monoid,Monoid) (Macaulay2Doc), -- tensor
    product of monoids
  * tensor(PolynomialRing,PolynomialRing,VariableBaseName=>...) (missing
    documentation)
  * tensor(PolynomialRing,QuotientRing,VariableBaseName=>...) (missing
    documentation)
  * tensor(QuotientRing,PolynomialRing,VariableBaseName=>...) (missing
    documentation)
  * tensor(QuotientRing,QuotientRing,VariableBaseName=>...) (missing
    documentation)
  * tensor(Ring,Ring,VariableBaseName=>...) (missing documentation)

secMilnorNumbers -- Compute the sectional Milnor numbers of a hypersurface with an isolated singularity
*******************************************************************************************************

Synopsis
========

  * Usage:
        secMilnorNumbers f
  * Inputs:
      * f, a ring element (Macaulay2Doc), polynomial
  * Optional inputs (Macaulay2Doc),:
      * BasisElementLimit,
        => ...,
        default value infinity, Bound the number of Groebner basis elements to
        compute in the saturation step
      * DegreeLimit,
        => ..., default value {}, Bound the degrees considered in the
        saturation step.
      * MinimalGenerators,
        => ...,
        default value true, Whether the saturation step returns minimal
        generators
      * PairLimit,
        => ..., default value infinity, Bound the number of s-pairs considered
        in the saturation step
      * Strategy, =>
        ..., default value null, Choose a strategy for the saturation step
  * Outputs:
      * a hash table (Macaulay2Doc), First $d-1$ sectional
        Milnor numbers, where $d$ is the dimension of the polynomial ring

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

Let $f$ be an element of a polynomial ring $R$ and let $d$ be the dimension of
$R$. The function computes the first $d-1$ sectional Milnor numbers by
computing the mixed multiplicities $e_0(m|J(f)),...,e_{d-1}(m|J(f))$, where $m$
is the maximal homogeneous ideal of $R$ and $J(f)$ is the Jacobian ideal of
$f$.

+---------------------------------------------------+
|i1 : k = frac(QQ[t])                               |
|                                                   |
|o1 = k                                             |
|                                                   |
|o1 : FractionField                                 |
+---------------------------------------------------+
|i2 : R = k[x,y,z]                                  |
|                                                   |
|o2 = R                                             |
|                                                   |
|o2 : PolynomialRing                                |
+---------------------------------------------------+
|i3 : secMilnorNumbers(z^5 + t*y^6*z + x*y^7 + x^15)|
|                                                   |
|o3 = HashTable{0 => 1 }                            |
|               1 => 4                              |
|               2 => 26                             |
|                                                   |
|o3 : HashTable                                     |
+---------------------------------------------------+
|i4 : secMilnorNumbers(z^5 + x*y^7 + x^15)          |
|                                                   |
|o4 = HashTable{0 => 1 }                            |
|               1 => 4                              |
|               2 => 28                             |
|                                                   |
|o4 : HashTable                                     |
+---------------------------------------------------+

Ways to use secMilnorNumbers :
==============================

  * secMilnorNumbers(RingElement) (missing documentation)

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

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