The FrobeniusThresholds package for Macaulay2

TL;DR

The FrobeniusThresholds package for Macaulay2 provides tools to compute and estimate $F$-thresholds and related invariants, aiding the study of singularities in prime characteristic algebra.

Contribution

It introduces a new Macaulay2 package that automates the calculation of $F$-pure thresholds and related invariants, enhancing computational approaches in singularity theory.

Findings

Enables efficient computation of $F$-pure thresholds.

Provides estimates for generalized $F$-thresholds.

Facilitates research in prime characteristic singularities.

Abstract

This article describes the \emph{Macaulay2} package \emph{FrobeniusThresholds}, designed to estimate and calculate $F$-pure thresholds, more general $F$-thresholds, and related numerical invariants arising in the study of singularities in prime characteristic commutative algebra.

Equations

$${\nu }_f^{\mathfrak{m}}(p^e):=\max \{n\in \mathbb{N}:f^n\notin {\mathfrak{m}}^{[p^e]}\},$$

$$c^{\mathfrak{m}}(f):=\underset{e\to \infty }{\lim }\frac{{\nu }_f^{\mathfrak{m}}(p^e)}{p^e}.$$

$$c^{\mathfrak{m}}(f)=\inf \{t>0:\tau (f^t)\subseteq \mathfrak{m}\}=\sup \{t>0:\sigma (f^t)\ne 0\},$$

$${\nu }_f^{\mathfrak{m}}(p^e)=\lceil p^e\cdot c^{\mathfrak{m}}(f)\rceil -1.$$

$${\nu }_I^J(p^e):=\max \{n\in \mathbb{N}:I^n⊈J^{[p^e]}\},$$

$$c^J(I):=\underset{e\to \infty }{\lim }\frac{{\nu }_I^J(p^e)}{p^e}$$

$${\nu }_I^J(p^e)={\nu }_I^J(p^{e-1})\cdot p+L,$$

$$I^n\subseteq J^{[p^e]}⟺(I^n{)}^{[1/p^e]}\subseteq J,$$

$$†$$

Full text

D. J. Hernández was partially supported by NSF DMS #1600702.

K. Schwede was supported by NSF CAREER Grant DMS #1252860/1501102, NSF FRG Grant DMS #1265261/1501115, NSF grant #1801849 and a Sloan Fellowship.

E. E. Witt was partially supported by NSF DMS #1623035.

1. Introduction

This paper describes the Macaulay2 package FrobeniusThresholds [GS, BHS*+*], which provides tools for computing or estimating certain fundamental invariants in positive characteristic commutative algebra, namely $F$-pure thresholds, $F$-thresholds, and $F$-jumping exponents. Recall that a ring of prime characteristic $p>0$ is $F$-pure if the Frobenius map—that is, the ring endomorphism sending an element to its $p$-th power—is a pure morphism; under natural geometric hypotheses, this is equivalent to the condition that the Frobenius morphism splits as a map of rings. The concept of $F$-purity has proven to be important in commutative algebra, and has a rich history. Indeed, it first appeared in the work of Hochster and Roberts to study local cohomology [HR76], was compared with rational singularities in [Fed83], and was used to study global properties of Schubert varieties in [MR85].

After the advent of tight closure [HH90], the use of the Frobenius map to quantify singularity—that is, deviation from regularity—proliferated, and based on a connection discovered between $F$-pure and log canonical singularities [HW02], the concept of $F$-purity was generalized to the context of pairs. Along these lines, the $F$-pure threshold was defined in analogy with the log canonical threshold [TW04], and $F$-thresholds were introduced as a natural extension [MTW05].

The connection between the $F$-pure threshold and the log canonical threshold, however, extends beyond mere analogy. For example, suppose $h$ is a polynomial with integer coefficients, and that $h_{p}$ is the polynomial obtained by reducing the coefficients of $h$ modulo a prime $p$. Then, the $F$-pure thresholds of the reductions $h_{p}$ converge to the log canonical threshold of $h$ as $p$ tends to infinity [HY03]. A related result is that of Zhu, who proved that the log canonical threshold of $h$ is at least the $F$-pure threshold of any reduction $h_{p}$ [Zhu17, Corollary 4.2].

