Description
Input is an equidimensional reduced ring in characteristic p that is finitely and separably generated over the base field. The output is a finite set of fractions that generate the integral closure as an
Rmodule. An intermediate step in the code is the computation of a conductor element
D that is a nonzerodivisor; its existence is guaranteed by the separability assumption. The user may supply
D with the optional
ConductorElement => D. (Sometimes, but not always, supplying
D speeds up the computation.) In any case, with the nonzero divisor
D, the algorithm starts by setting the initial approximation of the integral closure to be the finitely generated
Rmodule
(1/D)R, and in the subsequent loop the code recursively constructs submodules. Eventually two submodules repeat; the repeated module is the integral closure of
R. The user may optionally provide
Limit => N to stop the loop after
N steps, and the optional
Verbosity => 1 reports the conductor element and the number of steps it took for the loop to stabilize. The algorithm is based on the LeonardPellikaanSinghSwanson algorithm.
A simple example.
i1 : R = ZZ/5[x,y,z]/ideal(x^6z^6y^2*z^4);

i2 : icFracP R
2 3 2 3
x x y z + z
o2 = {1, , , }
z 2 x
z
o2 : List

The user may provide an optional nonzerodivisor conductor element
D. The output generators need not be expressed in the form with denominator
D.
i3 : R = ZZ/5[x,y,u,v]/ideal(x^2*uy^2*v);

i4 : icFracP(R)
x*u
o4 = {1, }
y
o4 : List

i5 : icFracP(R, ConductorElement => x)
x*u
o5 = {1, }
y
o5 : List

In case
D is not in the conductor, the output is
V_e = (1/D) {r in R  r^(p^i) in (D^(p^i1)) for
i = 1, ..., e} such that
V_e = V_(e+1) and
e is the smallest such
e.
i6 : R=ZZ/2[u,v,w,x,y,z]/ideal(u^2*x^3+u*v*y^3+v^2*z^3);

i7 : icFracP(R)
3 3
u*y + v*z
o7 = {1, }
u
o7 : List

i8 : icFracP(R, ConductorElement => x^2)
o8 = {1}
o8 : List

The user may also supply an optional limit on the number of steps in the algorithm. In this case, the output is a finitely generated
Rmodule contained in
(1/D)R which contains the integral closure (intersected with
(1/D)R.
i9 : R=ZZ/2[u,v,w,x,y,z]/ideal(u^2*x^3+u*v*y^3+v^2*z^3);

i10 : icFracP(R, Limit => 1)
2
1 u*x
o10 = {, }
y v*y
o10 : List

i11 : icFracP(R, Limit => 2)
3 3
u*y + v*z
o11 = {1, }
u
o11 : List

i12 : icFracP(R)
3 3
u*y + v*z
o12 = {1, }
u
o12 : List

With the option above one can for example determine how many intermediate modules the program should compute or did compute in the loop to get the integral closure. A shortcut for finding the number of steps performed is to supply the
Verbosity => 1 option.
i13 : R=ZZ/3[u,v,w,x,y,z]/ideal(u^2*x^4+u*v*y^4+v^2*z^4);

i14 : icFracP(R, Verbosity => 1)
Number of steps: 4, Conductor Element: u*x^4v*y^4
4 4
u*y  v*z
o14 = {1, }
u
o14 : List

With this extra bit of information, the user can now compute integral closures of principal ideals in
R via
icPIdeal.