# icFracP -- compute the integral closure in prime characteristic

## Synopsis

• Usage:
icFracP R, icFracP(R, ConductorElement => D), icFracP(R, Limit => N), icFracP(R, Verbosity => ZZ)
• Inputs:
• R, that is reduced, equidimensional, finitely and separably generated over a field of characteristic p
• Optional inputs:
• ConductorElement => ..., default value null, optionally provide a non-zerodivisor conductor element ConductorElement => D; the output is then the module generators of the integral closure. A good choice of D may speed up the calculations?
• Limit => ..., default value infinity, if value N is given, perform N loop steps only
• Verbosity => ..., default value 0, if value is greater than 0, report the conductor element and number of steps in the loop
• Outputs:
• The module generators of the integral closure of R in its total ring of fractions. The generators are given as elements in the total ring of fractions.

## 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.

## Caveat

The interface to this algorithm will likely change eventually