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

- The module generators of the integral closure of

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.

The user may provide an optional non-zerodivisor conductor element `D`. The output generators need not be expressed in the form with denominator `D`.

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

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

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.

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

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 |

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 |

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 |

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 |

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 |

The interface to this algorithm will likely change in Macaulay2 1.4

- icPIdeal -- compute the integral closure in prime characteristic of a principal ideal
- integralClosure -- integral closure of an ideal or a domain
- isNormal -- determine if a reduced ring is normal

- icFracP(Ring)