Macaulay2 » Documentation
Packages » IntegralClosure :: integralClosure(Ring,Ring)
next | previous | forward | backward | up | index | toc

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

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

## See also

- integralClosure(Ring) -- compute the integral closure (normalization) of an affine domain
- icMap -- natural map from an affine domain into its integral closure
- icFractions -- fractions integral over an affine domain

## Ways to use this method:

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

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