fpt -- attempt to compute the F-pure threshold of a polynomial at the origin or globally

Synopsis

• Usage:
fpt(f)
fpt(L, m)
• Inputs:
• f, , a polynomial with coefficients in a finite field
• L, a list, containing linear forms in two variables
• m, a list, containing positive integers
• Optional inputs:
• Attempts => an integer, default value 3, specifies the number of "guess and check" attempts to make
• Bounds => a list, default value {0, 1}, consisting of two numbers, known to be lower and upper bounds, respectively, of the $F$-pure threshold of f
• DepthOfSearch => an integer, default value 1, specifies the power of the characteristic to be used in a search for the $F$-pure threshold
• FinalAttempt => , default value false, specifies whether to use the $F$-signature function and a secant line argument to attempt to improve the $F$-pure threshold estimate
• GuessStrategy => , default value null, specifies a function to be used to rank numbers to be tested
• GuessStrategy => a list, default value null, specifies weights to be used to rank numbers to be tested
• AtOrigin => , default value true, specifies whether to compute the $F$-pure threshold at the origin or the global $F$-pure threshold
• UseSpecialAlgorithms => , default value true, specifies whether to check if f is a diagonal polynomial, binomial, a standard-graded homogeneous polynomial in two variables, or a product of factors in simple normal crossing, and then apply appropriate algorithms or formulas
• Verbose => , default value false, requests verbose feedback
• Outputs:
• a list, containing lower and upper bounds for the $F$-pure threshold of f
• , the $F$-pure threshold of f
• , the $F$-pure threshold of f, if f does not vanish at the origin (or anywhere, if AtOrigin => false)

Description

Given a polynomial $f$ with coefficients in a finite field, 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.

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

When the option UseSpecialAlgorithms is set to true (the default value), fpt first checks whether $f$ is a diagonal polynomial, a binomial, a form in two variables, or a product of factors in simple normal crossing. If $f$ is either a diagonal polynomial, a binomial, or a form in two variables, then algorithms of Hernández, or Hernández and Teixeira, are executed to compute the $F$-pure threshold of $f$. If $f$ is a product of factors in simple normal crossing, the $F$-pure threshold is easily computed.

 i4 : fpt(x^17 + y^20 + z^24) -- a diagonal polynomial 94 o4 = --- 625 o4 : QQ i5 : fpt(x^2*y^6*z^10 + x^10*y^5*z^3) -- a binomial 997 o5 = ---- 6250 o5 : QQ i6 : fpt(x^5*(x + y)^7*(x + y + z)^10) -- SNC 1 o6 = -- 10 o6 : QQ i7 : ZZ/5[x,y]; i8 : fpt(x^2*y^6*(x + y)^9*(x + 3*y)^10) -- a form in two variables 5787 o8 = ----- 78125 o8 : QQ

The computation of the $F$-pure threshold of a form $f$ in two variables requires factoring $f$ into linear forms, and can sometimes hang when attempting that factorization. For this reason, when a factorization is already known, the user can pass to fpt a list containing all the pairwise prime linear factors of $f$ and a list containing their respective multiplicities.

 i9 : fpt({x, y, x + y, x + 3*y}, {2, 6, 9, 10}) == oo o9 = true

When no special algorithm is available or UseSpecialAlgorithms is set to false, fpt computes $\nu$ = frobeniusNu(e,f), where $e$ is the value of the option DepthOfSearch, which conservatively defaults to 1. At this point, we know that the $F$-pure threshold of $f$ lies in the closed interval [$\nu/(p^e-1),(\nu+1)/p^e$], and the subroutine guessFPT is called to make some "educated guesses" in an attempt to find the $F$-pure threshold, or at least narrow down the above interval. The number of "guesses" is controlled by the option Attempts, which conservatively defaults to 3. If Attempts is set to 0, 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 is the $F$-pure threshold.

 i10 : f = x^2*(x + y)^3*(x + 3*y^2)^5; i11 : fpt(f, Attempts => 0) -- a bad estimate 1 o11 = {0, -} 5 o11 : List i12 : fpt(f, Attempts => 0, DepthOfSearch => 3) -- a better estimate 21 22 o12 = {---, ---} 124 125 o12 : List i13 : fpt(f, Attempts => 1, DepthOfSearch => 3) -- the right-hand endpoint (ν+1)/p^e is the fpt 22 o13 = --- 125 o13 : QQ

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

 i14 : f = x^6*y^4 + x^4*y^9 + (x^2 + y^3)^3; i15 : fpt(f, Attempts => 1, DepthOfSearch => 3) 17 7 o15 = {--, --} 62 25 o15 : List i16 : fpt(f, Attempts => 2, DepthOfSearch => 3) -- the left-hand endpoint ν/(p^e-1) is the fpt 17 o16 = -- 62 o16 : QQ

If neither endpoint is the $F$-pure threshold and Attempts is set to more than 2, then additional checks are performed at numbers in the interval. A number in the interval is selected, according to criteria specified by the option GuessStrategy (see its documentation for details), and 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.

 i17 : f = x^3*y^11*(x + y)^8*(x^2 + y^3)^8; i18 : fpt(f, DepthOfSearch => 3, Attempts => 4) 1 4 o18 = {--, --} 20 75 o18 : List i19 : fpt(f, DepthOfSearch => 3, Attempts => 6) 13 4 o19 = {---, --} 250 75 o19 : List i20 : fpt(f, DepthOfSearch => 3, Attempts => 8) 1 o20 = -- 19 o20 : 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.

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

If guessFPT is unsuccessful and FinalAttempt is set to true, the function fpt 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 that is not the case, an $F$-regularity check is done at the new lower bound, to verify if it is the $F$-pure threshold.

 i24 : f = 2*x^10*y^8+x^4*y^7-2*x^3*y^8; i25 : numeric fpt(f, DepthOfSearch => 3) o25 = {.14, .144} o25 : List i26 : numeric fpt(f, DepthOfSearch => 3, FinalAttempt => true) -- FinalAttempt improves the estimate slightly o26 = {.142067, .144} o26 : 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 often more effective to increase the values of Attempts or DepthOfSearch, instead.

 i27 : time numeric fpt(f, DepthOfSearch => 3, FinalAttempt => true) -- used 0.882473 seconds o27 = {.142067, .144} o27 : List i28 : time fpt(f, DepthOfSearch => 3, Attempts => 7) -- used 0.533529 seconds 1 o28 = - 7 o28 : QQ i29 : time fpt(f, DepthOfSearch => 4) -- used 0.432908 seconds 1 o29 = - 7 o29 : 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.

 i30 : fpt(f, DepthOfSearch => 3, FinalAttempt => true, Verbose => true) Starting fpt ... fpt is not 1 ... Verifying whether special algorithms apply... Special fpt algorithms were not used ... ν has been computed: ν = frobeniusNu(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 18 o30 = {-----, ---} 56375 125 o30 : List

Setting the option AtOrigin (default value true) to false can be used to tell the function to compute the $F$-pure threshold globally. In other words, it computes the minimum of the $F$-pure threshold at all maximal ideals.

 i31 : R = ZZ/7[x,y]; i32 : f = x*(y - 1)^2 - y*(x - 1)^3; i33 : fpt(f) o33 = 1 i34 : fpt(f, AtOrigin => false) 5 o34 = - 6 o34 : 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.

Consider a simple normal crossings case.

 i35 : f = x*y^2*(x - 1)^3*(y - 1)^4; i36 : fpt(f) 1 o36 = - 2 o36 : QQ i37 : fpt(f, AtOrigin => false) 1 o37 = - 4 o37 : QQ