isFRegular -- whether a ring or pair is strongly F-regular

Synopsis

Usage:

isFRegular(R)

isFRegular(t, f)

isFRegular(tList, fList)
Inputs:
- R, a ring,
- t, a rational number, a formal exponent for f
- f, a ring element, the element for the pair, to test $F$-regularity
- tList, a list, a list of formal exponents, for the elements of fList
- fList, a list, a list of elements for a pair, to test $F$-regularity
Optional inputs:
- AssumeDomain => a Boolean value, default value false, assumes the ring is an integral domain
- FrobeniusRootStrategy => a symbol, default value Substitution, selects the strategy for internal frobeniusRoot calls
- MaxCartierIndex => an integer, default value 10, sets the maximum Gorenstein index to search for when working with a $\mathbb{Q}$-Gorenstein ambient ring
- QGorensteinIndex => an integer, default value 0, specifies the $\mathbb{Q}$-Gorenstein index of the ring
- AtOrigin => a Boolean value, default value false, specifies whether to check $F$-regularity just at the origin
- DepthOfSearch => an integer, default value 2, specifies how hard to try to prove that a non-$\mathbb{Q}$-Gorenstein ring is $F$-regular
Outputs:
- a Boolean value,

Description

Given a normal $\mathbb{Q}$-Gorenstein ring $R$, the function isFRegular checks whether the ring is strongly $F$-regular. It can also prove that a non-$\mathbb{Q}$-Gorenstein ring is $F$-regular (but cannot show it is not); see below for how to access this functionality.

i1 : R = ZZ/5[x,y,z]/(x^2 + y*z);

i2 : isFRegular(R)

o2 = true

i3 : R = ZZ/7[x,y,z]/(x^3 + y^3 + z^3);

i4 : isFRegular(R)

o4 = false

The function isFRegular can also test strong $F$-regularity of pairs.

i5 : R = ZZ/5[x,y];

i6 : f = y^2 - x^3;

i7 : isFRegular(1/2, f)

o7 = true

i8 : isFRegular(5/6, f)

o8 = false

i9 : isFRegular(4/5, f)

o9 = false

i10 : isFRegular(4/5 - 1/100000, f)

o10 = true

When checking whether a ring or pair is strongly $F$-regular, the option AtOrigin determines if this is to be checked at the origin or everywhere. The default value for AtOrigin is false, which corresponds to checking $F$-regularity everywhere; setting AtOrigin => true, $F$-regularity is checked only at the origin.

i11 : R = ZZ/7[x,y,z]/((x - 1)^3 + (y + 1)^3 + z^3);

i12 : isFRegular(R)

o12 = false

i13 : isFRegular(R, AtOrigin => true)

o13 = true

i14 : S = ZZ/13[x,y,z]/(x^3 + y^3 + z^3);

i15 : isFRegular(S)

o15 = false

i16 : isFRegular(S, AtOrigin => true)

o16 = false

Here is an example of AtOrigin behavior with a pair.

i17 : R = ZZ/13[x,y];

i18 : f = (y - 2)^2 - (x - 3)^3;

i19 : isFRegular(5/6, f)

o19 = false

i20 : isFRegular(5/6, f, AtOrigin => true)

o20 = true

i21 : g = y^2 - x^3;

i22 : isFRegular(5/6, g)

o22 = false

i23 : isFRegular(5/6, g, AtOrigin => true)

o23 = false

The option AssumeDomain (default value false) is used when finding a test element. The option FrobeniusRootStrategy (default value Substitution) is passed to internal frobeniusRoot calls.

When working in a $\mathbb{Q}$-Gorenstein ring $R$, isFRegular looks for a positive integer $N$ such that $N K_R$ is Cartier. The option MaxCartierIndex (default value $10$) controls the maximum value of $N$ to consider in this search. If the smallest such $N$ turns out to be greater than the value passed to MaxCartierIndex, then testIdeal returns an error.

The $\mathbb{Q}$-Gorenstein index can be specified by the user through the option QGorensteinIndex; when this option is used, the search for $N$ is bypassed, and the option MaxCartierIndex ignored.

The function isFRegular can show that rings that are not $\mathbb{Q}$-Gorenstein are $F$-regular (it cannot, however, show that such a ring is not $F$-regular). To do this, set the option QGorensteinIndex => infinity. One may also use the option DepthOfSearch to increase the depth of search.

i24 : S = ZZ/7[x,y,z,u,v,w];

i25 : I = minors(2, matrix {{x, y, z}, {u, v, w}});

o25 : Ideal of S

i26 : debugLevel = 1;

i27 : time isFRegular(S/I, QGorensteinIndex => infinity, DepthOfSearch => 1)
isFRegular: This ring does not appear to be F-regular.  Increasing DepthOfSearch will let the function search more deeply.
     -- used 0.0330843 seconds

o27 = false

i28 : time isFRegular(S/I, QGorensteinIndex => infinity, DepthOfSearch => 2)
     -- used 0.134289 seconds

o28 = true

i29 : debugLevel = 0;

Ways to use isFRegular :

isFRegular(List,List)
isFRegular(Number,RingElement)
isFRegular(Ring)

For the programmer

The object isFRegular is a method function with options.

isFRegular -- whether a ring or pair is strongly F-regular

Synopsis

Description

See also

Ways to use isFRegular :

For the programmer