next | previous | forward | backward | up | top | index | toc | Macaulay2 web site
FThresholds :: fpt

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

Synopsis

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

See also

Ways to use fpt :