This is NonPrincipalTestIdeals.info, produced by Macaulay2, version 1.26.06

NonPrincipalTestIdeals -- a package for calculations of singularities of pairs in positive characteristic
*********************************************************************************************************

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

NonPrincipalTestIdeals is a package that can compute a test ideal $\tau(R,
I^t)$ of a pair $(R, I^t)$ where $R$ is a domain, $I$ is an ideal, and $t > 0$
is a rational number.  Currently, it works in Q-Gorenstein rings, although some
functions (such as checking for F-pure thresholds) are restricted to
quasi-Gorenstein strongly F-regular domains.

This package reduces the problem to the principal case by the mathematics
developed in the preprint
Test Modules of Extended Rees Algebras by Rahul Ajit and Hunter Simper,
arXiv:2509.01693.

After reducing to the principal case, some functions from the TestIdeals
package are used.  Note that this package requires Macaulay2 version 1.25 or
later.

Core functions
  * testIdeal (TestIdeals), computes the test ideal $\tau(R,
    I^t)$
  * testModule (TestIdeals), computes the test module
    $\tau(\omega_R, I^t)$
  * testModuleMinusEpsilon, computes the test
    module $\tau(\omega_R, I^{t-\epsilon})$ for arbitrary small $\epsilon > 0$
  * isFJumpingExponentModule, checks if $t$ is
    an F-jumping exponent for the test module $\tau(\omega_R, I^t)$
  * isFPT (FrobeniusThresholds), checks if $t$ is the F-pure
    threshold of the pair $(R, I)$
There are some other functions exported which people may also find useful.

Other useful functions
  * gradedReesPiece, computes a graded piece of a
    homogeneous ideal in a Rees algebra or extended Rees algebra

Requirements: All functions in this package require the ambient ring to be a
reduced equidimensional ring.  This ring must also be presented as a polynomial
ring over a field of characteristic $p > 0$ quotiented by an ideal.  Some other
functions including testIdeal, isFPT, isFJumpingNumber, torsionOrder,  and
isInvertibleIdeal require the ring to be a normal (or at least G1+S2) domain,
and in some cases even more.

History and support: This package was started in the 2023-2024 RTG seminar for
the NSF RTG grant #1840190 at the University of Utah.  Schwede also received
support from NSF grants #2101800 and #2501903 while working on this package.

Contributors
============

Rahul Ajit and Matthew Bertucci also contributed to the development of this
package.