This latter result is interesting from a computational perspective, in that it provides lower bounds for log canonical thresholds. Though there is a general purpose implementation of an algorithm for computing log canonical thresholds in the Dmodules package [LT]111The MultiplierIdeals package [TSR, Tei15] also computes log canonical thresholds in many special cases, including monomial ideals, hyperplane arrangements, generic determinantal ideals, and certain binomial ideals. , the function for computing $F$-pure thresholds contained in the FrobeniusThresholds package is typically much faster, especially so in low characteristic.

In summary, the $F$-pure threshold is an interesting numerical invariant, related to many other measures of singularity across all characteristics, and has been the focus of intense study over the past fifteen years. Unfortunately, it is typically difficult to calculate. The package FrobeniusThresholds is centered on calculating and estimating the $F$-pure threshold and other $F$-thresholds, with the function fpt at its core. It builds heavily upon the TestIdeals package for Macaulay2 [BBB*+*, BHK*+*18], which provides a broad range of functionality for effective computation in prime characteristic commutative algebra.

1.1. Some background and notation

Although some of the functionality implemented in FrobeniusThresholds is not restricted to regular ambient rings (see Section 3), for the sake of concreteness, in this introduction we will work in a polynomial ring over a finite field of characteristic $p$. The ideal of this ring generated by its variables is denoted $\mathfrak{m}$.

Let us outline a way in which natural numerical invariants in prime characteristic commutative algebra are often constructed: For every natural number $e$, associate to some fixed data—often, a collection of polynomials or ideals—an integer describing something of relevance that depends on $e$ (e.g., the dimension of some interesting vector space constructed in terms of the initial data). Normalize this integer by dividing by some power of $p^{e}$, and then take the limit as the integer $e$ tends to infinity. The resulting limit, if it exists, should then encode some interesting information about the initial data.

Consider a nonzero polynomial $f$ and a natural number $e$. If $f$ does not vanish at the origin, then set $\nu_{f}^{\mathfrak{m}}(p^{e}):=\infty$. Otherwise, $f\in\mathfrak{m}$, and we instead define

[TABLE]

where $\mathfrak{m}^{[p^{e}]}$ denotes the $p^{e}$-th Frobenius power of $\mathfrak{m}$, that is, the ideal generated by the $p^{e}$-th powers of the elements of $\mathfrak{m}$. Following our outline, we define

[TABLE]

This limit exists, and is a rational number when $f\in\mathfrak{m}$, though the latter is far from obvious [BMS08]. Inspired by its connections with the $F$-purity of pairs, this limit is called the $F$-pure threshold of $f$ at the origin.

The $F$-pure threshold is closely related to many other fundamental concepts in prime characteristic commutative algebra. For instance,

[TABLE]

where $\tau(f^{t})$ and $\sigma(f^{t})$ are the test ideal and $F$-signature, respectively, associated to $f$ and the formal nonnegative real exponent $t$. The former is an ideal in the ambient ring of $f$, and the latter is a real number; both depend on the parameter $t$ and the characteristic $p$ in subtle ways [BMS08, BST12].

In the literature, the $F$-pure threshold $\operatorname{c}^{\mathfrak{m}}(f)$ is often denoted $\operatorname{fpt}(f)$, for obvious reasons. However, in this note we adopt the former notation to avoid any possible confusion with the function fpt described in Section 4, which some times does not output the number $\operatorname{c}^{\mathfrak{m}}(f)=\operatorname{fpt}(f)$, but returns, instead, lower and upper bounds for that number.

It turns out that the sequence \big{(}\nu_{f}^{\mathfrak{m}}(p^{e})\big{)}_{e=0}^{\infty} itself, and not just its limit, encodes interesting information about $f$. For example, it is closely related to the Bernstein–Sato polynomial of $f$ [MTW05]. Thus, it is natural to ask whether one can recover the sequence \big{(}\nu_{f}^{\mathfrak{m}}(p^{e})\big{)}_{e=0}^{\infty} from the limit $\operatorname{c}^{\mathfrak{m}}(f)$. Fortunately, the answer to this question is yes [MTW05, Her12]; for each $e$ we have

