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

## Synopsis

• Usage:
nu(e,I,J)
nu(e,I)
nu(e,f,J)
nu(e,f)
• Inputs:
• Optional inputs:
• ComputePreviousNus => , default value true, specifies whether to compute nu(d,I,J) for d = 0, …, e-1 to aid in the computation of nu(e,I,J)
• ContainmentTest => , default value null, specifies the manner in which to verify the containment of a power of I in some specified Frobenius power of J
• Search => , default value Binary, specifies the strategy in which to search for the largest integer n such that In is not contained in some specified Frobenius power of J.
• UseColonIdeals => , default value false, specifies whether to use colon ideals in a recursive manner when computing nu(e,I,J)
• UseSpecialAlgorithms => ... (missing documentation),
• Outputs:
• an integer, the nu-invarants whose normalized limits compute the F-pure threshold, and more generally, F-thresholds.

## Description

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); ZZ o21 : Ideal of --[x, y] 3``` ```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); ZZ o26 : Ideal of --[x, y] 17``` ```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```