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
R-module. An intermediate step in the code is the computation of a conductor element
D that is a non-zerodivisor; 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 non-zero divisor
D, the algorithm starts by setting the initial approximation of the integral closure to be the finitely generated
R-module
(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 Leonard--Pellikaan--Singh--Swanson algorithm.
A simple example.
i1 : R = ZZ/5[x,y,z]/ideal(x^6-z^6-y^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 non-zerodivisor 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*u-y^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^i-1)) 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
R-module 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^4-v*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.