next | previous | forward | backward | up | top | index | toc | Macaulay2 web site
FrobeniusThresholds :: nu

nu -- computes the largest power of an ideal not contained in a specified Frobenius power

Synopsis

Description

Consider an element f of a polynomial ring R over a finite field of characteristic p, and an ideal J of this ring. If f is contained in the radical of J, then the command nu(e,f,J) outputs the maximal exponent n such that f n is not contained in the pe-th Frobenius power of J. More generally, if I is an ideal contained in the radical of J, then nu(e,I,J) outputs the maximal integer exponent n such that In is not contained in the pe-th Frobenius power of J.

These numbers are denoted νfJ(pe) and νIJ(pe), respectively, in the literature, and were originally defined in the paper F-thresholds and Bernstein-Sato Polynomials, by Mustaţă, Takagi, and Watanabe.

i1 : R = ZZ/11[x,y];
i2 : I = ideal(x^2 + y^3, x*y);

o2 : Ideal of R
i3 : J = ideal(x^2, y^3);

o3 : Ideal of R
i4 : nu(1, I, J)

o4 = 24
i5 : f = x*y*(x^2 + y^2);
i6 : nu(3, f, J)

o6 = 1330

If f or I is zero, then nu returns 0; if f or I is not contained in the radical of J, nu returns infinity.

i7 : nu(1, 0_R, J)

o7 = 0
i8 : nu(1, 1_R, J)

o8 = infinity

o8 : InfiniteNumber

When the third argument is omitted, the ideal J is assumed to be the homogeneous maximal ideal of R.

i9 : R = ZZ/17[x,y,z];
i10 : f = x^3 + y^4 + z^5;
i11 : nu(2, f)

o11 = 220
i12 : nu(2, f, ideal(x, y, z))

o12 = 220

It is well known that if q=pe for some nonnegative integer e, then νIJ(qp) = νIJ(q) p + L, 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 (e.g., L is at most p-1 when I is principal). This implies that when searching for nu(e,I,J), it is always safe to start at p times nu(e-1,I,J), and one need not search too far past this number, and suggests that the most efficient way to compute nu(e,I,J) is to compute, successively, nu(i,I,J), for i = 0,...,e. This is indeed how the computation is done in most cases.

If M is the homogeneous maximal ideal of R and f is an element of R, the numbers νfM(pe) determine and are determined by the F-pure threshold of f at the origin. Indeed, νfM(pe) is pe times the truncation of the non-terminating base p expansion of fpt(f) at its eth spot. This fact is used to speed up the computations for certain polynomials whose F-pure thresholds can be quickly computed via special algorithms, namely diagonal polynomials, binomials, forms in two variables, and polynomials whose factors are in simple normal crossing. This feature can be disabled by setting the option UseSpecialAlgorithms (default value true) to false.

i13 : R = ZZ/17[x,y,z];
i14 : f = x^3 + y^4 + z^5; -- a diagonal polynomial
i15 : time nu(3, f)
     -- used 0.00462332 seconds

o15 = 3756
i16 : time nu(3, f, UseSpecialAlgorithms => false)
     -- used 0.237601 seconds

o16 = 3756

The valid values for the option ContainmentTest are FrobeniusPower, FrobeniusRoot, and StandardPower. The default value of this option depends on what is passed to nu. Indeed, by default, ContainmentTest is set to FrobeniusRoot if nu is passed a ring element f, and is set to StandardPower if nu is passed an ideal I. We describe the consequences of setting ContainmentTest to each of these values below.

First, if ContainmentTest is set to StandardPower, then the ideal containments checked when computing nu(e,I,J) are verified directly. That is, the standard power In is first computed, and a check is then run to see if it is contained in the pe-th Frobenius power of J.

Alternately, if ContainmentTest is set to FrobeniusRoot, then the ideal containments are verified using Frobenius Roots. That is, the pe-th Frobenius root of In is first computed, and a check is then run to see if it is contained in J. The output is unaffected, but this option often speeds up computations, specially when a polynomial or principal ideal is passed as the second argument.

i17 : R = ZZ/5[x,y,z];
i18 : f = x^3 + y^3 + z^3 + x*y*z;
i19 : time nu(4, f) -- ContainmentTest is set to FrobeniusRoot, by default
     -- used 0.161865 seconds

o19 = 499
i20 : time nu(4, f, ContainmentTest => StandardPower)
     -- used 2.49917 seconds

o20 = 499

Finally, when ContainmentTest is set to FrobeniusPower, then instead of producing the invariant νIJ(pe) as defined above, nu instead outputs the maximal integer n such that the nth (generalized) Frobenius power of I is not contained in the pe-th Frobenius power of J. Here, the nth Frobenius power of I, when n is a nonnegative integer, is as defined in the paper Frobenius Powers by Hernández, Teixeira, and Witt, which can be computed with the function frobeniusPower, from the TestIdeals package. In particular, nu(e,I,J) and nu(e,I,J,ContainmentTest=>FrobeniusPower) need not agree. However, they will agree when I is a principal ideal.

i21 : R = ZZ/3[x,y];
i22 : M = ideal(x, y);

o22 : Ideal of R
i23 : nu(3, M^5)

o23 = 10
i24 : nu(3, M^5, ContainmentTest => FrobeniusPower)

o24 = 8

The function nu works by searching through the list of potential integers n and checking containments of In in the specified Frobenius power of J. The way this search is approached is specified by the option Search, which can be set to Binary (the default value) or Linear.

i25 : R = ZZ/5[x,y,z];
i26 : f = x^2*y^4 + y^2*z^7 + z^2*x^8;
i27 : time nu(5, f) -- uses binary search (default)
     -- used 0.491585 seconds

o27 = 1124
i28 : time nu(5, f, Search => Linear)
     -- used 0.723921 seconds

o28 = 1124
i29 : M = ideal(x, y, z);

o29 : Ideal of R
i30 : time nu(2, M, M^2) -- uses binary search (default)
     -- used 2.6922 seconds

o30 = 97
i31 : time nu(2, M, M^2, Search => Linear) -- but linear search gets luckier
     -- used 0.891344 seconds

o31 = 97

The option AtOrigin (default value true) can be turned off to tell nu to effectively do the computation over all possible maximal ideals J and take the minimum.

i32 : R = ZZ/7[x,y];
i33 : f = (x - 1)^3 - (y - 2)^2;
i34 : nu(1, f)

o34 = infinity

o34 : InfiniteNumber
i35 : nu(1, f, AtOrigin => false)

o35 = 5

The option ReturnList (default value false) can be used to request that the output be not only νIJ(pe), but a list containing νIJ(pi), for i=0,...,e.

i36 : R = ZZ/5[x,y,z];
i37 : f = x^2*y^4 + y^2*z^7 + z^2*x^8;
i38 : nu(5, f, ReturnList => true)

o38 = {0, 1, 8, 44, 224, 1124}

o38 : List

Alternatively, the option Verbose (default value false) can be used to request that the values νIJ(pi) (i=0,...,e) be printed as they are computed, to monitor the progress of the computation.

i39 : nu(5, f, Verbose => true)

nuInternal: using comparison test FrobeniusRoot

ν(1) = 0
ν(p^1) = 1
ν(p^2) = 8
ν(p^3) = 44
ν(p^4) = 224
ν(p^5) = 1124

o39 = 1124

See also

Ways to use nu :