integralClosure(Ring,Ring) -- compute the integral closure (normalization) of an affine reduced ring over a base ring

Synopsis

Function: integralClosure
Usage:

R' = integralClosure(R, A)
Inputs:
- R, a ring, a quotient of a polynomial ring ultimately over a field
- A, a ring, a base ring of $R$ (one of its coefficient rings)
Optional inputs:
- Keep => a list, default value null, of variables of R
- Limit => an integer, default value infinity, do a partial integral closure
- Variable => a symbol, default value "w", set the base letter for the indexed variables introduced while computing the integral closure
- Verbosity => an integer, default value 0, display a certain amount of detail about the computation
- Strategy => a list, default value {}, of some of the symbols: AllCodimensions, Radical, RadicalCodim1, Vasconcelos, StartWithOneminor, SimplifyFractions
Outputs:
- R', a ring, the integral closure of $R$, having coefficient ring $A$
Consequences:
- The inclusion map $R \rightarrow R'$ can be obtained with icMap.
- The fractions corresponding to the variables of the ring R' can be found with icFractions

Description

This function packages the output integral closure in the desired way. For more details about integral closure, see integralClosure(Ring).

In the following example, there are three possible coefficient rings for $R$: $R$, $A$ and ${\mathbb Q}$.

i1 : A = QQ[x,y]/(x^3-y^2)

o1 = A

o1 : QuotientRing

i2 : R = reesAlgebra(ideal(x*y,y^2), Variable => z)

o2 = R

o2 : QuotientRing

i3 : coefficientRing R

o3 = A

o3 : QuotientRing

i4 : describe R

                   A[z ..z ]
                      0   1
o4 = -------------------------------------
                           2     2      2
     (x*z  - y*z , y*z  - x z , z  - x*z )
         0      1     0      1   0      1

i5 : R' = integralClosure(R, R)

o5 = R'

o5 : QuotientRing

i6 : describe R'

                                 R[w   ]
                                    0,0
o6 = ---------------------------------------------------------------
                2               2
     (y*w    - x , x*w    - y, w    - x, z w    - z , z w    - x*z )
         0,0          0,0       0,0       1 0,0    0   0 0,0      1

i7 : icMap R

o7 = map (R', R, {z , z , x, y})
                   0   1

o7 : RingMap R' <-- R

i8 : fracs1 = icFractions R

      z
       0
o8 = {--, z , z , x, y}
      z    0   1
       1

o8 : List

i9 : R'' = integralClosure(R, A)

o9 = R''

o9 : QuotientRing

i10 : describe R''

                                     A[w   , z ..z ]
                                        0,0   0   1
o10 = ----------------------------------------------------------------------------
                              2                                           2
      (x*z  - y*z , y*w    - x , x*w    - y, w   z  - z , w   z  - x*z , w    - x)
          0      1     0,0          0,0       0,0 1    0   0,0 0      1   0,0

i11 : icMap R

o11 = map (R'', R, {z , z , x, y})
                     0   1

o11 : RingMap R'' <-- R

i12 : fracs2 = icFractions R

       z
        0
o12 = {--, z , z , x, y}
       z    0   1
        1

o12 : List

i13 : assert(fracs1 == fracs2)

i14 : R''' = integralClosure(R, QQ)

o14 = R'''

o14 : QuotientRing

i15 : describe R'''

                               QQ[w   , z ..z , x..y]
                                   0,0   0   1
o15 = -----------------------------------------------------------------------
        2                                                            2
      (x  - w   y, z x - z y, w   x - y, w   z  - z , w   z  - z x, w    - x)
             0,0    0     1    0,0        0,0 1    0   0,0 0    1    0,0

i16 : icMap R

o16 = map (R''', R, {z , z , x, y})
                      0   1

o16 : RingMap R''' <-- R

i17 : fracs3 = icFractions R

       z
        0
o17 = {--, z , z , x, y}
       z    0   1
        1

o17 : List

i18 : assert(fracs1 == fracs3)

Note that the second and third calls to integralClosure changes the output of icMap but the fractions are the same.

Caveat

All the caveats of integralClosure(Ring) are in effect and the output of icMap changes upon each call to this function.

Ways to use this method: