This is MultiplierIdeals.info, produced by Macaulay2, version 1.24.11

MultiplierIdeals -- multiplier ideals
*************************************

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

MultiplierIdeals is a package for computing multiplier ideals, log canonical
thresholds, and jumping numbers, using specialized routines wherever possible.

The package BernsteinSato provides computations of multiplier ideals, log
canonical thresholds, and jumping numbers of arbitrary ideals using general
algorithms.

This package provides alternatives for special classes of ideals, including
monomial ideals, hyperplane arrangements, generic determinantal ideals, and
binomial ideals (currently, ideals of curves in 3-space parametrized by
monomials). These special computations are typically much faster than general
methods and can often handle larger examples.

References
==========

  * [BL] Blickle, Manuel and Robert Lazarsfeld, An informal introduction to
    multiplier ideals. Trends in commutative algebra, 87-114, Math. Sci. Res.
    Inst. Publ., 51, Cambridge Univ. Press, Cambridge, 2004.
  * [H] Howald, J.A., Multiplier ideals of monomial ideals. Trans. Amer. Math.
    Soc. 353 (2001), no. 7, 2665-2671
  * [J] Johnson, Amanda, Multiplier ideals of determinantal ideals. Thesis
    (Ph.D.)-University of Michigan. 2003
  * [L] Lazarsfeld, Robert, Positivity in algebraic geometry. II. Ergebnisse
    der Mathematik., vol. 49, Springer-Verlag, Berlin, 2004. Positivity for
    vector bundles, and multiplier ideals.
  * [M] Mustata, Mircea, Multiplier ideals of hyperplane arrangements. Trans.
    Amer. Math. Soc. 358 (2006), no. 11, 5015-5023.
  * [T] Teitler, Zach, A note on Mustata's computation of multiplier ideals of
    hyperplane arrangements. Proc. Amer. Math. Soc. 136 (2008), no. 5,
    1575-1579.
  * [Th] Thompson, Howard M., Multiplier Ideals of Monomial Space Curves, Proc.
    Amer. Math. Soc. Ser. B 1 (2014), 33–41.

Caveat
======

The multiplier ideals and log canonical thresholds computed by this package are
valid over any field in any characteristic. In some cases results may be
computed over other coefficient rings, such as ZZ, but they may not represent
actual multiplier ideals or log canonical thresholds.