[TABLE]

We conclude this subsection by briefly reviewing some natural generalizations. Suppose that $I$ and $J$ are ideals. If $I$ is contained in the radical of $J$, then we set

[TABLE]

or $\nu_{I}^{J}(p^{e})\coloneqq 0$, when the set on the right-hand side is empty. Otherwise, we set $\nu_{I}^{J}(p^{e})\coloneqq\infty$. This clearly generalizes the quantity $\nu_{f}^{\mathfrak{m}}(p^{e})$ considered earlier, and we call

[TABLE]

the $F$-threshold of $I$ with respect to $J$. The value $\operatorname{c}^{\mathfrak{m}}(I)$ is called the $F$-pure threshold of $I$ at the origin, and if $I=\langle f\rangle$ is principal, $\operatorname{c}^{J}(f)\coloneqq\operatorname{c}^{J}(I)$ is called the $F$-threshold of $f$ with respect to $J$. Like $F$-pure thresholds, $F$-thresholds are rational (when finite), and can be characterized in terms of test ideals.

Acknowledgements.

The authors enthusiastically thank everyone who helped complete the FrobeniusThresholds package: the package coauthors Juliette Bruce and Daniel Smolkin, and contributors Erin Bela, Zhibek Kadyrsizova, Moty Katzman, Sara Malec, and Marcus Robinson.

Thanks go to the organizers of the Macaulay2 workshops where much of the functionality described herein was developed, hosted by Wake Forest University in 2012, the University of California, Berkeley in 2014 and 2017, Boise State University in 2015, and the University of Utah in 2016.

Finally, the authors are grateful to the University of Utah for hosting a collaborative development visit in 2018, and to the Institute of Mathematics and its Applications for its generous support for our 2019 Coding Sprint. The current version of the package was finalized during these events.

2. The nu function

We first consider the nu function, a fundamental component of the package FrobeniusThresholds. We adopt the setup established in the introduction: we work in a polynomial ring $R$ over a finite field of characteristic $p>0$, $\mathfrak{m}$ denotes the ideal generated by the variables, and $e$ is a natural number. If $I$ and $J$ are ideals of $R$, the command nu(e,I,J) outputs the extended integer $\nu_{I}^{J}(p^{e})$ defined in the introduction; if $f$ is an element of $R$, nu(e,f,J) outputs $\nu_{f}^{J}(p^{e})\coloneqq\nu_{\langle f\rangle}^{J}(p^{e})$. When the third argument is omitted from the function nu, it is assumed to be the maximal ideal $\mathfrak{m}$.

i1 : R = ZZ/11[x,y];i2 : I = ideal(x^2 + y^3, xy);o2 : Ideal of Ri3 : J = ideal(x^2, y^3);o3 : Ideal of Ri4 : nu(2, I, J)o4 = 281i5 : f = xy*(x^2 + y^2);i6 : nu(2, f, J)o6 = 120

2.1. Options for nu

We now describe the options available for the function nu. As pointed out in the introduction, if $f\in\mathfrak{m}$, the values $\nu^{\mathfrak{m}}_{f}(p^{e})$ can be recovered from the $F$-pure threshold of $f$. This is used to speed up computations for certain polynomials whose $F$-pure thresholds can be computed quickly via specialized algorithms or formulas, namely diagonal polynomials, binomials, forms in two variables, and products of factors in simple normal crossing (see Section 4). This feature can be disabled by setting the option UseSpecialAlgorithms (default value true) to false.222In Section 4.1 we discuss a couple of situations in which this may be desirable.

i7 : R = ZZ/17[x,y,z];i8 : f = x^3 + y^4 + z^5; -- a diagonal polynomiali9 : time nu(10, f)     -- used 0.0161622 secondso9 = 1541642394460i10 : time nu(10, f, UseSpecialAlgorithms => false)     -- used 2.06877 secondso10 = 1541642394460

