# fpt -- attempts to compute the F-pure threshold of a polynomial at the origin

## Synopsis

• Usage:
fpt(f)
fpt(L, m)
• Inputs:
• f, , a polynomial with coefficients in a finite field
• L, a list, containing forms in two variables
• m, a list, containing positive integers
• Optional inputs:
• DepthOfSearch => an integer, default value 1, specifies the power of the characteristic to be used in a search for the F-pure threshold
• FRegularityCheck => , default value false, specifies whether to check if the final lower bound is the F-pure threshold of f
• MaxChecks => an integer, default value 3, specifies the number of "guess and check" attempts to make
• UseFSignature => , 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
• UseSpecialAlgorithms => , default value true, specifies whether to check if f is diagonal, binomial, or a binary form (i.e., a standard-graded homogeneous polynomial in 2 variables), and then apply appropriate algorithms
• Verbose => , default value false, requests verbose feedback
• Outputs:
• a list, which contains the endpoints of an interval containing lower and upper bounds for the F-pure threshold of f
• Q, , the F-pure threshold of f

## Description

The function fpt tries to find the exact value for the F-pure threshold of a polynomial 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 ) 1 2 o3 = {-, -} 3 5 o3 : List```

If the option UseSpecialAlgorithms is set to true (the default value), then fpt first checks whether f is a diagonal polynomial, a binomial, or a form in two variables, respectively. If it is one of these, algorithms of D. Hernandez, or D. Hernandez and P. Teixeira, are executed to compute the F-pure threshold of f.

 ```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 : ZZ/5[x,y];` ```i7 : fpt( x^2*y^6*(x+y)^9*(x+3*y)^10 ) -- a binary form 5787 o7 = ----- 78125 o7 : QQ```

When no special algorithm is available or UseSpecialAlgorithms is set to false, fpt computes ν= νf(pe) (see nu), 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 [ν/(pe-1),(ν+1)/pe], 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 MaxChecks, which conservatively defaults to 3. If MaxChecks is set to 0, guessFPT is bypassed. If MaxChecks is set to at least 1, then a first check is run to verify whether the right-hand endpoint (ν+1)/pe of the above interval is the F-pure threshold.

 `i8 : f = x^2*(x+y)^3*(x+3*y^2)^5;` ```i9 : fpt( f, MaxChecks => 0 ) -- a bad estimate 1 o9 = {0, -} 5 o9 : List``` ```i10 : fpt( f, MaxChecks => 0, DepthOfSearch => 3 ) -- a better estimate 21 22 o10 = {---, ---} 124 125 o10 : List``` ```i11 : fpt( f, MaxChecks => 1, DepthOfSearch => 3 ) -- the right-hand endpoint (nu+1)/p^e is the fpt 22 o11 = --- 125 o11 : QQ```

If MaxChecks is set to at least 2 and the right-hand endpoint (ν+1)/pe is not the F-pure threshold, a second check is run to verify whether the left-hand endpoint ν/(pe-1) is the F-pure threshold.

 `i12 : f = x^6*y^4+x^4*y^9+(x^2+y^3)^3;` ```i13 : fpt( f, MaxChecks => 1, DepthOfSearch => 3 ) 17 7 o13 = {--, --} 62 25 o13 : List``` ```i14 : fpt( f, MaxChecks => 2, DepthOfSearch => 3 ) -- the left-hand endpoint is the fpt 17 o14 = -- 62 o14 : QQ```

If neither endpoint is the F-pure threshold, and MaxChecks is set to more than 2, additional checks are performed at numbers in the interval. A number in the interval with minimal denominator is selected, 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 MaxChecks.

 `i15 : f = x^3*y^11*(x+y)^8*(x^2+y^3)^8;` ```i16 : fpt( f, DepthOfSearch => 3, MaxChecks => 2 ) 3 7 o16 = {--, ---} 62 125 o16 : List``` ```i17 : fpt( f, DepthOfSearch => 3, MaxChecks => 3 ) -- an additional check sharpens the estimate 3 1 o17 = {--, --} 62 18 o17 : List``` ```i18 : fpt( f, DepthOfSearch => 3, MaxChecks => 4 ) -- and one more finds the exact answer 1 o18 = -- 19 o18 : QQ```

If guessFPT is unsuccessful and UseFSignature 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.

 `i19 : f = x^5*y^6*(x+y)^9*(x^2+y^3)^4;` ```i20 : fpt( f, DepthOfSearch => 3 ) 2 1 o20 = {--, --} 31 14 o20 : List``` ```i21 : fpt( f, DepthOfSearch => 3, UseFSignature => true ) 181 1 o21 = {----, --} 2750 14 o21 : List``` ```i22 : numeric ooo o22 = {.0645161, .0714286} o22 : List``` ```i23 : numeric ooo -- UseFSignature sharpened the estimate a bit o23 = {.0658182, .0714286} o23 : List```

When FRegularityCheck is set to true and no exact answer has been found, a final check is run (if necessary) to verify whether the final lower bound for the F-pure threshold is the exact answer.

 `i24 : f = (x+y)^4*(x^2+y^3)^6;` ```i25 : fpt( f, MaxChecks => 2, DepthOfSearch => 3 ) 3 13 o25 = {--, ---} 31 125 o25 : List``` ```i26 : fpt( f, MaxChecks => 2, DepthOfSearch => 3, UseFSignature => true ) -- using FSignatures the answer improves a bit 1 13 o26 = {--, ---} 10 125 o26 : List``` ```i27 : fpt( f, MaxChecks => 2, DepthOfSearch => 3, UseFSignature => true, FRegularityCheck => true ) -- FRegularityCheck finds the answer 1 o27 = -- 10 o27 : QQ```

The computations performed when UseFSignature and FRegularityCheck are set to true are often slow, and often fail to improve the estimate, and for this reason, these options should be used sparingly. It is often more effective to increase the values of MaxChecks or DepthOfSearch, instead.

 `i28 : f = x^7*y^5*(x+y)^5*(x^2+y^3)^4;` ```i29 : timing numeric fpt( f, DepthOfSearch => 3, UseFSignature => true, FRegularityCheck => true ) o29 = {.0733061, .0769231} -- 8.77073 seconds o29 : Time``` ```i30 : timing numeric fpt( f, MaxChecks => 5, DepthOfSearch => 3 ) -- a better answer in less time o30 = {.075, .0769231} -- 2.82508 seconds o30 : Time``` ```i31 : timing fpt( f, DepthOfSearch => 4 ) -- the exact answer in even less time 48 o31 = --- 625 -- 1.0455 seconds o31 : Time```

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; if the option Verbose is set to true, the precise interval will be printed.

 `i32 : f = x^7*y^5*(x+y)^5*(x^2+y^3)^4;` ```i33 : fpt( f, DepthOfSearch => 3, UseFSignature => true, Verbose => true ) Starting fpt ... fpt is not 1 ... Verifying if special algorithms apply... Special fpt algorithms were not used ... nu has been computed: nu = nu(3,f) = 9 ... fpt lies in the interval [ nu/(p^e-1), (nu+1)/p^e ] = [ 9/124, 2/25 ] ... Starting guessFPT ... The right-hand endpoint is not the fpt ... The left-hand endpoint is not the fpt ... guessFPT narrowed the interval down to ( 9/124, 1/13 ) ... Beginning F-signature computation ... First F-signature computed: s(f,(nu-1)/p^e) = 456/15625 ... Second F-signature computed: s(f,nu/p^e) = 64/15625 ... Computed F-signature secant line intercept: 449/6125 ... F-signature intercept is an improved lower bound ... fpt failed to find the exact answer; try increasing the value of DepthOfSearch or MaxChecks. fpt lies in the interval [ 449/6125, 1/13 ). 449 1 o33 = {----, --} 6125 13 o33 : List```

The computation of the F-pure threshold of a binary form f 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.

 `i34 : L = {x, y, x+y, x+3*y};` `i35 : m = {2, 6, 9, 10};` ```i36 : fpt(L, m) 5787 o36 = ----- 78125 o36 : QQ``` ```i37 : fpt( x^2*y^6*(x+y)^9*(x+3*y)^10 ) 5787 o37 = ----- 78125 o37 : QQ```