FThresholds :: nu

- Usage:
`nu(e,I,J)``nu(e,I)``nu(e,f,J)``nu(e,f)`

- Inputs:
`e`, an integer`I`, an ideal`J`, an ideal`f`, a ring element

- Optional inputs:
`ComputePreviousNus =>`a Boolean value, 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 =>`a symbol, 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 =>`a symbol, default value Binary, specifies the strategy in which to search for the largest integer*n*such that*I*is not contained in some specified Frobenius power of^{n}*J*.`UseColonIdeals =>`a Boolean value, 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.

- an integer, the

Consider a field *k* of characteristic *p>0*, and an ideal *J* in the polynomial ring *S = k[x _{1}, ..., x_{d}]*. If

These numbers are denoted *ν _{f}^{J}(p^{e})* and

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=p ^{e}* for some nonnegative integer

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 *I ^{n}* is first computed, and a check is then run to see if it lies in the

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 *p ^{e}*-th Frobenius root of

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 *ν _{I}^{J}(p^{e})* as defined above,

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 *I ^{n}* in a specified Frobenius power of

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 |

- nu(ZZ,Ideal)
- nu(ZZ,Ideal,Ideal)
- nu(ZZ,RingElement)
- nu(ZZ,RingElement,Ideal)