In general, the function nu works by searching through a list of integers $n$, and checking containments of the $n$-th power of $I$ in the specified Frobenius power of $J$. It is well known that, for any positive integer $e$,

[TABLE]

where the error term $L$ is nonnegative and can be explicitly bounded from above in terms of $p$ and the number of generators of $I$ and $J$. For instance, the error term $L$ is at most $p-1$ when $I$ is principal and $J$ is arbitrary. This implies that when searching for the maximal exponent defining nu(e,I,J) for positive $e$, it is safe to start at $p$ times the output of nu(e-1,I,J), and one need not search too far past this number. This also suggests that the most efficient way to compute nu(e,I,J) is to compute, successively, nu(s,I,J), for each integer $s=0,\ldots,e$, and this is indeed how the computation is done in most cases.

The user can specify how the search is approached through the option Search, which can take two values: Binary (the default value) and Linear.

i11 : R = ZZ/5[x,y,z];i12 : m = ideal(x, y, z);o12 : Ideal of Ri13 : time nu(2, m, m^2) -- uses binary search (default)     -- used 1.82479 secondso13 = 97i14 : time nu(2, m, m^2, Search => Linear) -- but linear search gets luckier     -- used 0.597035 secondso14 = 97

If the option ReturnList is changed from its default value of false to true, nu outputs a list of the values $\nu_{I}^{J}(p^{s})$, for $s=0,\ldots,e$, at no additional computational cost.

i15 : nu(5, x^2y^4 + y^2z^7 + z^2*x^8, ReturnList => true)o15 = {0, 1, 8, 44, 224, 1124}o15 : List

The same information can be found by setting the option Verbose to true, to request that the values $\nu_{I}^{J}(p^{s})$ be printed as they are iteratively computed (serving also as a way to monitor the progress of the computation).

As described in the introduction, the integer $\nu_{I}^{J}(p^{e})$ is the maximal integer $n$ such that the $n$-th power of $I$ is not contained in the $p^{e}$-th Frobenius power of $J$. However,

[TABLE]

where $(I^{n})^{[1/p^{e}]}$ denotes the $p^{e}$-th Frobenius root of $I^{n}$, as defined in [BMS08]. The option ContainmentTest for nu allows the user to choose which of the two types of containment statements appearing above to use toward the calculation of $\nu_{I}^{J}(p^{e})$.

If ContainmentTest is set to StandardPower, then nu(e,I,J) is computed by testing the left-hand containment above, and when it is set to FrobeniusRoot, the right-hand containment is checked. For efficiency reasons, the default value for ContainmentTest is set to FrobeniusRoot if the second argument passed to nu is a polynomial, and is set to StandardPower if the second argument is an ideal.

i16 : R = ZZ/11[x,y,z];i17 : f = x^3 + y^3 + z^3 + xyz;i18 : time nu(3, f) -- ContainmentTest is set to FrobeniusRoot, by default     -- used 0.153691 secondso18 = 1209i19 : time nu(3, f, ContainmentTest => StandardPower)     -- used 10.1343 secondso19 = 1209

The option ContainmentTest has a third possible value, FrobeniusPower, which allows nu to compute a different but analogous invariant. The first, third, and fourth authors introduced the notion of a (generalized) Frobenius power $I^{[n]}$ of an ideal $I$, when $n$ is an arbitrary nonnegative integer [HTW18]. When ContainmentTest is set to FrobeniusPower, rather than computing $\nu_{I}^{J}(p^{e})$, the function nu computes the maximal integer $n$ for which $I^{[n]}$ is not contained in $J^{[p^{e}]}$. This number is denoted $\mu_{I}^{J}(p^{e})$ in loc. cit., and equals $\nu_{I}^{J}(p^{e})$ when $I$ is a principal ideal. However, these numbers need not agree in general, as we see below.

i20 : R = ZZ/3[x,y];i21 : m = ideal(x, y);o21 : Ideal of Ri22 : nu(4, m^5)o22 = 32i23 : nu(4, m^5, ContainmentTest => FrobeniusPower)o23 = 26