Authors
=======

  * Zach Teitler (see http://math.boisestate.edu/~zteitler/ )
    <zteitler@member.ams.org>
  * Bart Snapp
  * Claudiu Raicu

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

Version 1.1 of this package was accepted for publication in volume 7 (see
https://msp.org/jsag/2015/7-1/ ) of The Journal of Software for Algebra and
Geometry (see https://msp.org/jsag/ ) on 5 June 2015, in the article Software
for multiplier ideals (see https://msp.org/jsag/2015/7-1/p01.xhtml ) (DOI:
10.2140/jsag.2015.7.1 (see https://doi.org/10.2140/jsag.2015.7.1 )). That
version can be obtained from the journal (see
https://msp.org/jsag/2015/7-1/jsag-v7-n1-x01-MultiplierIdeals.m2 ) or from the
Macaulay2 source code repository (see
https://github.com/Macaulay2/M2/blob/a71903e3507b0384ece1ed43f815b9344258ed1a/
M2/Macaulay2/packages/MultiplierIdeals.m2 ).

Version
=======

This documentation describes version 1.1 of MultiplierIdeals.

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

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

Exports
=======

  * Functions and commands
      * jumpingNumbers -- jumping numbers
  * Methods
      * "jumpingNumbers(CentralArrangement)" -- see jumpingNumbers,
        -- jumping numbers
      * "jumpingNumbers(MonomialIdeal)" -- see jumpingNumbers,
        -- jumping numbers
      * "jumpingNumbers(Sequence)" -- see jumpingNumbers,
        -- jumping numbers
      * "logCanonicalThreshold(CentralArrangement,List)" -- see
        logCanonicalThreshold(MonomialIdeal),
        -- log canonical threshold
      * "logCanonicalThreshold(Matrix,ZZ)" -- see
        logCanonicalThreshold(MonomialIdeal),
        -- log canonical threshold
      * logCanonicalThreshold(MonomialIdeal)
        -- log canonical threshold
      * "logCanonicalThreshold(MonomialIdeal,RingElement)" -- see
        logCanonicalThreshold(MonomialIdeal),
        -- log canonical threshold
      * "logCanonicalThreshold(Ring,List)" -- see
        logCanonicalThreshold(MonomialIdeal),
        -- log canonical threshold
      * "multiplierIdeal(CentralArrangement,List,Number)" -- see
        multiplierIdeal(MonomialIdeal,QQ),
        -- multiplier ideal
      * "multiplierIdeal(CentralArrangement,Number)" -- see
        multiplierIdeal(MonomialIdeal,QQ),
        -- multiplier ideal
      * "multiplierIdeal(Matrix,ZZ,QQ)" -- see
        multiplierIdeal(MonomialIdeal,QQ),
        -- multiplier ideal
      * "multiplierIdeal(Matrix,ZZ,ZZ)" -- see
        multiplierIdeal(MonomialIdeal,QQ),
        -- multiplier ideal
      * multiplierIdeal(MonomialIdeal,QQ)
        -- multiplier ideal
      * "multiplierIdeal(MonomialIdeal,ZZ)" -- see
        multiplierIdeal(MonomialIdeal,QQ),
        -- multiplier ideal
      * "multiplierIdeal(Ring,List,QQ)" -- see
        multiplierIdeal(MonomialIdeal,QQ),
        -- multiplier ideal
      * "multiplierIdeal(Ring,List,ZZ)" -- see
        multiplierIdeal(MonomialIdeal,QQ),
        -- multiplier ideal
  * Symbols
      * Interval -- name for an optional argument
      * IntervalType -- name for an optional argument

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

The object MultiplierIdeals, is a package (Macaulay2Doc).

Interval -- name for an optional argument
*****************************************

Functions with optional argument named Interval:
================================================

  * jumpingNumbers(...,Interval=>...)
    -- interval for
    jumping numbers

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

The object Interval, is a symbol (Macaulay2Doc).

IntervalType -- name for an optional argument
*********************************************

Functions with optional argument named IntervalType:
====================================================

  * "jumpingNumbers(...,IntervalType=>...)" -- see
    jumpingNumbers(...,Interval=>...),
    -- interval for
    jumping numbers

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

The object IntervalType, is a symbol (Macaulay2Doc).

jumpingNumbers -- jumping numbers
*********************************

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

Jumping numbers of an ideal $I$ are those real numbers $t$ at which the
multiplier ideal $J(I^t)$, as a function of the parameter $t$, changes. More
precisely, $t$ is a jumping number if $J(I^t)$ is different from
$J(I^{t-\epsilon})$ for all $\epsilon > 0$. The jumping numbers form a discrete
sequence of rational numbers. Thus $t_1, t_2$ are two consecutive jumping
numbers of $I$ when $J(I^t) = J(I^{t_1})$ for all $t_1 \leq t < t_2$ and
$J(I^t) \neq J(I^{t_1})$ for $t < t_1$ or $t_2 \leq t$.

The jumpingNumbers command determines the jumping numbers of an ideal along
with the multiplier ideals at those jumping numbers. By definition, the
multiplier ideals are then determined at the intermediate parameter values.

The jumpingNumbers command can handle any input that the multiplierIdeals
command can handle (but omit the rational number argument of multiplierIdeals).
That is, jumpingNumbers can handle the following inputs: a hyperplane
arrangement; a hyperplane arrangement with a list of multiplicities; a monomial
ideal; a monomial space curve (specified by giving a ring together with a list
of exponents); a generic determinantal ideal (specified by giving a generic
matrix together with a size of minors).

+-----------------------------------------------------------------------------+
|i1 : R = QQ[x,y,z,w];                                                        |
+-----------------------------------------------------------------------------+
|i2 : I = monomialIdeal(x*y, x*z, y*z, y*w, z*w^2);                           |
|                                                                             |
|o2 : MonomialIdeal of R                                                      |
+-----------------------------------------------------------------------------+
|i3 : jumpingNumbers(I)                                                       |
|                                                                             |
|          7  5  8     10  7  11                                              |
|o3 = {{2, -, -, -, 3, --, -, --, 4}, {monomialIdeal (y, z), monomialIdeal (y,|
|          3  2  3      3  2   3                                              |
|     ------------------------------------------------------------------------|
|           2                             2                                   |
|     x*z, z , z*w), monomialIdeal (x*y, y , x*z, y*z, y*w, z*w),             |
|     ------------------------------------------------------------------------|
|                          2                  2      2                     2  |
|     monomialIdeal (x*y, y , x*z, y*z, y*w, z w, z*w ), monomialIdeal (x*y , |
|     ------------------------------------------------------------------------|
|             2      2     2   2           2 2                     2          |
|     x*y*z, y z, x*z , y*z , y w, y*z*w, z w ), monomialIdeal (x*y , x*y*z,  |
|     ------------------------------------------------------------------------|
|      2    2 2     3     3   2      2      2        2   3 2   2 3            |
|     y z, x z , x*z , y*z , y w, x*z w, y*z w, y*z*w , z w , z w ),          |
|     ------------------------------------------------------------------------|
|                     2 2     3   2        2    3    2 2       2   2 2     2  |
|     monomialIdeal (x y , x*y , x y*z, x*y z, y z, x z , x*y*z , y z , x*y w,|
|     ------------------------------------------------------------------------|
|      3             2        2      2    2 2       2   2 3                   |
|     y w, x*y*z*w, y z*w, x*z w, y*z w, y w , y*z*w , z w ), monomialIdeal   |
|     ------------------------------------------------------------------------|
|       2 2     3   2        2    3    2 2       2   2 2     2    3           |
|     (x y , x*y , x y*z, x*y z, y z, x z , x*y*z , y z , x*y w, y w, x*y*z*w,|
|     ------------------------------------------------------------------------|
|      2        3      3    2 2     2 2     2 2       3   3 3   2 4           |
|     y z*w, x*z w, y*z w, y w , x*z w , y*z w , y*z*w , z w , z w ),         |
|     ------------------------------------------------------------------------|
|                     2 3   2 2      3    2   2     2 2   3 2   2 3       3   |
|     monomialIdeal (x y , x y z, x*y z, x y*z , x*y z , y z , x z , x*y*z ,  |
|     ------------------------------------------------------------------------|
|      2 3     3      2      3          2    2 2    3 2   2   2     3 2       |
|     y z , x*y w, x*y z*w, y z*w, x*y*z w, y z w, y w , y z*w , x*z w ,      |
|     ------------------------------------------------------------------------|
|        3 2     2 3   3 4                                                    |
|     y*z w , y*z w , z w )}}                                                 |
|                                                                             |
|o3 : List                                                                    |
+-----------------------------------------------------------------------------+

By default, jumpingNumbers looks for jumping numbers in a closed interval
$[a,b]$ where $a$ is the log canonical threshold of the ideal and $b$ is a
sufficiently large value to ensure that Skoda periodicity holds, that is,
$J(I^t) = I J(I^{t-1})$ for $t \geq b$. (In particular, the multiplier ideals
and jumping numbers are determined for all $t$ by the output of this command.)
The user may specify a different interval via the optional arguments
Interval, and IntervalType.

+-----------------------------------------------------------------------------+
|i4 : R = QQ[x,y,z,w];                                                        |
+-----------------------------------------------------------------------------+
|i5 : I = monomialIdeal(x*y, x*z, y*z, y*w, z*w^2);                           |
|                                                                             |
|o5 : MonomialIdeal of R                                                      |
+-----------------------------------------------------------------------------+
|i6 : jumpingNumbers(I,Interval=>{2,3},IntervalType=>"OpenClosed")            |
|                                                                             |
|       7  5  8                               2                             2 |
|o6 = {{-, -, -, 3}, {monomialIdeal (y, x*z, z , z*w), monomialIdeal (x*y, y ,|
|       3  2  3                                                               |
|     ------------------------------------------------------------------------|
|                                               2                  2      2   |
|     x*z, y*z, y*w, z*w), monomialIdeal (x*y, y , x*z, y*z, y*w, z w, z*w ), |
|     ------------------------------------------------------------------------|
|                       2          2      2     2   2           2 2           |
|     monomialIdeal (x*y , x*y*z, y z, x*z , y*z , y w, y*z*w, z w )}}        |
|                                                                             |
|o6 : List                                                                    |
+-----------------------------------------------------------------------------+

References
==========

  * [ELSV] Ein, Lawrence, Robert Lazarsfeld, Karen E. Smith, and Dror Varolin,
    Jumping coefficients of multiplier ideals. Duke Math. J. 123 (2004), no. 3,
    469-506.

See also
========

  * logCanonicalThreshold (HyperplaneArrangements),
    --
    compute the log-canonical threshold of an arrangement

Ways to use jumpingNumbers:
===========================

  * "jumpingNumbers(CentralArrangement)"
  * "jumpingNumbers(MonomialIdeal)"
  * "jumpingNumbers(Sequence)"

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

The object jumpingNumbers, is a method function with a single argument (Macaulay2Doc).

jumpingNumbers(...,Interval=>...) -- interval for jumping numbers
*****************************************************************

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

Specify the interval in which to search for jumping numbers. IntervalType may
be "Closed" (default), "Open", "ClosedOpen", or "OpenClosed".

+-----------------------------------------------------------------------------+
|i1 : R = QQ[x,y];                                                            |
+-----------------------------------------------------------------------------+
|i2 : I = monomialIdeal(y^2,x^3);                                             |
|                                                                             |
|o2 : MonomialIdeal of R                                                      |
+-----------------------------------------------------------------------------+
|i3 : jumpingNumbers(I) -- default: interval [5/6, 2]                         |
|                                                                             |
|       5  7  4  3  5  11                                             2       |
|o3 = {{-, -, -, -, -, --, 2}, {monomialIdeal (x, y), monomialIdeal (x , y),  |
|       6  6  3  2  3   6                                                     |
|     ------------------------------------------------------------------------|
|                     2        2                   3        2                 |
|     monomialIdeal (x , x*y, y ), monomialIdeal (x , x*y, y ), monomialIdeal |
|     ------------------------------------------------------------------------|
|       3   2    2                   4   2      2   3                   4     |
|     (x , x y, y ), monomialIdeal (x , x y, x*y , y ), monomialIdeal (x ,    |
|     ------------------------------------------------------------------------|
|      3      2   3                                                           |
|     x y, x*y , y )}}                                                        |
|                                                                             |
|o3 : List                                                                    |
+-----------------------------------------------------------------------------+
|i4 : jumpingNumbers(I,Interval=>{1,3/2}) -- [1,3/2]                          |
|                                                                             |
|       7  4  3                    2                      2        2          |
|o4 = {{-, -, -}, {monomialIdeal (x , y), monomialIdeal (x , x*y, y ),        |
|       6  3  2                                                               |
|     ------------------------------------------------------------------------|
|                     3        2                                              |
|     monomialIdeal (x , x*y, y )}}                                           |
|                                                                             |
|o4 : List                                                                    |
+-----------------------------------------------------------------------------+
|i5 : jumpingNumbers(I,IntervalType=>"Open") -- (5/6,2)                       |
|                                                                             |
|       7  4  3  5  11                    2                      2        2   |
|o5 = {{-, -, -, -, --}, {monomialIdeal (x , y), monomialIdeal (x , x*y, y ), |
|       6  3  2  3   6                                                        |
|     ------------------------------------------------------------------------|
|                     3        2                   3   2    2                 |
|     monomialIdeal (x , x*y, y ), monomialIdeal (x , x y, y ), monomialIdeal |
|     ------------------------------------------------------------------------|
|       4   2      2   3                                                      |
|     (x , x y, x*y , y )}}                                                   |
|                                                                             |
|o5 : List                                                                    |
+-----------------------------------------------------------------------------+
|i6 : jumpingNumbers(I,Interval=>{1,3/2},IntervalType=>"ClosedOpen") --       |
|                                                                             |
|       7  4                    2                      2        2             |
|o6 = {{-, -}, {monomialIdeal (x , y), monomialIdeal (x , x*y, y )}}          |
|       6  3                                                                  |
|                                                                             |
|o6 : List                                                                    |
|-----------------------------------------------------------------------------|
|[1,3/2)                                                                      |
+-----------------------------------------------------------------------------+

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

  * Default value: {0, infinity}
  * Function: jumpingNumbers, -- jumping numbers
  * Option key: Interval, -- name for an optional argument

Functions with optional argument named Interval:
================================================

  * jumpingNumbers(...,Interval=>...)
    -- interval for
    jumping numbers

logCanonicalThreshold(MonomialIdeal) -- log canonical threshold
***************************************************************

Synopsis
========

  * Function: logCanonicalThreshold (HyperplaneArrangements),

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

The log canonical threshold of an ideal $I$ is the infimum of $t$ for which the
multiplier ideal $J(I^t)$ is a proper ideal. Equivalently it is the least
nonzero jumping number.

log canonical threshold of a monomial ideal
===========================================

  * Usage:
        logCanonicalThreshold I
  * Inputs:
      * I, a monomial ideal (Macaulay2Doc),
  * Outputs:
      * a rational number (Macaulay2Doc),
Computes the log canonical threshold of a monomial ideal $I$.
+-----------------------------------------------------------------------------+
|i1 : R = QQ[x,y];                                                            |
+-----------------------------------------------------------------------------+
|i2 : I = monomialIdeal(y^2,x^3);                                             |
|                                                                             |
|o2 : MonomialIdeal of R                                                      |
+-----------------------------------------------------------------------------+
|i3 : logCanonicalThreshold(I)                                                |
|                                                                             |
|     5                                                                       |
|o3 = -                                                                       |
|     6                                                                       |
|                                                                             |
|o3 : QQ                                                                      |
+-----------------------------------------------------------------------------+
|i4 : S = QQ[x,y,z];                                                          |
+-----------------------------------------------------------------------------+
|i5 : J = monomialIdeal(x*y^4*z^6, x^5*y, y^7*z, x^8*z^8); -- Example 7 of    |
|                                                                             |
|o5 : MonomialIdeal of S                                                      |
|-----------------------------------------------------------------------------|
|[Howald 2000]                                                                |
+-----------------------------------------------------------------------------+
|i6 : logCanonicalThreshold(J)                                                |
|                                                                             |
|      68                                                                     |
|o6 = ---                                                                     |
|     191                                                                     |
|                                                                             |
|o6 : QQ                                                                      |
+-----------------------------------------------------------------------------+

thresholds of multiplier ideals of monomial ideals
==================================================

  * Usage:
        logCanonicalThreshold(I,m)
  * Inputs:
      * I, a monomial ideal (Macaulay2Doc),
      * m, a ring element (Macaulay2Doc), a monomial
  * Outputs:
      * a rational number (Macaulay2Doc), the least $t$ such that $m$
        is not in the $t$-th multiplier ideal of $I$
      * a matrix (Macaulay2Doc), the equations of the facets of
        the Newton polyhedron of $I$ which impose the threshold on $m$
Computes the threshold of inclusion of the monomial $m=x^v$ in the multiplier
ideal $J(I^t)$, that is, the value $t = sup\{ c | m lies in J(I^c) \} = min\{ c
| m does not lie in J(I^c)\}$. In other words, $(1/t)(v+(1,..,1))$ lies on the
boundary of the Newton polyhedron Newt($I$). In addition, returns the linear
inequalities for those facets of Newt($I$) which contain $(1/t)(v+(1,..,1))$.
These are in the format of Normaliz, i.e., a matrix $(A |
b)$ where the number of columns of $A$ is the number of variables in the ring,
$b$ is a column vector, and the inequality on the column vector $v$ is given by
$Av+b \geq 0$, entrywise. As a special case, the log canonical threshold is the
threshold of the monomial $1_R = x^0$.
+-----------------------------------------------------------------------------+
|i7 : R = QQ[x,y];                                                            |
+-----------------------------------------------------------------------------+
|i8 : I = monomialIdeal(x^13,x^6*y^4,y^9);                                    |
|                                                                             |
|o8 : MonomialIdeal of R                                                      |
+-----------------------------------------------------------------------------+
|i9 : logCanonicalThreshold(I,x^2*y)                                          |
|                                                                             |
|      1                                                                      |
|o9 = (-, | 4 7 -52 |)                                                        |
|      2  | 5 6 -54 |                                                         |
|                                                                             |
|o9 : Sequence                                                                |
+-----------------------------------------------------------------------------+
|i10 : J = monomialIdeal(x^6,x^3*y^2,x*y^5); -- Example 6.7 of [Howald 2001]  |
|                                                                             |
|o10 : MonomialIdeal of R                                                     |
|-----------------------------------------------------------------------------|
|(thesis)                                                                     |
+-----------------------------------------------------------------------------+
|i11 : logCanonicalThreshold(J,1_R)                                           |
|                                                                             |
|        5                                                                    |
|o11 = (--, | 3 2 -13 |)                                                      |
|       13                                                                    |
|                                                                             |
|o11 : Sequence                                                               |
+-----------------------------------------------------------------------------+
|i12 : logCanonicalThreshold(J,x^2)                                           |
|                                                                             |
|       3                                                                     |
|o12 = (-, | 2 3 -12 |)                                                       |
|       4                                                                     |
|                                                                             |
|o12 : Sequence                                                               |
+-----------------------------------------------------------------------------+

log canonical threshold of a hyperplane arrangement
===================================================

  * Usage:
        logCanonicalThreshold A
  * Inputs:
      * A, a central hyperplane arrangement (HyperplaneArrangements),
        a central hyperplane
        arrangement
  * Outputs:
      * a rational number (Macaulay2Doc),
Computes the log canonical threshold of a hyperplane arrangement $A$.
+-----------------------------------------------------------------------+
|i13 : R = QQ[x,y,z];                                                   |
+-----------------------------------------------------------------------+
|i14 : f = toList factor((x^2 - y^2)*(x^2 - z^2)*(y^2 - z^2)*z) / first;|
+-----------------------------------------------------------------------+
|i15 : A = arrangement f;                                               |
+-----------------------------------------------------------------------+
|i16 : logCanonicalThreshold(A)                                         |
|                                                                       |
|      3                                                                |
|o16 = -                                                                |
|      7                                                                |
|                                                                       |
|o16 : QQ                                                               |
+-----------------------------------------------------------------------+

log canonical threshold of monomial space curves
================================================

  * Usage:
        logCanonicalThreshold(R,n)
  * Inputs:
      * R, a ring (Macaulay2Doc),
      * n, a list (Macaulay2Doc), a list of three integers
  * Outputs:
      * logCanonicalThreshold, a rational number (Macaulay2Doc),

Computes the log canonical threshold of the ideal $I$ of a space curve
parametrized by $u \to (u^a,u^b,u^c)$.

+--------------------------------+
|i17 : R = QQ[x,y,z];            |
+--------------------------------+
|i18 : n = {2,3,4};              |
+--------------------------------+
|i19 : logCanonicalThreshold(R,n)|
|                                |
|      11                        |
|o19 = --                        |
|       6                        |
|                                |
|o19 : QQ                        |
+--------------------------------+

log canonical threshold of a generic determinantal ideal
========================================================

  * Usage:
        multiplierIdeal(L,r)
  * Inputs:
      * L, a list (Macaulay2Doc), dimensions $\{m,n\}$ of a matrix
      * r, an integer (Macaulay2Doc), the size of minors generating
        the determinantal ideal
  * Outputs:
      * a rational number (Macaulay2Doc),
Computes the log canonical threshold of the ideal of $r \times r$ minors in a
$m \times n$ matrix whose entries are independent variables (a generic matrix).

lct of ideal of 2-by-2 minors of 4-by-5 matrix:

+--------------------------------+
|i20 : x = getSymbol "x";        |
+--------------------------------+
|i21 : R = QQ[x_1..x_20];        |
+--------------------------------+
|i22 : X = genericMatrix(R,4,5); |
|                                |
|              4      5          |
|o22 : Matrix R  <-- R           |
+--------------------------------+
|i23 : logCanonicalThreshold(X,2)|
|                                |
|o23 = 10                        |
|                                |
|o23 : QQ                        |
+--------------------------------+
We produce some tables of lcts:
+---------------------------------------------------------------+
|i24 :                                                          |
|            lctTable = (M,N,r) -> (                            |
|              x = getSymbol "x";                               |
|              R := QQ[x_1..x_(M*N)];                           |
|              netList (                                        |
|              prepend( join({"m\\n"}, toList(3..M)),           |
|              for n from 3 to N list (                         |
|                prepend(n,                                     |
|                for m from 3 to min(n,M) list (                |
|                  logCanonicalThreshold(genericMatrix(R,m,n),r)|
|                ))                                             |
|              ))                                               |
|            ));                                                |
+---------------------------------------------------------------+
Table of LCTs of ideals of 3-by-3 minors of various size matrices (Table A.1 of
[Johnson, 2003] (dissertation))
+----------------------+
|i25 :                 |
|      lctTable(6,10,3)|
|                      |
|      +---+-+--+--+--+|
|o25 = |m\n|3|4 |5 |6 ||
|      +---+-+--+--+--+|
|      |3  |1|  |  |  ||
|      +---+-+--+--+--+|
|      |4  |2|4 |  |  ||
|      +---+-+--+--+--+|
|      |5  |3|6 |8 |  ||
|      +---+-+--+--+--+|
|      |   | |15|  |  ||
|      |6  |4|--|10|12||
|      |   | | 2|  |  ||
|      +---+-+--+--+--+|
|      |   | |  |35|  ||
|      |7  |5|9 |--|14||
|      |   | |  | 3|  ||
|      +---+-+--+--+--+|
|      |   | |21|40|  ||
|      |8  |6|--|--|16||
|      |   | | 2| 3|  ||
|      +---+-+--+--+--+|
|      |9  |7|12|15|18||
|      +---+-+--+--+--+|
|      |   | |40|50|  ||
|      |10 |8|--|--|20||
|      |   | | 3| 3|  ||
|      +---+-+--+--+--+|
+----------------------+
Table of LCTs of ideals of 4-by-4 minors of various size matrices (Table A.2 of
[Johnson, 2003] (dissertation))
+----------------------------+
|i26 : lctTable(8,14,4)      |
|                            |
|      +---+-+--+--+--+--+--+|
|o26 = |m\n|3|4 |5 |6 |7 |8 ||
|      +---+-+--+--+--+--+--+|
|      |3  |0|  |  |  |  |  ||
|      +---+-+--+--+--+--+--+|
|      |4  |0|1 |  |  |  |  ||
|      +---+-+--+--+--+--+--+|
|      |5  |0|2 |4 |  |  |  ||
|      +---+-+--+--+--+--+--+|
|      |6  |0|3 |6 |8 |  |  ||
|      +---+-+--+--+--+--+--+|
|      |   | |  |15|  |  |  ||
|      |7  |0|4 |--|10|12|  ||
|      |   | |  | 2|  |  |  ||
|      +---+-+--+--+--+--+--+|
|      |   | |  |  |35|  |  ||
|      |8  |0|5 |9 |--|14|16||
|      |   | |  |  | 3|  |  ||
|      +---+-+--+--+--+--+--+|
|      |   | |  |21|40|63|  ||
|      |9  |0|6 |--|--|--|18||
|      |   | |  | 2| 3| 4|  ||
|      +---+-+--+--+--+--+--+|
|      |   | |  |  |  |35|  ||
|      |10 |0|7 |12|15|--|20||
|      |   | |  |  |  | 2|  ||
|      +---+-+--+--+--+--+--+|
|      |   | |  |40|33|77|  ||
|      |11 |0|8 |--|--|--|22||
|      |   | |  | 3| 2| 4|  ||
|      +---+-+--+--+--+--+--+|
|      |   | |  |44|  |  |  ||
|      |12 |0|9 |--|18|21|24||
|      |   | |  | 3|  |  |  ||
|      +---+-+--+--+--+--+--+|
|      |   | |  |  |39|91|  ||
|      |13 |0|10|16|--|--|26||
|      |   | |  |  | 2| 4|  ||
|      +---+-+--+--+--+--+--+|
|      |   | |  |52|  |49|  ||
|      |14 |0|11|--|21|--|28||
|      |   | |  | 3|  | 2|  ||
|      +---+-+--+--+--+--+--+|
+----------------------------+

See also
========

  * jumpingNumbers -- jumping numbers

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

  * "logCanonicalThreshold(CentralArrangement,List)"
  * "logCanonicalThreshold(Matrix,ZZ)"
  * logCanonicalThreshold(MonomialIdeal)
    -- log canonical threshold
  * "logCanonicalThreshold(MonomialIdeal,RingElement)"
  * "logCanonicalThreshold(Ring,List)"

multiplierIdeal(MonomialIdeal,QQ) -- multiplier ideal
*****************************************************

Synopsis
========

  * Function: multiplierIdeal (HyperplaneArrangements),

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

multiplier ideal of a monomial ideal
====================================

  * Usage:
        multiplierIdeal(I,t)
  * Inputs:
      * I, a monomial ideal (Macaulay2Doc), a monomial
        ideal in a polynomial ring
      * t, a rational number (Macaulay2Doc), a coefficient
  * Outputs:
      * an ideal (Macaulay2Doc),
Computes the multiplier ideal of $I$ with coefficient $t$ using Howald's
Theorem and the package Normaliz.
+--------------------------------------------------------------+
|i1 : R = QQ[x,y];                                             |
+--------------------------------------------------------------+
|i2 : I = monomialIdeal(y^2,x^3);                              |
|                                                              |
|o2 : MonomialIdeal of R                                       |
+--------------------------------------------------------------+
|i3 : multiplierIdeal(I,5/6)                                   |
|                                                              |
|o3 = monomialIdeal (x, y)                                     |
|                                                              |
|o3 : MonomialIdeal of R                                       |
+--------------------------------------------------------------+
|i4 : J = monomialIdeal(x^8,y^6); -- Example 2 of [Howald 2000]|
|                                                              |
|o4 : MonomialIdeal of R                                       |
+--------------------------------------------------------------+
|i5 : multiplierIdeal(J,1)                                     |
|                                                              |
|                     6   5    4 2   2 3     4   5             |
|o5 = monomialIdeal (x , x y, x y , x y , x*y , y )            |
|                                                              |
|o5 : MonomialIdeal of R                                       |
+--------------------------------------------------------------+

multiplier ideal of a hyperplane arrangement
============================================

  * Usage:
        multiplierIdeal(A,m,s)
  * Inputs:
      * A, a central hyperplane arrangement (HyperplaneArrangements),
        a central hyperplane
        arrangement
      * m, a list (Macaulay2Doc), a list of weights for the
        hyperplanes in $A$ (optional)
      * s, a number (Macaulay2Doc), a coefficient
  * Outputs:
      * an ideal (Macaulay2Doc),
Computes the multiplier ideal of the ideal of $A$ with coefficient $s$ using
the package HyperplaneArrangements.
+----------------------------------------------------------------------+
|i6 : R = QQ[x,y,z];                                                   |
+----------------------------------------------------------------------+
|i7 : f = toList factor((x^2 - y^2)*(x^2 - z^2)*(y^2 - z^2)*z) / first;|
+----------------------------------------------------------------------+
|i8 : A = arrangement f;                                               |
+----------------------------------------------------------------------+
|i9 : multiplierIdeal(A,3/7)                                           |
|                                                                      |
|o9 = ideal (z, y, x)                                                  |
|                                                                      |
|o9 : Ideal of R                                                       |
+----------------------------------------------------------------------+

multiplier ideal of monomial space curve
========================================

  * Usage:
        I = multiplierIdeal(R,n,t)
  * Inputs:
      * R, a ring (Macaulay2Doc),
      * n, a list (Macaulay2Doc), a list of three integers
      * t, a rational number (Macaulay2Doc),
  * Outputs:
      * I, an ideal (Macaulay2Doc),

Computes the multiplier ideal of the space curve $C$ parametrized by
$(t^a,t^b,t^c)$ given by $n=(a,b,c)$.

+--------------------------------+
|i10 : R = QQ[x,y,z];            |
+--------------------------------+
|i11 : n = {2,3,4};              |
+--------------------------------+
|i12 : t = 5/2;                  |
+--------------------------------+
|i13 : I = multiplierIdeal(R,n,t)|
|                                |
|              2         2       |
|o13 = ideal (y  - x*z, x  - z)  |
|                                |
|o13 : Ideal of R                |
+--------------------------------+

multiplier ideal of a generic determinantal ideal
=================================================

  * Usage:
        multiplierIdeal(R,L,r,t)
  * Inputs:
      * R, a ring (Macaulay2Doc), a ring
      * L, a list (Macaulay2Doc), dimensions $\{m,n\}$ of a matrix
      * r, an integer (Macaulay2Doc), the size of minors generating
        the determinantal ideal
      * t, a rational number (Macaulay2Doc), a coefficient
  * Outputs:
      * an ideal (Macaulay2Doc),
Computes the multiplier ideal of the ideal of $r \times r$ minors in a $m
\times n$ matrix whose entries are independent variables in the ring $R$ (a
generic matrix).
+-------------------------------+
|i14 : x = symbol x;            |
+-------------------------------+
|i15 : R = QQ[x_1..x_20];       |
+-------------------------------+
|i16 : X = genericMatrix(R,4,5);|
|                               |
|              4      5         |
|o16 : Matrix R  <-- R          |
+-------------------------------+
|i17 : multiplierIdeal(X,2,5/7) |
|                               |
|o17 = ideal 1                  |
|                               |
|o17 : Ideal of R               |
+-------------------------------+

See also
========

  * MonomialIdeal (Macaulay2Doc) -- the class of all
    monomial ideals handled by the engine

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

  * "multiplierIdeal(CentralArrangement,List,Number)"
  * "multiplierIdeal(CentralArrangement,Number)"
  * "multiplierIdeal(Matrix,ZZ,QQ)"
  * "multiplierIdeal(Matrix,ZZ,ZZ)"
  * multiplierIdeal(MonomialIdeal,QQ)
    -- multiplier ideal
  * "multiplierIdeal(MonomialIdeal,ZZ)"
  * "multiplierIdeal(Ring,List,QQ)"
  * "multiplierIdeal(Ring,List,ZZ)"