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

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



Consider a field k of characteristic p>0, and an ideal J in the polynomial ring S = k[x1, ..., xd]. If f is a polynomial contained in the radical of J, then the command nu(e, f, J) outputs the maximal exponent n such that fn 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 Mustata, Takagi, and Watanabe.

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

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

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

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

o6 = 10

When the ideal J is omitted from the argument, it is assumed to be the homogeneous maximal ideal.

i7 : S=ZZ/17[x,y,z];
i8 : f=x^3+y^4+z^5;
i9 : J=ideal(x,y,z);

o9 : Ideal of S
i10 : nu(2,f)

o10 = 220

o10 : QQ
i11 : nu(2,f,J)

o11 = 220

o11 : QQ

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 explicitly bounded from above in terms of p, and the number of generators of I and J (e.g., it is at most p-1 when I is principal). This relation implies that when searching for nu(e+1,I,J), it is always safe to start at p times nu(e,I,J), and one needn’t search too far past this number.

The option ComputePreviousNus, whose default value is true, exploits this observation, and computes nu(d,I,J) for d = 0, …, e-1 to aid in the computation of nu(e,I,J). It usually leads to faster computations.

i12 : S=ZZ/79[x,y];
i13 : f=x^5+x^4*y+x^3*y^2+x^2*y^3+x*y^4+y^5; -- a homogeneous polynomial of degree 5 in x,y
i14 : time nu(10,f)
     -- used 10.5819 seconds

o14 = 3787310433050738880
i15 : time nu(10,f, ComputePreviousNus=>false)
     -- used 20.7752 seconds

o15 = 3787310433050738880

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 that occur 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 lies in the pe-th Frobenius power of J.

Alternately, if ContainmentTest is set to FrobeniusRoot, then the ideal containments that occur when computing nu(e,I,J) 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 lies in J. The output is unaffected, but this option often speeds up computations.

i16 : ZZ/11[x,y,z];
i17 : f=x^3+y^3+z^3+x*y*z;
i18 : time nu(3,f) -- ContainmentTest is set to frobeniusRoot, by default
     -- used 0.430068 seconds

o18 = 1209
i19 : time nu(3,f,ContainmentTest=>StandardPower)
     -- used 37.1526 seconds

o19 = 1209

Finally, when ContainmentTest is set to FrobeniusPower, then instead of producing the invariant νIJ(pe) as defined above, nu(e,I,J, ContainmentTest=>FrobeniusPower) instead outputs the maximal integer n such that the n-th Frobenius power of I is not contained in the pe-th Frobenius power of J. Here, the n-th Frobenius power of I, when n is a nonnegative integer, is as defined in the paper "Frobenius Powers" by Hernandez, Teixeira, and Witt. In particular, nu(e,I,J) and nu(e,I,J, ContainmentTest => FrobeniusPower) need not agree! However, they will when I is a principal ideal. We note that the output of nu(e,I,J, ContainmentTest => FrobeniusPower) is the same as that of mu(e,I,J).

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

o21 : Ideal of --[x, y]
i22 : nu(3,M^5)

o22 = 10
i23 : nu(3,M^5,ContainmentTest=>FrobeniusPower)

o23 = 8
i24 : mu(3,M^5) -- should produce the same output as preceding command

o24 = 8

The function nu works by searching through list of integers n and checking containments of In in a specified Frobenius power of J. The option Search specifies the search algorithm used to do so search for the exponent n among a list of possibilities. Valid values for Search are Binary, the default value, BinaryRecursive, and Linear.

i25 : ZZ/17[x,y];
i26 : M=ideal(x,y);

o26 : Ideal of --[x, y]
i27 : time nu(2,M,M^2,Search=>Binary)
     -- used 4.84581 seconds

o27 = 865
i28 : time nu(2,M,M^2,Search=>BinaryRecursive)
     -- used 3.79014 seconds

o28 = 865
i29 : time nu(2,M,M^2,Search=>Linear)
     -- used 7.93007 seconds

o29 = 865

The option UseColonIdeals specifies whether or not nu uses colon ideals to compute ν in an iterative way.

i30 : ZZ/5[x,y,z];
i31 : f = 2*x^2*y^3*z^8+2*x^4*z^9+2*x*y^7*z^4;
i32 : time nu( 5, f ) --Use ColonIdeals is set to false, by default
     -- used 0.687808 seconds

o32 = 593
i33 : time nu( 5, f, UseColonIdeals => true )
     -- used 0.318047 seconds

o33 = 593

See also

Ways to use nu :