The last option we describe for nu is AtOrigin. Recall that $\nu_{I}^{\mathfrak{m}}(p^{e})$ can be interpreted as the maximum integer $n$ for which $(I^{n})^{[1/p^{e}]}$ is not contained in $\mathfrak{m}$. When the option AtOrigin is set to false (from its default value true), the function nu determines, instead, the maximum integer $n$ for which $(I^{n})^{[1/p^{e}]}$ is the unit ideal, which can also be characterized as the minimal integer $\nu_{I}^{\mathfrak{n}}(p^{e})$ as $\mathfrak{n}$ varies among all maximal ideals of the ring.

i24 : R = ZZ/7[x,y];i25 : f = (x - 1)^3 - (y - 2)^2;i26 : nu(3, f)o26 = infinityo26 : InfiniteNumberi27 : nu(3, f, AtOrigin => false)o27 = 285

3. isFPT, compareFPT and isFJumpingExponent

The FrobeniusThresholds package contains methods to test candidate values for $F$-pure thresholds and $F$-jumping numbers, even in some singular rings. Consider a $\mathbb{Q}$-Gorenstein ring $R$ of characteristic $p>0$, whose index is not divisible by $p$. Given a parameter $t\in\mathbb{Q}$ and an element $f$ of $R$, the command isFPT(t, f) checks whether $t$ is the $F$-pure threshold of $f$, while compareFPT(t, f) provides further information, returning -1, 0, or 1 when $t$ is, respectively, less than, equal to, or greater than the $F$-pure threshold of $f$. Setting the option AtOrigin to true tells the function to consider the $F$-pure threshold at the origin.

i1 : R = ZZ/11[x,y,z]/(x^2 - y*(z - 1));i2 : compareFPT(5/11, z - 1)o2 = -1i3 : isFPT(1/2, z - 1)o3 = truei4 : isFPT(1/2, z - 1, AtOrigin => true)o4 = false

The general method applied calls upon functionality from the TestIdeals package. The functions testIdeal and FPureModule therein are used to compute the test ideals $\tau(f^{t})$ and $\tau(f^{t-\varepsilon})$, for $0<\varepsilon\ll 1$. By comparing these test ideals, we can decide whether $t$ is the $F$-pure threshold of $f$. For instance, when $R$ is a polynomial ring, $t$ is the $F$-pure threshold of $f$ at the origin if and only if $\tau(f^{t})$ is contained in the homogeneous maximal ideal, but $\tau(f^{t-\varepsilon})$ is not.

Since not only the $F$-pure thresholds, but also the higher $F$-jumping numbers, are determined by containment conditions on test ideals, the functionality is extended to determine whether a given number is an $F$-jumping number.

i5 : R = ZZ/13[x,y];i6 : f = y*((y + 1) - (x - 1)^2)(x - 2)(x + y - 2);i7 : isFJumpingExponent(3/4, f)o7 = truei8 : isFPT(3/4, f)o8 = false

4. The fpt function

The core function in the package FrobeniusThresholds is called fpt. Throughout this section, let $f$ be a polynomial with coefficients in a finite field of characteristic $p$. When passed the polynomial $f$, the function fpt attempts to find the exact value for the $F$-pure threshold of $f$ at the origin, and returns that value, if possible. Otherwise, it returns lower and upper bounds for the $F$-pure threshold, as demonstrated below.

i1 : R = ZZ/5[x,y,z];i2 : fpt(x^3 + y^3 + z^3 + xyz)     4o2 = -     5o2 : QQi3 : fpt(x^5 + y^6 + z^7 + (xyz)^3)       7  2o3 = {--, -}      25  5o3 : List

4.1. The option UseSpecialAlgorithms

The fpt function has an option called UseSpecialAlgorithms, which, when set to true (its default value), tells fpt to first check whether $f$ is a diagonal polynomial, a binomial, a form in two variables, or a product of factors in simple normal crossing, in that order. When $f$ is a diagonal polynomial, a binomial, or a form in two variables, algorithms of Hernández [Her15, Her14] or Hernández and Teixeira [HT17] are executed to compute the $F$-pure threshold.

