Macaulay2 » Documentation
Packages » IntegralClosure :: icFracP
next | previous | forward | backward | up | index | toc

# icFracP -- compute the integral closure in prime characteristic

- 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

## See also

- icPIdeal -- compute the integral closure in prime characteristic of a principal ideal
- integralClosure -- integral closure of an ideal or a domain
- isNormal(Ring)

## Ways to use icFracP:

- `icFracP(Ring)`

## For the programmer

The object icFracP is a method function with options.

The source of this document is in /build/macaulay2-88fgJW/macaulay2-1.25.11+ds/M2/Macaulay2/packages/IntegralClosure.m2:2179:0.