Authors
=======

  * Trung Chau (see https://trungchaumath.github.io/ )
    <chauchitrung1996@gmail.com>
  * Karl Schwede (see https://www.math.utah.edu/~schwede/ )
    <schwede@math.utah.edu>
  * Hunter Simper (see https://www.huntersimper.com/ ) <hunter.simper@utah.edu>

Version
=======

This documentation describes version 1.0 of NonPrincipalTestIdeals, released
September 28th, 2025.

Citation
========

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

+-----------------------------------------------------------------------------+
|@misc{NonPrincipalTestIdealsSource,                                          |
|  title = {{NonPrincipalTestIdeals: singularities of pairs with non-principal|
|  author = {Trung Chau and Karl Schwede and Hunter Simper},                  |
|  howpublished = {A \emph{Macaulay2} package available at                    |
|    \url{https://github.com/Macaulay2/M2/tree/stable/M2/Macaulay2/packages}} |
|}                                                                            |
|-----------------------------------------------------------------------------|
|ideals. Version~1.0}},                                                       |
+-----------------------------------------------------------------------------+

Exports
=======

  * Functions and commands
      * classicalReesAlgebra -- computes the
        flattened Rees algebra
      * extendedReesAlgebra -- computes the
        flattened extended Rees algebra
      * gradedReesPiece -- gets a certain degree piece
        of an ideal in an (extended) Rees algebra
      * isFJumpingExponentModule -- decides if
        a rational number is a jumping exponent of a generalized parameter test
        module
      * isFRationalThreshold -- determines if a
        given number is the F-rational threshold, or, equivalently in the case
        of a quasi-Gorenstein ring, the F-pure threshold
      * isInvertibleIdeal -- checks whether an ideal
        is locally principal (invertible)
      * manualExt -- computes the Ext module of two modules
        as the core Ext function sometimes does not work properly in the
        negatively graded case
      * reesCanonicalModule -- constructs the
        graded canonical module in a ring constructed via classicalReesAlgebra
        or extendedReesAlgebra
      * reesModuleToIdeal -- embeds a homogeneous
        rank 1 module as an ideal in a Rees algebra
      * testModuleMinusEpsilon -- computes the
        (parameter) test module of a pair for values arbitrarily close to, but
        below, t
      * torsionOrder -- computes the local torsion order
        of an ideal in a normal domain
  * Methods
      * "classicalReesAlgebra(Ideal)" -- see classicalReesAlgebra,
        -- computes the flattened Rees algebra
      * "extendedReesAlgebra(Ideal)" -- see extendedReesAlgebra,
        -- computes the flattened extended Rees algebra
      * "gradedReesPiece(ZZ,Ideal)" -- see gradedReesPiece,
        -- gets a certain degree piece of an ideal in an
        (extended) Rees algebra
      * "isFJumpingExponent(QQ,Ideal)" -- see isFJumpingExponentModule,
        -- decides if a rational number is a jumping
        exponent of a generalized parameter test module
      * "isFJumpingExponent(ZZ,Ideal)" -- see isFJumpingExponentModule,
        -- decides if a rational number is a jumping
        exponent of a generalized parameter test module
      * "isFJumpingExponentModule(QQ,Ideal)" -- see
        isFJumpingExponentModule, -- decides if a
        rational number is a jumping exponent of a generalized parameter test
        module
      * "isFJumpingExponentModule(ZZ,Ideal)" -- see
        isFJumpingExponentModule, -- decides if a
        rational number is a jumping exponent of a generalized parameter test
        module
      * "isFPT(QQ,Ideal)" -- see isFRationalThreshold,
        -- determines if a given number is the F-rational
        threshold, or, equivalently in the case of a quasi-Gorenstein ring, the
        F-pure threshold
      * "isFPT(ZZ,Ideal)" -- see isFRationalThreshold,
        -- determines if a given number is the F-rational
        threshold, or, equivalently in the case of a quasi-Gorenstein ring, the
        F-pure threshold
      * "isFRationalThreshold(QQ,Ideal)" -- see isFRationalThreshold,
        -- determines if a given number is the F-rational
        threshold, or, equivalently in the case of a quasi-Gorenstein ring, the
        F-pure threshold
      * "isFRationalThreshold(ZZ,Ideal)" -- see isFRationalThreshold,
        -- determines if a given number is the F-rational
        threshold, or, equivalently in the case of a quasi-Gorenstein ring, the
        F-pure threshold
      * "isInvertibleIdeal(Ideal)" -- see isInvertibleIdeal,
        -- checks whether an ideal is locally principal
        (invertible)
      * "manualExt(ZZ,Module,Module)" -- see manualExt, --
        computes the Ext module of two modules as the core Ext function
        sometimes does not work properly in the negatively graded case
      * "reesCanonicalModule(Ring)" -- see reesCanonicalModule,
        -- constructs the graded canonical module in a
        ring constructed via classicalReesAlgebra or extendedReesAlgebra
      * "reesModuleToIdeal(Ring,Module)" -- see reesModuleToIdeal,
        -- embeds a homogeneous rank 1 module as an ideal in
        a Rees algebra
      * testIdeal(QQ,Ideal) -- computes the
        test ideal of a pair
      * "testIdeal(ZZ,Ideal)" -- see testIdeal(QQ,Ideal),
        -- computes the test ideal of a pair
      * testModule(QQ,Ideal) -- computes the
        test ideal of a pair
      * "testModule(ZZ,Ideal)" -- see testModule(QQ,Ideal),
        -- computes the test ideal of a pair
      * "testModuleMinusEpsilon(QQ,Ideal)" -- see testModuleMinusEpsilon,
        -- computes the (parameter) test module of a
        pair for values arbitrarily close to, but below, t
      * "testModuleMinusEpsilon(ZZ,Ideal)" -- see testModuleMinusEpsilon,
        -- computes the (parameter) test module of a
        pair for values arbitrarily close to, but below, t
      * "torsionOrder(ZZ,Ideal)" -- see torsionOrder, --
        computes the local torsion order of an ideal in a normal domain
  * Symbols
      * "AmbientCanonical" -- see reesCanonicalModule,
        -- constructs the graded canonical module in a
        ring constructed via classicalReesAlgebra or extendedReesAlgebra

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

The object NonPrincipalTestIdeals, is a package (Macaulay2Doc),
defined in NonPrincipalTestIdeals.m2.

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

The source of this document is in NonPrincipalTestIdeals.m2:809:0.

classicalReesAlgebra -- computes the flattened Rees algebra
***********************************************************

  * Usage:
        S = classicalReesAlgebra(J)
  * Inputs:
      * J, an ideal (Macaulay2Doc),
  * Outputs:
      * S, a ring (Macaulay2Doc),

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

This function calls the function reesAlgebra from the package ReesAlgebras and
formats it for our purposes.

The difference is this ring is flattened, and there are certain keys added for
obtaining information about this Rees algebra, as demonstrated in the example
below.

+---------------------------------------------+
|i1 : R = QQ[x,y,z];                          |
+---------------------------------------------+
|i2 : J= ideal(x^2,y);                        |
|                                             |
|o2 : Ideal of R                              |
+---------------------------------------------+
|i3 : S1 = reesAlgebra J;                     |
+---------------------------------------------+
|i4 : describe S1                             |
|                                             |
|      R[w ..w ]                              |
|         0   1                               |
|o4 = -----------                             |
|      2                                      |
|     x w  - y*w                              |
|        0      1                             |
+---------------------------------------------+
|i5 : S2 = classicalReesAlgebra J;            |
+---------------------------------------------+
|i6 : describe S2                             |
|                                             |
|     QQ[x..z, ly ..ly ]                      |
|                0    1                       |
|o6 = ------------------                      |
|         2                                   |
|        x ly  - y*ly                         |
|            0       1                        |
+---------------------------------------------+
|i7 : degrees S2                              |
|                                             |
|o7 = {{0, 1}, {0, 1}, {0, 1}, {1, 1}, {1, 2}}|
|                                             |
|o7 : List                                    |
+---------------------------------------------+

BaseRing provides the ring where we blew up the ideal.  Degree1 is the
generators of the degree 1 part of the Rees algebra.  BaseRingList is the list
of generators of the ideal we blew up.

Caveat
======

Currently, this only works for singly graded base rings.

See also
========

  * reesAlgebra (ReesAlgebra) -- Compute the defining ideal
    of the Rees Algebra
  * extendedReesAlgebra -- computes the flattened
    extended Rees algebra

Ways to use classicalReesAlgebra:
=================================

  * "classicalReesAlgebra(Ideal)"

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

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

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

The source of this document is in NonPrincipalTestIdeals.m2:1041:0.

extendedReesAlgebra -- computes the flattened extended Rees algebra
*******************************************************************

  * Usage:
        S = extendedReesAlgebra(J)
  * Inputs:
      * J, an ideal (Macaulay2Doc),
  * Outputs:
      * S, a ring (Macaulay2Doc),

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

This function creates an extended Rees algebra.  Unlike the reesAlgebra
command, this function creates a flattened ring with certain other keys added
for the convenience of other functions in this package.

+------------------------------------------------------+
|i1 : R = QQ[x,y,z];                                   |
+------------------------------------------------------+
|i2 : J= ideal(x^2,y);                                 |
|                                                      |
|o2 : Ideal of R                                       |
+------------------------------------------------------+
|i3 : S2 = extendedReesAlgebra J;                      |
+------------------------------------------------------+
|i4 : describe S2                                      |
|                                                      |
|               QQ[x..z, ly ..ly , ti]                 |
|                          0    1                      |
|o4 = ------------------------------------------       |
|       2                             2                |
|     (x ly  - y*ly , - y + ly ti, - x  + ly ti)       |
|          0       1          0             1          |
+------------------------------------------------------+
|i5 : degrees S2                                       |
|                                                      |
|o5 = {{0, 1}, {0, 1}, {0, 1}, {1, 1}, {1, 2}, {-1, 0}}|
|                                                      |
|o5 : List                                             |
+------------------------------------------------------+

Caveat
======

Currently, this only works for singly graded base rings.

See also
========

  * reesAlgebra (ReesAlgebra) -- Compute the defining ideal
    of the Rees Algebra
  * classicalReesAlgebra -- computes the flattened
    Rees algebra

Ways to use extendedReesAlgebra:
================================

  * "extendedReesAlgebra(Ideal)"

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

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

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

The source of this document is in NonPrincipalTestIdeals.m2:1069:0.

gradedReesPiece -- gets a certain degree piece of an ideal in an (extended) Rees algebra
****************************************************************************************

  * Usage:
        J = gradedReesPiece(n, I)
  * Inputs:
      * n, an integer (Macaulay2Doc), a natural number
      * I, an ideal (Macaulay2Doc), an ideal in an (extended Rees
        algebra)
  * Outputs:
      * J, an ideal (Macaulay2Doc), an ideal in an the base ring

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

Given an ideal $J$ in a Rees ring $T = \oplus T_i$ constructed either with
classicalReesAlgebra, or extendedReesAlgebra,
this will take the $n$th graded piece of $J$ and express
it as an ideal in $T_0$.

+-----------------------------------------+
|i1 : R = QQ[x,y];                        |
+-----------------------------------------+
|i2 : J = ideal(x,y);                     |
|                                         |
|o2 : Ideal of R                          |
+-----------------------------------------+
|i3 : S = classicalReesAlgebra(J);        |
+-----------------------------------------+
|i4 : trim gradedReesPiece(0, ideal(1_S)) |
|                                         |
|o4 = ideal 1                             |
|                                         |
|o4 : Ideal of R                          |
+-----------------------------------------+
|i5 : trim gradedReesPiece(1, ideal(1_S)) |
|                                         |
|o5 = ideal (y, x)                        |
|                                         |
|o5 : Ideal of R                          |
+-----------------------------------------+
|i6 : trim gradedReesPiece(3, ideal(1_S)) |
|                                         |
|             3     2   2    3            |
|o6 = ideal (y , x*y , x y, x )           |
|                                         |
|o6 : Ideal of R                          |
+-----------------------------------------+
|i7 : T = extendedReesAlgebra(J);         |
+-----------------------------------------+
|i8 : trim gradedReesPiece(-1, ideal(1_T))|
|                                         |
|o8 = ideal 1                             |
|                                         |
|o8 : Ideal of R                          |
+-----------------------------------------+
|i9 : trim gradedReesPiece(0, ideal(1_T)) |
|                                         |
|o9 = ideal 1                             |
|                                         |
|o9 : Ideal of R                          |
+-----------------------------------------+
|i10 : trim gradedReesPiece(2, ideal(1_T))|
|                                         |
|              2        2                 |
|o10 = ideal (y , x*y, x )                |
|                                         |
|o10 : Ideal of R                         |
+-----------------------------------------+

Note the command basis (Macaulay2Doc), cannot be used in the
extended Rees algebra case as it cannot handle rings with both positive and
negative degrees.

See also
========

  * classicalReesAlgebra -- computes the flattened
    Rees algebra
  * extendedReesAlgebra -- computes the flattened
    extended Rees algebra
  * basis (Macaulay2Doc) -- basis or generating set of all or part
    of a ring, ideal or module

Ways to use gradedReesPiece:
============================

  * "gradedReesPiece(ZZ,Ideal)"

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

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

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

The source of this document is in NonPrincipalTestIdeals.m2:848:0.

isFJumpingExponentModule -- decides if a rational number is a jumping exponent of a generalized parameter test module
*********************************************************************************************************************

  * Usage:
        b = isFJumpingExponentModule(t, J)
  * Inputs:
      * t, a rational number (Macaulay2Doc), the exponent
      * J, an ideal (Macaulay2Doc), the ideal of the pair
  * Optional inputs (Macaulay2Doc),:
      * AtOrigin => ..., default value false
      * FrobeniusRootStrategy => ..., default value Substitution
      * Verbose => ..., default value false
  * Outputs:
      * b, a Boolean value (Macaulay2Doc),

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

Given an ideal $J$ in a ring $R$ and a rational number $t$, this function
determines if $\tau(\omega_R, J^t) \neq \tau(\omega_R, J^{t-\epsilon})$ for all
$1 \gg \epsilon > 0$.  If so, it returns true, that is $t$ is a jumping
exponent of $\tau(\omega_R, J^*)$, and otherwise it returns false.

+-----------------------------------------------------------------------------+
|i1 : R = ZZ/3[x,y,z];                                                        |
+-----------------------------------------------------------------------------+
|i2 : J = ideal(x^3,y^4,z^5);                                                 |
|                                                                             |
|o2 : Ideal of R                                                              |
+-----------------------------------------------------------------------------+
|i3 : isFJumpingExponent(1/3+1/4+1/5, J) -- should be true, this is the fpt = |
|                                                                             |
|o3 = true                                                                    |
|-----------------------------------------------------------------------------|
|lct                                                                          |
+-----------------------------------------------------------------------------+
|i4 : isFJumpingExponent(1/3+1/4, J) -- should be false                       |
|                                                                             |
|o4 = false                                                                   |
+-----------------------------------------------------------------------------+

The option AtOrigin (default) checks whether the jump happens is done at the
origin (as opposed to anywhere).

+----------------------------------------------------+
|i5 : R = ZZ/3[x,y];                                 |
+----------------------------------------------------+
|i6 : J = ideal(x-1,y);                              |
|                                                    |
|o6 : Ideal of R                                     |
+----------------------------------------------------+
|i7 : isFJumpingExponentModule(2, J, AtOrigin=>false)|
|                                                    |
|o7 = true                                           |
+----------------------------------------------------+
|i8 : isFJumpingExponentModule(2, J, AtOrigin=>true) |
|                                                    |
|o8 = false                                          |
+----------------------------------------------------+

The formulation isFJumpingExponent(t, J) also computes whether the test ideal
jumps at $t$.  However, it only works if $R$ is a quasi-Gorenstein normal
domain as in that case the jumping numbers of $\tau(R, J^t)$ agree with those
of $\tau(\omega_R, J^t)$.

See also
========

  * isFJumpingExponent (FrobeniusThresholds), --
    whether a given number is an F-jumping exponent
  * isFPT(QQ,Ideal) (missing documentation)

Ways to use isFJumpingExponentModule:
=====================================

  * "isFJumpingExponentModule(QQ,Ideal)"
  * "isFJumpingExponentModule(ZZ,Ideal)"

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

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

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

The source of this document is in NonPrincipalTestIdeals.m2:1145:0.

isFRationalThreshold -- determines if a given number is the F-rational threshold, or, equivalently in the case of a quasi-Gorenstein ring, the F-pure threshold
***************************************************************************************************************************************************************

  * Usage:
        b = isFRationalThreshold(t, I)
        b = isFPT(t,I)
  * Inputs:
      * t, a rational number (Macaulay2Doc), the number which might
        equal the threshold
      * I, an ideal (Macaulay2Doc), the ideal whose threshold you
        want to compute
  * Optional inputs (Macaulay2Doc),:
      * AtOrigin => ..., default value false
      * FrobeniusRootStrategy => ..., default value Substitution
      * Verbose => ..., default value false
  * Outputs:
      * b, a Boolean value (Macaulay2Doc), is it the threshold
        or not

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

Given an ideal $I$ in a domain $R$, this determines whether a rational $t$ is
the $F$-rational threshold, that is whether or not $\tau(\omega_R, I^t) \neq
\omega_R$ while $\tau(\omega_R, I^{t-\epsilon}) = \omega_R$.  In the case of a
quasi-Gorenstein strongly $F$-regular ring (ie, if $\omega_R$ is an invertible
ideal, for instance if its principal), this is equivalent to the $F$-pure
threshold of $(R, I)$.  Hence, you may also call isFPT(R, I) in that case.

+--------------------------------------------------------------------+
|i1 : R = ZZ/3[x,y,z];                                               |
+--------------------------------------------------------------------+
|i2 : I = ideal(x^2,y^3,z^5); --fpt should be 1/2 + 1/3 + 1/5 = 31/30|
|                                                                    |
|o2 : Ideal of R                                                     |
+--------------------------------------------------------------------+
|i3 : isFPT(31/30, I)                                                |
|                                                                    |
|o3 = true                                                           |
+--------------------------------------------------------------------+
|i4 : isFRationalThreshold(31/30, I)                                 |
|                                                                    |
|o4 = true                                                           |
+--------------------------------------------------------------------+
|i5 : isFRationalThreshold(1, I)                                     |
|                                                                    |
|o5 = false                                                          |
+--------------------------------------------------------------------+
|i6 : isFPT(32/30, I)                                                |
|                                                                    |
|o6 = false                                                          |
+--------------------------------------------------------------------+

The option AtOrigin says that the computation must only be checked at the
origin.

+-----------------------------------------------------------------------------+
|i7 : R = ZZ/3[u,v]                                                           |
|                                                                             |
|o7 = R                                                                       |
|                                                                             |
|o7 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i8 : I = ideal( (u-1)^2, v^3) --fpt should be 1/2+1/3 = 5/6, but it's not the|
|                                                                             |
|             2           3                                                   |
|o8 = ideal (u  + u + 1, v )                                                  |
|                                                                             |
|o8 : Ideal of R                                                              |
|-----------------------------------------------------------------------------|
|threshold at the origin                                                      |
+-----------------------------------------------------------------------------+
|i9 : isFPT(5/6, I)                                                           |
|                                                                             |
|o9 = true                                                                    |
+-----------------------------------------------------------------------------+
|i10 : isFRationalThreshold(5/6, I, AtOrigin=>true)                           |
|                                                                             |
|o10 = false                                                                  |
+-----------------------------------------------------------------------------+

The Verbose option turns on debugging output if true.  The option
FrobeniusRootStrategy is passed on to the TestIdealsPackage.

See also
========

  * isFPT (FrobeniusThresholds) -- checks whether a given rational
    number is the F-pure threshold
  * isFJumpingExponent (FrobeniusThresholds), --
    whether a given number is an F-jumping exponent
  * isFJumpingExponentModule -- decides if a
    rational number is a jumping exponent of a generalized parameter test
    module

Ways to use isFRationalThreshold:
=================================

  * "isFRationalThreshold(QQ,Ideal)"
  * "isFRationalThreshold(ZZ,Ideal)"

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

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

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

The source of this document is in NonPrincipalTestIdeals.m2:1290:0.

isInvertibleIdeal -- checks whether an ideal is locally principal (invertible)
******************************************************************************

  * Usage:
        b = isInvertibleIdeal(I)
  * Inputs:
      * I, an ideal (Macaulay2Doc),
  * Outputs:
      * b, a Boolean value (Macaulay2Doc),

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

Given an ideal $I$, this function returns true if $I$ is locally principal, and
false otherwise.  It will work in a normal domain (or more generally a G1 + S2
domain reduced equidimensional ring).

+-----------------------------------------------------------------------------+
|i1 : R = QQ[x,y]/(y^2-x*(x-1)*(x+1)); --an elliptic curve                    |
+-----------------------------------------------------------------------------+
|i2 : I = ideal(x,y); --corresponding to a point, should be invertible, even  |
|                                                                             |
|o2 : Ideal of R                                                              |
|-----------------------------------------------------------------------------|
|if not principal                                                             |
+-----------------------------------------------------------------------------+
|i3 : isInvertibleIdeal(I)--should be true                                    |
|                                                                             |
|o3 = true                                                                    |
+-----------------------------------------------------------------------------+
|i4 : S = QQ[u,v];                                                            |
+-----------------------------------------------------------------------------+
|i5 : J = ideal(u,v);                                                         |
|                                                                             |
|o5 : Ideal of S                                                              |
+-----------------------------------------------------------------------------+
|i6 : isInvertibleIdeal(J) --should be false                                  |
|                                                                             |
|o6 = false                                                                   |
+-----------------------------------------------------------------------------+

This frequently also works in non-domains.

+------------------------------------------------------+
|i7 : R = QQ[w..z]/ideal(x*y,x*z,y*z,x^2-y^2,x^2-z^2); |
+------------------------------------------------------+
|i8 : isInvertibleIdeal(ideal(w,x)) -- should be false |
|                                                      |
|o8 = false                                            |
+------------------------------------------------------+
|i9 : isInvertibleIdeal(ideal(x,y,z)) -- should be true|
|                                                      |
|o9 = true                                             |
+------------------------------------------------------+

Ways to use isInvertibleIdeal:
==============================

  * "isInvertibleIdeal(Ideal)"

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

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

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

The source of this document is in NonPrincipalTestIdeals.m2:1206:0.

manualExt -- computes the Ext module of two modules as the core Ext function sometimes does not work properly in the negatively graded case
*******************************************************************************************************************************************

  * Usage:
        M = manualExt(t, N, P)
  * Inputs:
      * t, an integer (Macaulay2Doc), the homological degree
      * N, a module (Macaulay2Doc), a module
      * P, a module (Macaulay2Doc), a module
  * Outputs:
      * M, a module (Macaulay2Doc),

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

Given two modules $N$ and $P$ over a ring $R$ and an integer $t$, this function
computes and returns ${Ext}_R^t(N,P)$.

+-------------------------------------+
|i1 : R = S = QQ[X,T,Degrees=>{1,-1}];|
+-------------------------------------+
|i2 : N = S^1/ideal(X*T-1);           |
+-------------------------------------+
|i3 : P = S^1;                        |
+-------------------------------------+
|i4 : manualExt(1, N, P)              |
|                                     |
|o4 = cokernel | XT-1 |               |
|                                     |
|                            1        |
|o4 : S-module, quotient of S         |
+-------------------------------------+
|i5 : Ext^1(N,P)                      |
|                                     |
|o5 = cokernel | XT-1 |               |
|                                     |
|                            1        |
|o5 : S-module, quotient of S         |
+-------------------------------------+

See also
========

  * Ext (Macaulay2Doc) -- compute an Ext module

Ways to use manualExt:
======================

  * "manualExt(ZZ,Module,Module)"

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

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

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

The source of this document is in NonPrincipalTestIdeals.m2:1175:0.

reesCanonicalModule -- constructs the graded canonical module in a ring constructed via classicalReesAlgebra or extendedReesAlgebra
***********************************************************************************************************************************

  * Usage:
        M = reesCanonicalModule(S)
  * Inputs:
      * S, a ring (Macaulay2Doc), constructed with
        classicalReesAlgebra or extendedReesAlgebra
  * Optional inputs (Macaulay2Doc),:
      * AmbientCanonical => ..., default value null
  * Outputs:
      * M, a module (Macaulay2Doc), the graded canonical module
        over S

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

Computes the graded canonical modules of a ring constructed with
classicalReesAlgebra, or extendedReesAlgebra,
or

+----------------------------------------------------------------+
|i1 : R = QQ[x,y];                                               |
+----------------------------------------------------------------+
|i2 : J = ideal(x^2,x*y,y^2);                                    |
|                                                                |
|o2 : Ideal of R                                                 |
+----------------------------------------------------------------+
|i3 : S = classicalReesAlgebra(J);                               |
+----------------------------------------------------------------+
|i4 : T = extendedReesAlgebra(J);                                |
+----------------------------------------------------------------+
|i5 : reesCanonicalModule(S)                                     |
|                                                                |
|o5 = cokernel {1, 3} | -ly_1 ly_0  -y |                         |
|              {1, 3} | ly_2  -ly_1 x  |                         |
|                                                                |
|                            2                                   |
|o5 : S-module, quotient of S                                    |
+----------------------------------------------------------------+
|i6 : reesCanonicalModule(T)                                     |
|                                                                |
|o6 = cokernel {1, 3} | bt_0 -bt_1 -y   x     0     0    -ti 0  ||
|              {1, 3} | bt_1 -bt_2 0    0     -y    x    0   ti ||
|              {0, 2} | 0    0     bt_1 -bt_2 -bt_0 bt_1 x   y  ||
|                                                                |
|                            3                                   |
|o6 : T-module, quotient of T                                    |
+----------------------------------------------------------------+

The option AmbientCanonical is used to specify the canonical module of ambient
S.

Caveat
======

One should use this function and not other similar functions to create
canonical modules in extended Rees algebras, especially in older versions of
Macaulay2.  This is because core Macaulay2 Ext function sometimes gives the
wrong answer in rings with variables of negative degrees.  See this github
issue https://github.com/Macaulay2/M2/issues/3180

See also
========

  * classicalReesAlgebra -- computes the flattened
    Rees algebra
  * extendedReesAlgebra -- computes the flattened
    extended Rees algebra
  * gradedReesPiece -- gets a certain degree piece of
    an ideal in an (extended) Rees algebra

Ways to use reesCanonicalModule:
================================

  * "reesCanonicalModule(Ring)"

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

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

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

The source of this document is in NonPrincipalTestIdeals.m2:884:0.

reesModuleToIdeal -- embeds a homogeneous rank 1 module as an ideal in a Rees algebra
*************************************************************************************

  * Usage:
        (I,d,phi) = reesModuleToIdeal(S, M)
  * Inputs:
      * S, a ring (Macaulay2Doc), constructed with
        classicalReesAlgebra or extendedReesAlgebra
      * M, a module (Macaulay2Doc), a homogeneous S-module
  * Optional inputs (Macaulay2Doc),:
      * MTries => ..., default value 10
  * Outputs:
      * I, an ideal (Macaulay2Doc), an ideal of S isomorphic to M
        as a module
      * d, an integer (Macaulay2Doc), the degree shift between the
        module and ideal
      * phi, a matrix (Macaulay2Doc), the map M to S^1 whose
        image is I

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

In the following example we embed the canonical module of an extended Rees
algebra and then embed it as an ideal.  Note there is a degree shift.

+-----------------------------------------------------------------------------+
|i1 : R = QQ[x,y];                                                            |
+-----------------------------------------------------------------------------+
|i2 : J = ideal(x^2,x*y^2,y^3);                                               |
|                                                                             |
|o2 : Ideal of R                                                              |
+-----------------------------------------------------------------------------+
|i3 : S = extendedReesAlgebra(J);                                             |
+-----------------------------------------------------------------------------+
|i4 : canMod = reesCanonicalModule(S)                                         |
|                                                                             |
|o4 = cokernel {1, 3} | ly_1 -ly_2  0    -y2  x     0   -ti y |               |
|              {0, 2} | 0    0      ly_1 ly_2 -ly_0 -y  x   0 |               |
|              {1, 3} | ly_2 -yly_0 y2   0    0     -ti 0   x |               |
|                                                                             |
|                            3                                                |
|o4 : S-module, quotient of S                                                 |
+-----------------------------------------------------------------------------+
|i5 : L = reesModuleToIdeal(S, canMod) --the first entry -1 of {-1,-2} refers |
|                                                                             |
|o5 = (ideal (ti, y, x), {-1, -2}, | x ti -y |)                               |
|                                                                             |
|o5 : Sequence                                                                |
|-----------------------------------------------------------------------------|
|to the Rees algebra degree                                                   |
+-----------------------------------------------------------------------------+
|i6 : L#2 -- the map from canMod to S                                         |
|                                                                             |
|o6 = | x ti -y |                                                             |
|                                                                             |
|             1                                                               |
|o6 : Matrix S  <-- canMod                                                    |
+-----------------------------------------------------------------------------+

The MTries option specifies how many attempts to make before giving up.

See also
========

  * classicalReesAlgebra -- computes the flattened
    Rees algebra
  * extendedReesAlgebra -- computes the flattened
    extended Rees algebra
  * gradedReesPiece -- gets a certain degree piece of
    an ideal in an (extended) Rees algebra

Ways to use reesModuleToIdeal:
==============================

  * "reesModuleToIdeal(Ring,Module)"

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

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

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

The source of this document is in NonPrincipalTestIdeals.m2:923:0.

testIdeal(QQ,Ideal) -- computes the test ideal of a pair
********************************************************

  * Function: testIdeal (TestIdeals),
  * Usage:
        J = testIdeal(t, I)
  * Inputs:
      * t, a rational number (Macaulay2Doc), a rational number
      * I, an ideal (Macaulay2Doc), an ideal
  * Optional inputs (Macaulay2Doc),:
      * AssumeDomain (TestIdeals), => ..., default value false,
      * FrobeniusRootStrategy (TestIdeals), => ..., default
        value Substitution,
      * MaxCartierIndex (TestIdeals), => ..., default value 10,
      * QGorensteinIndex (TestIdeals), => ..., default value 0,
  * Outputs:
      * J, an ideal (Macaulay2Doc), an ideal, the test ideal

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

This computes the test ideal $\tau(R, I^t)$ of an ideal $I$ in a normal
quasi-Gorenstein domain $R$.  We begin with example in a regular ring.

+------------------------------+
|i1 : R = ZZ/5[x,y];           |
+------------------------------+
|i2 : I = ideal(x^2, y^3);     |
|                              |
|o2 : Ideal of R               |
+------------------------------+
|i3 : testIdeal(5/6, I)        |
|                              |
|o3 = ideal (y, x)             |
|                              |
|o3 : Ideal of R               |
+------------------------------+
|i4 : testIdeal(5/6-1/25, I)   |
|                              |
|o4 = ideal 1                  |
|                              |
|o4 : Ideal of R               |
+------------------------------+
|i5 : testIdeal(2, I)          |
|                              |
|             2    3   4     3 |
|o5 = ideal (x y, x , y , x*y )|
|                              |
|o5 : Ideal of R               |
+------------------------------+

We now include an example in a singular ring.

+------------------------------------+
|i6 : R = ZZ/3[x,y,z]/ideal(x^2-y*z);|
+------------------------------------+
|i7 : I = ideal(x,y);                |
|                                    |
|o7 : Ideal of R                     |
+------------------------------------+
|i8 : testIdeal(1, I)                |
|                                    |
|o8 = ideal (y, x)                   |
|                                    |
|o8 : Ideal of R                     |
+------------------------------------+
|i9 : I2 = ideal(x,y,z);             |
|                                    |
|o9 : Ideal of R                     |
+------------------------------------+
|i10 : testIdeal(3/2,I2)             |
|                                    |
|o10 = ideal (z, y, x)               |
|                                    |
|o10 : Ideal of R                    |
+------------------------------------+

See also
========

  * testIdeal (TestIdeals) -- compute a test ideal in a
    Q-Gorenstein ring
  * testModule(QQ,Ideal) (missing documentation)
  * testModule (TestIdeals) -- find the parameter test module
    of a reduced ring

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

  * testIdeal(QQ,Ideal) -- computes the test
    ideal of a pair
  * "testIdeal(ZZ,Ideal)"
-------------------------------------------------------------------------------

The source of this document is in NonPrincipalTestIdeals.m2:962:0.

testModule(QQ,Ideal) -- computes the test ideal of a pair
*********************************************************

  * Function: testModule (TestIdeals),
  * Usage:
        J = testModule(t, I)
  * Inputs:
      * t, a rational number (Macaulay2Doc), a rational number
      * I, an ideal (Macaulay2Doc), an ideal
  * Optional inputs (Macaulay2Doc),:
      * AssumeDomain (TestIdeals), => ..., default value
        false,
      * CanonicalIdeal (TestIdeals), => ..., default value
        null,
      * CurrentRing (TestIdeals), => ..., default value null,
      * FrobeniusRootStrategy (TestIdeals), => ..., default
        value Substitution,
      * GeneratorList (TestIdeals), => ..., default value
        null,
  * Outputs:
      * L, a list (Macaulay2Doc), a list with the test module and
        the canonical module

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

This computes the test module $\tau(\omega_R, I^t)$ of an ideal $I$ in a domain
$R$ of index not divisible by the characteristic $p > 0$. It returns a list
with two entries.  The first is the ideal of $R$ isomorphic viewed as an ideal
of $R$ isomorphic to $\tau(\omega_R, J^t)$. The second is an ideal $R$
isomorphic to $\omega_R$, in which the first module sits as a subideal.

We begin with example in a regular ring.

+----------------------------+
|i1 : R = ZZ/5[x,y];         |
+----------------------------+
|i2 : I = ideal(x^2, y^3);   |
|                            |
|o2 : Ideal of R             |
+----------------------------+
|i3 : testModule(5/6, I)     |
|                            |
|o3 = (ideal (y, x), ideal 1)|
|                            |
|o3 : Sequence               |
+----------------------------+
|i4 : testModule(5/6-1/25, I)|
|                            |
|o4 = (ideal 1, ideal 1)     |
|                            |
|o4 : Sequence               |
+----------------------------+

We now include an example in a non-Gorenstein ring

+----------------------------------------------------+
|i5 : T = ZZ/2[a,b,c,d];                             |
+----------------------------------------------------+
|i6 : S = ZZ/2[x,y];                                 |
+----------------------------------------------------+
|i7 : f = map(S, T, {x^3, x^2*y, x*y^2, y^3});       |
|                                                    |
|o7 : RingMap S <-- T                                |
+----------------------------------------------------+
|i8 : R = T/(ker f);                                 |
+----------------------------------------------------+
|i9 : m = ideal(a,b,c,d);                            |
|                                                    |
|o9 : Ideal of R                                     |
+----------------------------------------------------+
|i10 : testModule(1, m)                              |
|                                                    |
|                                   2                |
|o10 = (ideal (b*d, a*d, a*c, a*b, a ), ideal (b, a))|
|                                                    |
|o10 : Sequence                                      |
+----------------------------------------------------+
|i11 : testModule(1-1/16, m)                         |
|                                                    |
|o11 = (ideal (b, a), ideal (b, a))                  |
|                                                    |
|o11 : Sequence                                      |
+----------------------------------------------------+

See also
========

  * testModule (TestIdeals) -- find the parameter test module
    of a reduced ring
  * testModule(QQ,Ideal) (missing documentation)
  * testModuleMinusEpsilon -- computes the
    (parameter) test module of a pair for values arbitrarily close to, but
    below, t
  * testIdeal (TestIdeals) -- compute a test ideal in a
    Q-Gorenstein ring
  * testIdeal(QQ,Ideal) (missing documentation)

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

  * testModule(QQ,Ideal) -- computes the
    test ideal of a pair
  * "testModule(ZZ,Ideal)"
-------------------------------------------------------------------------------

The source of this document is in NonPrincipalTestIdeals.m2:1007:0.

testModuleMinusEpsilon -- computes the (parameter) test module of a pair for values arbitrarily close to, but below, t
**********************************************************************************************************************

  * Usage:
        M = testModuleMinusEpsilon(t, J)
  * Inputs:
      * t, a rational number (Macaulay2Doc), the exponent we are
        interested in
      * J, an ideal (Macaulay2Doc), the ideal were are interested
        in
  * Outputs:
      * S, a ring (Macaulay2Doc),

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

This function computes $\tau(\omega_R, J^{t-\epsilon})$, the test module of the
pair $(R, J^{t-\epsilon})$ for $1 \gg \epsilon > 0$.  It returns a list with
two entries.  The first is the ideal of $R$ isomorphic viewed as an ideal of
$R$ isomorphic to $\tau(\omega_R, J^t)$. The second is an ideal $R$ isomorphic
to $\omega_R$, in which the first module sits as a subideal.

+-------------------------------------------+
|i1 : R = ZZ/5[x,y,z];                      |
+-------------------------------------------+
|i2 : J = ideal(x^2,y^2,z^2);               |
|                                           |
|o2 : Ideal of R                            |
+-------------------------------------------+
|i3 : testModuleMinusEpsilon(3/2,J)         |
|                                           |
|o3 = (ideal (0, 1, y*z, x*z, x*y), ideal 1)|
|                                           |
|o3 : Sequence                              |
+-------------------------------------------+
|i4 : apply(oo, JJ -> trim JJ)              |
|                                           |
|o4 = (ideal 1, ideal 1)                    |
|                                           |
|o4 : Sequence                              |
+-------------------------------------------+
|i5 : testModule(3/2, J)                    |
|                                           |
|o5 = (ideal (z, y, x), ideal 1)            |
|                                           |
|o5 : Sequence                              |
+-------------------------------------------+

In the above example, one can see that 3/2 is the F-pure threshold of the given
ideal $J$, as expected.

Caveat
======

There is not a guarantee different calls to the function will always produce
the same ambient canonical module.

See also
========

  * testModule (TestIdeals) -- find the parameter test module
    of a reduced ring

Ways to use testModuleMinusEpsilon:
===================================

  * "testModuleMinusEpsilon(QQ,Ideal)"
  * "testModuleMinusEpsilon(ZZ,Ideal)"

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

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

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

The source of this document is in NonPrincipalTestIdeals.m2:1102:0.

torsionOrder -- computes the local torsion order of an ideal in a normal domain
*******************************************************************************

  * Usage:
        (m,J) = torsionOrder(n, I)
  * Inputs:
      * n, an integer (Macaulay2Doc), the maximum order to check
      * I, an ideal (Macaulay2Doc), the ideal you want to check
  * Outputs:
      * m, an integer (Macaulay2Doc), the local torsion order of the
        ideal in the class group, or 0 if not found
      * J, an ideal (Macaulay2Doc), the reflexive hull of $I^n$

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

Given an ideal $I$ in a normal (or G1 + S2) domain, this computes the local
torsion order of the class of $I$.  In other words, this computes the smallest
integer $m$ such that $I^{m}$ is locally principal up to reflexification (that
is, $(I^{m})^{**}$ is locally principal).

This function returns a pair $(m, (I^{m})^{**})$ if such an $m$ is found.  If
no $m$ is found, this returns $(0, ideal 0)$.

+------------------------------------------------------------------------+
|i1 : R = QQ[x,y,z]/ideal(x*y+z^7);                                      |
+------------------------------------------------------------------------+
|i2 : I = ideal(x,z);                                                    |
|                                                                        |
|o2 : Ideal of R                                                         |
+------------------------------------------------------------------------+
|i3 : torsionOrder(10, I) --the order should be 7                        |
|                                                                        |
|o3 = (7, ideal x)                                                       |
|                                                                        |
|o3 : Sequence                                                           |
+------------------------------------------------------------------------+
|i4 : torsionOrder(5, I) --we only check up to 5, so this should return 0|
|                                                                        |
|o4 = (0, ideal 0)                                                       |
|                                                                        |
|o4 : Sequence                                                           |
+------------------------------------------------------------------------+

As we are computing the reflexive hull, this function does not distinguish
between the ideal $I$ and the ideal made up of the height-one components of a
primary decomposition of $I$.

+----------------------------------------------------+
|i5 : R = ZZ/5[a,b,c]/ideal(a*b-c^8)                 |
|                                                    |
|o5 = R                                              |
|                                                    |
|o5 : QuotientRing                                   |
+----------------------------------------------------+
|i6 : torsionOrder(10, (ideal(a,b,c))^2*(ideal(a,c)))|
|                                                    |
|o6 = (8, ideal a)                                   |
|                                                    |
|o6 : Sequence                                       |
+----------------------------------------------------+

Ways to use torsionOrder:
=========================

  * "torsionOrder(ZZ,Ideal)"

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

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

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

The source of this document is in NonPrincipalTestIdeals.m2:1241:0.