i4 : fpt(x^17 + y^20 + z^24) -- a diagonal polynomial      94o4 = ---     625o4 : QQi5 : fpt(x^2y^6z^10 + x^10y^5z^3) -- a binomial      997o5 = ----     6250o5 : QQi6 : R = ZZ/5[x,y];i7 : fpt(x^2y^6(x + y)^9*(x + 3*y)^10) -- a form in two variables      5787o7 = -----     78125o7 : QQ

The algorithm for computing the $F$-pure threshold of a binary form $f$ requires factoring $f$ into linear forms, and that may be difficult or impossible when that factorization occurs in a Galois field of excessively large order. This is a situation when the user will want to set the option UseSpecialAlgorithms to false. However, when a factorization is already known, instead of passing $f$ to fpt, the user can pass a list containing all the pairwise coprime linear factors of $f$ to fpt, and a list containing their respective multiplicities.

i8 : fpt({x, y, x + y, x + 3*y}, {2, 6, 9, 10}) == ooo8 = true

If UseSpecialAlgorithms is set to true and $f$ does not fall into any of the aforementioned cases, then the function fpt next calls isSimpleNormalCrossing(f) (see Section 4.3) to check whether the polynomial $f$ is (locally, at the origin) a product of factors that are in simple normal crossing, in which case the $F$-pure threshold is simply the reciprocal of the largest multiplicity occurring in that factorization. Note that the function factor is called whenever isSimpleNormalCrossing is used, and that can sometimes make the verification slow. The user can avoid this by setting UseSpecialAlgorithms to false.

4.2. When no special algorithm applies

We now explain how the function fpt proceeds when no special algorithm is available, or when UseSpecialAlgorithms is set to false. In this case, fpt computes a sequence of lower and upper bounds for the $F$-pure threshold of $f$, and either finds its exact value in this process, or outputs the last of these sets of bounds, which will be the tightest among all computed. The value of the option DepthOfSearch determines the precision of the initial set of bounds, and the option Attempts determines, roughly, how many new, tighter sets of bounds are to be computed.

More specifically, let $e$ denote the value of the option DepthOfSearch, which conservatively defaults to 1. The fpt function first computes $\nu=\nu_{f}(p^{e})$, which agrees with the output of nu(e,f). It is well known that the $F$-pure threshold of $f$ is greater than $\nu/p^{e}$ and at most $(\nu+1)/p^{e}$, and applying [Her12, Proposition 4.2] to the lower bound tells us that the $F$-pure threshold of $f$ must be at least $\nu/(p^{e}-1)$. In summary, we know that the $F$-pure threshold of $f$ must lie in the closed interval

[TABLE]

With these estimates in hand, the subroutine guessFPT is called to make some “educated guesses” in an attempt to identify the $F$-pure threshold within this interval, or at least narrow down this interval to produce improved estimates. The number of “guesses” is controlled by the option Attempts, which conservatively defaults to 3. If Attempts is set to 0, then guessFPT is bypassed. If Attempts is set to at least 1, then a first check is run to verify whether the right-hand endpoint $(\nu+1)/p^{e}$ of the above interval ($\dagger$ ‣ 4.2) is the $F$-pure threshold. We illustrate this below.

i9 : f = x^2*(x + y)^3*(x + 3*y^2)^5;i10 : fpt(f, Attempts => 0) -- a bad estimate          1o10 = {0, -}          5o10 : Listi11 : fpt(f, Attempts => 0, DepthOfSearch => 3) -- a better estimate        21   22o11 = {---, ---}       124  125o11 : Listi12 : fpt(f, Attempts => 1, DepthOfSearch => 3) -- the right-hand endpoint      (ν+1)/p^e is the F-pure threshold       22o12 = ---      125o12 : QQ

If Attempts is set to at least 2 and the right-hand endpoint $(\nu+1)/p^{e}$ of the interval ($\dagger$ ‣ 4.2) is not the $F$-pure threshold, then a second check is run to verify whether the left-hand endpoint $\nu/(p^{e}-1)$ of this interval is the $F$-pure threshold.

