next | previous | forward | backward | up | top | index | toc | Macaulay2 web site
IntegralClosure :: icFracP

icFracP -- compute the integral closure in prime characteristic



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

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)

o4 = {1, ---}

o4 : List
i5 : icFracP(R, ConductorElement => x)

o5 = {1, ---}

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, -----------}

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)

       1  u*x
o10 = {-, ----}
       y   v*y

o10 : List
i11 : icFracP(R, Limit => 2)

             3      3
          u*y  + v*z
o11 = {1, -----------}

o11 : List
i12 : icFracP(R)

             3      3
          u*y  + v*z
o12 = {1, -----------}

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, -----------}

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


The interface to this algorithm will likely change in Macaulay2 1.4

See also

Ways to use icFracP :