next | previous | forward | backward | up | top | index | toc | Macaulay2 website
FrobeniusThresholds :: fpt

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

Synopsis

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

See also

Ways to use fpt :

For the programmer

The object fpt is a method function with options.