i13 : f = x^6y^4 + x^4y^9 + (x^2 + y^3)^3;i14 : fpt(f, Attempts => 1, DepthOfSearch => 3)       17   7o14 = {--, --}       62  25o14 : Listi15 : fpt(f, Attempts => 2, DepthOfSearch => 3) -- the left-hand endpoint      ν/(p^e-1) is the F-pure threshold      17o15 = --      62o15 : QQ

If neither endpoint is the $F$-pure threshold and Attempts is set to more than 2, then additional checks are performed at certain numbers within the interval. First, a number in the interval is selected, according to criteria specified by the value of the option GuessStrategy; we refer the reader to the documentation of this option for more details. Then the function compareFPT is used to test that number. If that “guess” is correct, its value is returned; otherwise, the information returned by compareFPT is used to narrow down the interval, and this process is repeated as many times as specified by Attempts.

i16 : f = x^3y^11(x + y)^8*(x^2 + y^3)^8;i17 : fpt(f, DepthOfSearch => 3, Attempts => 4)        1   4o17 = {--, --}       20  75o17 : Listi18 : fpt(f, DepthOfSearch => 3, Attempts => 6)        13   4o18 = {---, --}       250  75o18 : Listi19 : fpt(f, DepthOfSearch => 3, Attempts => 8)       1o19 = --      19o19 : QQ

The option Bounds allows the user to specify known lower and upper bounds for the $F$-pure threshold of $f$, in order to speed up computations or to refine previously obtained estimates.

i20 : f = x^7y^5(x + y)^5*(x^2 + y^3)^4;i21 : fpt(f, DepthOfSearch => 3, Attempts => 5)        19   1o21 = {---, --}       250  13o21 : Listi22 : fpt(f, DepthOfSearch => 3, Attempts => 5, Bounds => oo)        45   1o22 = {---, --}       589  13o22 : List

If guessFPT is unsuccessful and FinalAttempt is set to true, the fpt function proceeds to use the convexity of the $F$-signature function and a secant line argument to attempt to narrow down the interval bounding the $F$-pure threshold. If successful, the new lower bound may coincide with the upper bound, in which case we can conclude that it is the desired $F$-pure threshold. If this is not the case, a check is performed to verify if the new lower bound is the $F$-pure threshold.

i23 : f = 2x^10y^8 + x^4y^7 - 2x^3*y^8;i24 : numeric fpt(f, DepthOfSearch => 3)o24 = {.14, .144}o24 : Listi25 : numeric fpt(f, DepthOfSearch => 3, FinalAttempt => true)      -- FinalAttempt improves the estimate slightlyo25 = {.142067, .144}o25 : List

The computations performed when FinalAttempt is set to true are often slow, and often fail to improve the estimate, and for this reason, this option should be used sparingly. It is typically more effective to increase the values of Attempts or DepthOfSearch, instead.

i26 : time numeric fpt(f, DepthOfSearch => 3, FinalAttempt => true)     -- used 0.72874 secondso26 = {.142067, .144}o26 : Listi27 : time fpt(f, DepthOfSearch => 3, Attempts => 7)     -- used 0.452872 seconds      1o27 = -      7o27 : QQi28 : time fpt(f, DepthOfSearch => 4)     -- used 0.338834 seconds      1o28 = -      7o28 : QQ

As seen in several examples above, when the exact answer is not found, a list containing the endpoints of an interval containing the $F$-pure threshold of $f$ is returned. Whether that interval is open, closed, or a mixed interval depends on the options passed (it will be open whenever Attempts is set to at least 3); if the option Verbose is set to true, the precise interval will be printed.

