# isFInjective -- whether a ring is F-injective

## Synopsis

• Usage:
isFInjective(R)
• Inputs:
• Optional inputs:
• FrobeniusRootStrategy => , default value Substitution, selects the strategy for internal frobeniusRoot calls
• AtOrigin => , default value false, stipulates whether to check $F$-injectivity only at the origin
• AssumeCM => , default value false, assumes the ring is Cohen-Macaulay
• AssumeNormal => , default value false, assumes the ring is normal
• AssumeReduced => , default value true, assumes the ring is reduced
• CanonicalStrategy => , default value Katzman, specifies what strategy to use when computing the Frobenius action on top local cohomology
• Outputs:

## Description

This function determines whether a ring of finite type over a finite prime field is $F$-injective. Over a more general field, it checks the $F$-injectivity of the relative Frobenius. We begin with an example of an $F$-injective ring that is not $F$-pure (taken from the work of Anurag Singh on deformation of $F$-regularity).

 i1 : S = ZZ/3[a,b,c,d,t]; i2 : M = matrix{{a^2 + t^4, b, d}, {c, a^2, b^3-d}}; 2 3 o2 : Matrix S <--- S i3 : I = minors(2, M); o3 : Ideal of S i4 : R = S/I; i5 : isFInjective(R) o5 = true i6 : isFPure(R) o6 = false

Next, let us form the cone over $\mathbb{P}^1 \times E$, where $E$ is an elliptic curve. We begin with a supersingular elliptic curve. This should be $F$-injective if and only if it is $F$-pure.

 i7 : S = ZZ/3[xs, ys, zs, xt, yt, zt]; i8 : EP1 = ZZ/3[x,y,z,s,t]/(x^3 + y^2*z - x*z^2); --supersingular elliptic curve i9 : f = map(EP1, S, {x*s, y*s, z*s, x*t, y*t, z*t}); o9 : RingMap EP1 <--- S i10 : R = S/(ker f); i11 : isFInjective(R) o11 = false i12 : isFPure(R) o12 = false

Now we do a similar computation, this time with an ordinary elliptic curve.

 i13 : S = ZZ/3[xs, ys, zs, xt, yt, zt]; i14 : EP1 = ZZ/3[x,y,z,s,t]/(y^2*z - x^3 + x*y*z); --ordinary elliptic curve i15 : f = map(EP1, S, {x*s, y*s, z*s, x*t, y*t, z*t}); o15 : RingMap EP1 <--- S i16 : R = S/(ker f); i17 : isFInjective(R) o17 = true i18 : isFPure(R) o18 = true

If CanonicalStrategy is set to Katzman (its default behavior), then the Frobenius action on the top local cohomology (bottom Ext) is computed via the method of Katzman. If it is set to anything else, it is simply brute forced in Macaulay2 using the functoriality of Ext. The Katzman strategy is typically much faster.

 i19 : R = ZZ/5[x,y,z]/(y^2*z + x*y*z-x^3) o19 = R o19 : QuotientRing i20 : time isFInjective(R) -- used 0.087885 seconds o20 = true i21 : time isFInjective(R, CanonicalStrategy => null) -- used 1.88501 seconds o21 = true

If the option AtOrigin (default value false) is set to true, isFInjective will only check $F$-injectivity at the origin. Otherwise, it will check $F$-injectivity globally. Note that checking $F$-injectivity at the origin can be slower than checking it globally. Consider the following example of a non-$F$-injective ring.

 i22 : R = ZZ/7[x,y,z]/((x-1)^5 + (y+1)^5 + z^5); i23 : time isFInjective(R) -- used 0.131481 seconds o23 = false i24 : time isFInjective(R, AtOrigin => true) -- used 0.168063 seconds o24 = true

If the option AssumeCM (default value false) is set to true, then isFInjective only checks the Frobenius action on top cohomology (which is typically much faster). Note that it can give an incorrect answer if the non-injective Frobenius occurs in a lower degree. Consider the example of the cone over a supersingular elliptic curve times $\mathbb{P}^1$.

 i25 : S = ZZ/3[xs, ys, zs, xt, yt, zt]; i26 : EP1 = ZZ/3[x,y,z,s,t]/(x^3 + y^2*z - x*z^2); i27 : f = map(EP1, S, {x*s, y*s, z*s, x*t, y*t, z*t}); o27 : RingMap EP1 <--- S i28 : R = S/(ker f); i29 : time isFInjective(R) -- used 1.21214 seconds o29 = false i30 : time isFInjective(R, AssumeCM => true) -- used 0.400845 seconds o30 = true

If the option AssumedReduced is set to true (its default behavior), then the bottom local cohomology is avoided (this means the Frobenius action on the top potentially nonzero Ext is not computed).

If the option AssumeNormal (default value false) is set to true, then the bottom two local cohomology modules (or, rather, their duals) need not be computed.

The value of the option FrobeniusRootStrategy is passed to internal frobeniusRoot calls.