# integralClosure(Ring) -- compute the integral closure (normalization) of an affine domain

## Synopsis

• Usage:
R' = integralClosure R
• Function: integralClosure
• Inputs:
• R, a ring, a quotient of a polynomial ring over a field
• Optional inputs:
• Keep => ..., -- list ring generators which should not be simplified away
• Limit => ..., -- do a partial integral closure
• Strategy => ..., -- control the algorithm used
• Variable => ..., -- set the base letter for the indexed variables introduced while computing the integral closure
• Verbosity => ..., -- display a certain amount of detail about the computation
• Outputs:
• R', a ring, the integral closure of R
• Consequences:
• The inclusion map R →R’ can be obtained with icMap.
• The fractions corresponding to the variables of the ring R’ can be found with icFractions

## Description

The integral closure of a domain is the subring of the fraction field consisting of all fractions integral over the domain. For example,
 `i1 : R = QQ[x,y,z]/ideal(x^6-z^6-y^2*z^4-z^3);` ```i2 : R' = integralClosure R o2 = R' o2 : QuotientRing``` ```i3 : gens R' o3 = {w , x, y, z} 3,0 o3 : List``` ```i4 : icFractions R 2 x o4 = {--, x, y, z} z o4 : List``` ```i5 : icMap R o5 = map(R',R,{x, y, z}) o5 : RingMap R' <--- R``` ```i6 : I = trim ideal R' 2 3 2 3 o6 = ideal (w z - x , w - y z - z - 1) 3,0 3,0 o6 : Ideal of QQ[w , x, y, z] 3,0```
Sometimes using trim provides a cleaner set of generators.

If R is not a domain, first decompose it, and collect all of the integral closures.
 `i7 : S = ZZ/101[a..d]/ideal(a*(b-c),c*(b-d),b*(c-d));` ```i8 : C = decompose ideal S o8 = {ideal (b - c, - c + d), ideal (b, d, a), ideal (c, b), ideal (c, d, a)} o8 : List``` `i9 : Rs = apply(C, I -> (ring I)/I);` ```i10 : Rs/integralClosure ZZ ZZ ZZ ZZ ---[a, b, c, d] ---[a, b, c, d] ---[a, b, c, d] ---[a, b, c, d] 101 101 101 101 o10 = {----------------, ---------------, ---------------, ---------------} (b - c, - c + d) (b, d, a) (c, b) (c, d, a) o10 : List``` ```i11 : oo/prune ZZ ZZ ZZ ZZ o11 = {---[a, d], ---[c], ---[a, d], ---[b]} 101 101 101 101 o11 : List```
This function is roughly based on Theo De Jong’s paper, An Algorithm for Computing the Integral Closure, J. Symbolic Computation, (1998) 26, 273-277. This algorithm is similar to the round two algorithm of Zassenhaus in algebraic number theory.
There are several optional parameters which allows the user to control the way the integral closure is computed. These options may change in the future.

## Caveat

This function requires that the degree of the field extension (over a pure transcendental subfield) be greater than the characteristic of the base field. If not, use icFracP. This function requires that the ring be finitely generated over a ring. If not (e.g. if it is f.g. over the integers), then the result is integral, but not necessarily the entire integral closure. Finally, if the ring is not a domain, then the answers will often be incorrect, or an obscure error will occur.