i29 : fpt(f, DepthOfSearch => 3, FinalAttempt => true, Verbose => true)Starting fpt ...fpt is not 1 ...Verifying if special algorithms apply...Special fpt algorithms were not used ...ν has been computed: ν = nu(3,f) = 17 ...fpt lies in the interval [ν/(p^e-1),(ν+1)/p^e] = [17/124,18/125] ...Starting guessFPT ...The right-hand endpoint is not the fpt ...The left-hand endpoint is not the fpt ...guessFPT narrowed the interval down to (7/50,18/125) ...Beginning F-signature computation ...First F-signature computed: s(f,(ν-1)/p^e) = 793/15625 ...Second F-signature computed: s(f,ν/p^e) = 342/15625 ...Computed F-signature secant line intercept: 8009/56375 ...F-signature intercept is an improved lower bound;Using F-regularity to check if it is the fpt ...The new lower bound is not the fpt ...fpt failed to find the exact answer; try increasing the value of    DepthOfSearch or Attempts.fpt lies in the interval (8009/56375,18/125).        8009   18o29 = {-----, ---}       56375  125o29 : List

Finally, we point out that one can set the option AtOrigin from its default value of true to false, to compute the $F$-pure threshold globally. In other words, it computes the minimum of the $F$-pure threshold at all maximal ideals.

i30 : R = ZZ/7[x,y];i31 : f = x*(y - 1)^2 - y*(x - 1)^3;i32 : fpt(f)o32 = 1i33 : fpt(f, AtOrigin => false)      5o33 = -      6o33 : QQ

In this case, most features enabled by UseSpecialAlgorithms => true are ignored, except for the check for simple normal crossings; FinalAttempt => true is also ignored.

4.3. The function isSimpleNormalCrossings

As mentioned earlier, the function isSimpleNormalCrossings verifies whether a polynomial $f$ is a product of factors in simple normal crossing. Suppose that $f$ has factorization $f_{1}^{a_{i}}f_{2}^{a_{2}}\cdots f_{n}^{a_{n}}$. Recall that its factors $f_{i}$ are said to be in simple normal crossing at a point if, locally, they form part of a regular system of parameters. The function isSimpleNormalCrossings determines whether $f$ has simple normal crossings at the origin by computing the Jacobian matrix of each subset of $\{f_{1},\ldots,f_{n}\}$ (evaluated at the origin), and checking that these matrices have the expected rank, and that these subsets generate ideals of the appropriate height.

i34 : R = ZZ/7[x,y,z];i35 : isSimpleNormalCrossing(x^2 - y^2)o35 = truei36 : isSimpleNormalCrossing(x^2 - y*z)o36 = false

The function isSimpleNormalCrossing is exposed to the user, so can be used independent of any $F$-pure threshold calculation. If the user sets its option AtOrigin to false (its default value is true), then the function checks whether the $f_{i}$ are in simple normal crossing everywhere, which can be much slower, since Jacobian ideals are computed.

i37 : R = QQ[x,y,z];i38 : f = (y - (x - 1)^2)*y^2; --SNC at the origin, but not globallyi39 : isSimpleNormalCrossing(f)o39 = truei40 : isSimpleNormalCrossing(f, AtOrigin => false)o40 = false

5. Possible Future Directions

One natural direction of development would be to incorporate the test ideals $\tau(I^{t})$ when computing $F$-thresholds in the case where the ideal $I$ is nonprincipal. The theoretical foundation for computing such test ideals has already largely been worked out in [ST14], but such an update to the FrobeniusThresholds package would require the TestIdeals package to be updated first.

At the moment, the specialized algorithm called by the fpt function for computing the $F$-pure threshold of a homogeneous polynomial in two variables limits us to working with the standard grading on the ambient polynomial ring. Clearly, it is desirable to be able to work with nonstandard gradings as well, and results of [HT17] suggest an algorithm for doing so. Thus, the package could be improved by finalizing and implementing such an algorithm.

Finally, it would be desirable to develop and implement additional algorithms for computing $F$-pure thresholds and $F$-jumping numbers for additional classes of polynomials. The first, third, and fourth authors, along with Josep Álvarez Montaner, Jack Jeffries, and Luis Núñez-Betancourt, are currently working on developing such algorithms. The theoretical foundation of these algorithms lies in polyhedral geometry and integer programming, making them natural candidates for implementation in Macaulay2.