This is Seminormalization.info, produced by Macaulay2, version 1.22

Seminormalization -- a package used to seminormalize rings
**********************************************************

Description
===========

Seminormalization is a package which can be used to seminormalize rings or more
generally check if a ring is seminormal.  Roughly speaking a ring is non-normal
if in the Spec, points are identified and tangent spaces killed.  Seminormal
rings are those where only points are identified.  See the following for more
discussion: MathOverflow question (see
https://mathoverflow.net/questions/109395/is-there-a-geometric-intuition-
underlying-the-notion-of-normal-varieties/ )

Core functions
  * seminormalize, computes the seminormalization of a
    ring
  * isSeminormal, checks if a ring is seminormal
To accomplish this, this we first normalize the ring via integralClosure (IntegralClosure),
and then glue points together via the
Pullback, package.  There are some other functions exported
which people may also find useful.

Other useful functions
  * ringProduct, finds a ring equal to a product of rings
  * betterNormalizationMap, computes the integral
    closure of reduced rings (that are not necessarily domains)

Authors
=======

  * Karl Schwede (see http://math.utah.edu/~schwede/ ) <schwede@math.utah.edu>
  * Bernard Serbinowski <bserbinowski@gmail.com>

Certification a gold star
=========================

Version 0.21 of this package was accepted for publication in volume 10 (see
https://msp.org/jsag/2020/10-1/ ) of The Journal of Software for Algebra and
Geometry (see http://j-sag.org/ ) on 5 December 2019, in the article
Seminormalization package for Macaulay2 (see
https://msp.org/jsag/2020/10-1/p01.xhtml ). That version can be obtained from
the journal (see https://msp.org/jsag/2020/10-1/jsag-v10-n1-x01-
Seminormalization.m2 ) or from the Macaulay2 source code repository (see
http://github.com/Macaulay2/M2/blob/7a7e6f96b0122482f5d60306f34d06fd8ae1e885/M2
/Macaulay2/packages/Seminormalization.m2 ).

Version
=======

This documentation describes version 0.21 of Seminormalization.

Source code
===========

The source code from which this documentation is derived is in the file
Seminormalization.m2 (see common/share/Macaulay2/Seminormalization.m2 ).

Exports
=======

  * Functions and commands
      * betterNormalizationMap -- normalizes non
        domains
      * findElementMappingToTarget -- given
        a ring map and an element of the target, this find an element from the
        source whose image is the given one
      * flattenVarDegrees -- turns a multigraded ring
        into a singly graded ring
      * isSeminormal -- checks if a ring is seminormal
      * ringProduct -- compute the product of a list of
        rings
      * ringToAlgebraMap -- presents the target of a
        map of rings as an algebra over the source
      * seminormalize -- seminormalize a reduced ring
  * Methods
      * "betterNormalizationMap(Ring)" -- see betterNormalizationMap,
        -- normalizes non domains
      * "findElementMappingToTarget(RingMap,RingElement)" -- see
        findElementMappingToTarget, -- given a ring
        map and an element of the target, this find an element from the source
        whose image is the given one
      * "flattenVarDegrees(Ring)" -- see flattenVarDegrees,
        -- turns a multigraded ring into a singly graded
        ring
      * "isSeminormal(Ring)" -- see isSeminormal, -- checks
        if a ring is seminormal
      * "ringProduct(List)" -- see ringProduct, -- compute
        the product of a list of rings
      * "ringToAlgebraMap(RingMap)" -- see ringToAlgebraMap,
        -- presents the target of a map of rings as an
        algebra over the source
      * "ringToAlgebraMap(RingMap,ZZ)" -- see ringToAlgebraMap,
        -- presents the target of a map of rings as an
        algebra over the source
      * "seminormalize(Ring)" -- see seminormalize, --
        seminormalize a reduced ring
  * Symbols
      * Yy -- default symbol for new variables in the
        seminormalization method

For the programmer
==================

The object Seminormalization, is a package (Macaulay2Doc).

betterNormalizationMap -- normalizes non domains
************************************************

Synopsis
========

  * Usage:
        phi = betterNormalizationMap(S)
  * Inputs:
      * S, a ring (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * Strategy,
        => ..., default value {}, controls what strategy is used in
        calls to integralClosure
      * Variable, =>
        ..., default value Yy, set the name for new variables created by the
        function
  * Outputs:
      * phi, a ring map (Macaulay2Doc), the map from the ring to
        its normalization

Description
===========

Given a reduced ring $S$, this returns the normalization map $S \to S^N$.  It
works by computing the normalization after modding out by each minimal prime,
and then taking the product of the rings.  This should be compared to the
function icMap built into Macaulay2.

+--------------------------------------------------------+
|i1 : R = QQ[x,y]/ideal(x*y);                            |
+--------------------------------------------------------+
|i2 : icMap(R);                                          |
|                                                        |
|o2 : RingMap R <--- R                                   |
+--------------------------------------------------------+
|i3 : h2 = betterNormalizationMap(R);                    |
|                                                        |
|                       QQ[Yy0, Yy1, Yy2]                |
|o3 : RingMap ------------------------------------ <--- R|
|                 2                                      |
|             (Yy2  - Yy2, Yy1*Yy2 - Yy1, Yy0*Yy2)       |
+--------------------------------------------------------+
|i4 : RN = target h2                                     |
|                                                        |
|o4 = RN                                                 |
|                                                        |
|o4 : QuotientRing                                       |
+--------------------------------------------------------+
|i5 : radical ideal singularLocus RN                     |
|                                                        |
|o5 = ideal 1                                            |
|                                                        |
|o5 : Ideal of QQ[Yy0, Yy1, Yy2]                         |
+--------------------------------------------------------+

Ways to use betterNormalizationMap :
====================================

  * "betterNormalizationMap(Ring)"

For the programmer
==================

The object betterNormalizationMap, is a
method function with options (Macaulay2Doc).

betterNormalizationMap(...,Strategy=>...) -- controls what strategy is used in calls to integralClosure
*******************************************************************************************************

Description
===========

These options are passed along whenever the functions call integralClosure.

Further information
===================

  * Default value: {}
  * Function: betterNormalizationMap, --
    normalizes non domains
  * Option key: Strategy (Macaulay2Doc), -- an optional argument

See also
========

  * integralClosure(...,Strategy=>...) (IntegralClosure),
    --
    control the algorithm used

Functions with optional argument named Strategy :
=================================================

  * "addHook(...,Strategy=>...)" -- see addHook (Macaulay2Doc),
    -- add a hook function to an object for later processing
  * "annihilator(...,Strategy=>...)" -- see annihilator (Saturation),
    -- the annihilator ideal
  * "basis(...,Strategy=>...)" -- see basis (Macaulay2Doc), --
    basis or generating set of all or part of a ring, ideal or module
  * betterNormalizationMap(...,Strategy=>...)
    -- controls
    what strategy is used in calls to integralClosure
  * "seminormalize(...,Strategy=>...)"
  * "mingens(...,Strategy=>...)" -- see Complement (Macaulay2Doc),
    -- a Strategy option value
  * "trim(...,Strategy=>...)" -- see Complement (Macaulay2Doc),
    -- a Strategy option value
  * determinant(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "dual(MonomialIdeal,List,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * "dual(MonomialIdeal,RingElement,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc)
  * exteriorPower(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "gb(...,Strategy=>...)" -- see gb (Macaulay2Doc), -- compute a
    Gröbner basis
  * "GF(...,Strategy=>...)" -- see GF (Macaulay2Doc), -- make a finite
    field
  * "groebnerBasis(...,Strategy=>...)" -- see groebnerBasis (Macaulay2Doc),
    -- Gröbner basis, as a matrix
  * "hooks(...,Strategy=>...)" -- see hooks (Macaulay2Doc), -- list
    hooks attached to a key
  * "intersect(Ideal,Ideal,Strategy=>...)" -- see intersect(Ideal,Ideal) (Macaulay2Doc),
    -- compute an intersection of a
    sequence of ideals or modules
  * "intersect(Module,Module,Strategy=>...)" -- see
    intersect(Ideal,Ideal) (Macaulay2Doc), --
    compute an intersection of a sequence of ideals or modules
  * "isPrime(Ideal,Strategy=>...)" -- see isPrime(Ideal) (MinimalPrimes),
    -- whether an ideal is prime
  * "match(...,Strategy=>...)" -- see match (Macaulay2Doc), --
    regular expression matching
  * "decompose(Ideal,Strategy=>...)" -- see minimalPrimes (MinimalPrimes),
    -- minimal primes of an ideal
  * minors(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * pushForward(...,Strategy=>...) (missing documentation)
  * quotient(...,Strategy=>...) (Saturation)
  * resolution(...,Strategy=>...) (Macaulay2Doc)
  * saturate(...,Strategy=>...) (Saturation)
  * "syz(...,Strategy=>...)" -- see syz(Matrix) (Macaulay2Doc),
    -- compute the syzygy matrix

findElementMappingToTarget -- given a ring map and an element of the target, this find an element from the source whose image is the given one
**********************************************************************************************************************************************

Synopsis
========

  * Usage:
        x = findElementMappingToTarget(phi, y)
  * Inputs:
      * phi, a ring map (Macaulay2Doc),
      * y, a ring element (Macaulay2Doc),
  * Outputs:
      * x, a ring element (Macaulay2Doc), a ring element
        mapping to y by phi

Description
===========

Given a ring map $\phi : R \to S$ and $y \in S$, this finds $x \in R$ such that
$\phi(x) = y$ (if it exists).  If no such element exists, it throws an error.

+-----------------------------------------------+
|i1 : R = QQ[u,v, w];                           |
+-----------------------------------------------+
|i2 : S = QQ[a,b];                              |
+-----------------------------------------------+
|i3 : phi = map(S, R, {a, a*b, 0});             |
|                                               |
|o3 : RingMap S <--- R                          |
+-----------------------------------------------+
|i4 : findElementMappingToTarget(phi, a)        |
|                                               |
|o4 = u                                         |
|                                               |
|o4 : R                                         |
+-----------------------------------------------+
|i5 : findElementMappingToTarget(phi, sub(0, S))|
|                                               |
|o5 = 0                                         |
|                                               |
|o5 : R                                         |
+-----------------------------------------------+

Ways to use findElementMappingToTarget :
========================================

  * "findElementMappingToTarget(RingMap,RingElement)"

For the programmer
==================

The object findElementMappingToTarget, is a
method function (Macaulay2Doc).

flattenVarDegrees -- turns a multigraded ring into a singly graded ring
***********************************************************************

Synopsis
========

  * Usage:
        S = flattenVarDegrees(R)
  * Inputs:
      * R, a ring (Macaulay2Doc),
  * Outputs:
      * S, a ring (Macaulay2Doc),

Description
===========

This turns a multigraded ring into a singly graded ring, summing the individual
degrees.

+-----------------------------------------+
|i1 : R = QQ[x,y, Degrees=>{{1,2},{2,5}}];|
+-----------------------------------------+
|i2 : S = flattenVarDegrees(R);           |
+-----------------------------------------+
|i3 : vars S                              |
|                                         |
|o3 = | x y |                             |
|                                         |
|             1       2                   |
|o3 : Matrix S  <--- S                    |
+-----------------------------------------+
|i4 : degrees S                           |
|                                         |
|o4 = {{3}, {7}}                          |
|                                         |
|o4 : List                                |
+-----------------------------------------+

Ways to use flattenVarDegrees :
===============================

  * "flattenVarDegrees(Ring)"

For the programmer
==================

The object flattenVarDegrees, is a method function (Macaulay2Doc).

isSeminormal -- checks if a ring is seminormal
**********************************************

Synopsis
========

  * Usage:
        b = isSeminormal(R)
  * Inputs:
      * R, a ring (Macaulay2Doc),
  * Outputs:
      * b, a Boolean value (Macaulay2Doc), true if the ring is
        seminormal

Description
===========

This returns true if the ring is seminormal, otherwise it returns false.

+-------------------------------------+
|i1 : R = QQ[x,y]/ideal(y^2 - x^3);   |
+-------------------------------------+
|i2 : isSeminormal(R)                 |
|                                     |
|o2 = false                           |
+-------------------------------------+
|i3 : S = ZZ/5[a,b]/ideal(a^2-b^2+a^3)|
|                                     |
|o3 = S                               |
|                                     |
|o3 : QuotientRing                    |
+-------------------------------------+
|i4 : isSeminormal(R)                 |
|                                     |
|o4 = false                           |
+-------------------------------------+

Ways to use isSeminormal :
==========================

  * "isSeminormal(Ring)"

For the programmer
==================

The object isSeminormal, is a method function (Macaulay2Doc).

ringProduct -- compute the product of a list of rings
*****************************************************

Synopsis
========

  * Usage:
        M = ringProduct(L)
  * Inputs:
      * L, a list (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * Variable, =>
        ..., default value null, set the name for new variables created by the
        function
  * Outputs:
      * M, a list (Macaulay2Doc), a list with a product of the
        rings input, and information about its structure

Description
===========

Given a list of rings, of finite type over the same coefficient ring, this
computes a ring isomorphic to a product of the rings.  It returns a list with
three entries.  First is the ring.  Second is the list of orthogonal
idempotents.  Finally, it lists where the variables of each of the rings in the
list go in the new ring.

+-----------------------------------------------------------------------------+
|i1 : R = QQ[a];                                                              |
+-----------------------------------------------------------------------------+
|i2 : S = QQ[b];                                                              |
+-----------------------------------------------------------------------------+
|i3 : T = QQ[c];                                                              |
+-----------------------------------------------------------------------------+
|i4 : L = ringProduct({R,S})                                                  |
|                                                                             |
|                     QQ[aRE0RE0, e0, bRE1RE1, e1]                            |
|o4 = {---------------------------------------------------------,             |
|                      2                                                      |
|      (e0 + e1 - 1, e1  - e1, bRE1RE1*e1 - bRE1RE1, aRE0RE0*e1)              |
|     ------------------------------------------------------------------------|
|     MutableList{...2...}, {{aRE0RE0}, {bRE1RE1}}}                           |
|                                                                             |
|o4 : List                                                                    |
+-----------------------------------------------------------------------------+
|i5 : ringProduct({R,S,T})                                                    |
|                                                                             |
|                                           QQ[aRE0RE0, e0, bRE1RE1, e1, cRE2R|
|o5 = {-----------------------------------------------------------------------|
|                           2                                      2          |
|      (e0 + e1 + e2 - 1, e2  - e2, cRE2RE2*e2 - cRE2RE2, e1*e2, e1  - e1, bRE|
|     ------------------------------------------------------------------------|
|     E2, e2]                                                                 |
|     -------------------------------------------, MutableList{...3...},      |
|                                                                             |
|     1RE1*e1 - bRE1RE1, aRE0RE0*e1 + aRE0RE0*e2)                             |
|     ------------------------------------------------------------------------|
|     {{aRE0RE0}, {bRE1RE1}, {cRE2RE2}}}                                      |
|                                                                             |
|o5 : List                                                                    |
+-----------------------------------------------------------------------------+

The third entry in the list correspond to the elements $(x,0)$ and $(0,y)$ in
the product of rings.

+----------------------------+
|i6 : R = QQ[x];             |
+----------------------------+
|i7 : S = QQ[y,z];           |
+----------------------------+
|i8 : L = ringProduct({R,S});|
+----------------------------+
|i9 : newx = L#2#0#0;        |
+----------------------------+
|i10 : newy = L#2#1#0;       |
+----------------------------+
|i11 : newz = L#2#1#1;       |
+----------------------------+
|i12 : newx*newy==0          |
|                            |
|o12 = true                  |
+----------------------------+
|i13 : newx*newz==0          |
|                            |
|o13 = true                  |
+----------------------------+
|i14 : newy*newz==0          |
|                            |
|o14 = false                 |
+----------------------------+

Ways to use ringProduct :
=========================

  * "ringProduct(List)"

For the programmer
==================

The object ringProduct, is a method function with options (Macaulay2Doc).

ringToAlgebraMap -- presents the target of a map of rings as an algebra over the source
***************************************************************************************

Synopsis
========

  * Usage:
        L = ringToAlgebraMap(f)
        L = ringToAlgebraMap(f, n)
  * Inputs:
      * f, a ring map (Macaulay2Doc),
      * n, an integer (Macaulay2Doc),
  * Outputs:
      * L, a list (Macaulay2Doc), the first entry is the target of
        f as an algebra over the source

Description
===========

Given a ringmap map $f: A \to B$, this writes $B$ as $A[...]/J$.  It returns
the ring $A[...]/J$ as well as the isomorphism $B \to A[...]/J$.  Consider the
first example, a normalization of a cusp.

+------------------------------------------------------------+
|i1 : A = QQ[a,b]/ideal(a^2-b^3);                            |
+------------------------------------------------------------+
|i2 : B = QQ[t];                                             |
+------------------------------------------------------------+
|i3 : f = map(B, A, {t^3, t^2});                             |
|                                                            |
|o3 : RingMap B <--- A                                       |
+------------------------------------------------------------+
|i4 : (ringToAlgebraMap(f))#0                                |
|                                                            |
|                     A[tRE1]                                |
|o4 = --------------------------------------                 |
|          2                              2                  |
|     (tRE1  - b, b*tRE1 - a, - a*tRE1 + b )                 |
|                                                            |
|o4 : QuotientRing                                           |
+------------------------------------------------------------+
|i5 : (ringToAlgebraMap(f))#1                                |
|                                                            |
|                          A[tRE1]                           |
|o5 = map (--------------------------------------, B, {tRE1})|
|               2                              2             |
|          (tRE1  - b, b*tRE1 - a, - a*tRE1 + b )            |
|                                                            |
|                             A[tRE1]                        |
|o5 : RingMap -------------------------------------- <--- B  |
|                  2                              2          |
|             (tRE1  - b, b*tRE1 - a, - a*tRE1 + b )         |
+------------------------------------------------------------+

The second input is used to specify an integer used for new variable
enumeration and labeling.  Here is another example where we consider the
Frobenius map.

+-----------------------------------------------------------------------------+
|i6 : A = ZZ/5[x,y,z]/ideal(x^2-y*z);                                         |
+-----------------------------------------------------------------------------+
|i7 : B = ZZ/5[X,Y,Z]/ideal(X^2-Y*Z);                                         |
+-----------------------------------------------------------------------------+
|i8 : f = map(B, A, {X^5, Y^5, Z^5});                                         |
|                                                                             |
|o8 : RingMap B <--- A                                                        |
+-----------------------------------------------------------------------------+
|i9 : (ringToAlgebraMap(f))#0                                                 |
|                                                                             |
|                                                                             |
|o9 = ------------------------------------------------------------------------|
|          2                    3              2        3              2      |
|     (XRE1  - YRE1*ZRE1, z*YRE1  - x*XRE1*ZRE1 , x*YRE1  - y*XRE1*ZRE1 , z*XR|
|                                                                             |
|o9 : QuotientRing                                                            |
|-----------------------------------------------------------------------------|
|        A[XRE1, YRE1, ZRE1]                                                  |
|-----------------------------------------------------------------------------|
|       2         3             2         3      5               2    2       |
|E1*YRE1  - x*ZRE1 , x*XRE1*YRE1  - y*ZRE1 , ZRE1  - z, XRE1*YRE1 ZRE1  - x, Y|
|-----------------------------------------------------------------------------|
|------------------------------                                               |
|   5          3    3                                                         |
|RE1  - y, YRE1 ZRE1  - x*XRE1)                                               |
+-----------------------------------------------------------------------------+
|i10 : (ringToAlgebraMap(f, 5))#0                                             |
|                                                                             |
|                                                                             |
|o10 = -----------------------------------------------------------------------|
|           2                    3              2        3              2     |
|      (XRE5  - YRE5*ZRE5, z*YRE5  - x*XRE5*ZRE5 , x*YRE5  - y*XRE5*ZRE5 , z*X|
|                                                                             |
|o10 : QuotientRing                                                           |
|-----------------------------------------------------------------------------|
|         A[XRE5, YRE5, ZRE5]                                                 |
|-----------------------------------------------------------------------------|
|        2         3             2         3      5               2    2      |
|RE5*YRE5  - x*ZRE5 , x*XRE5*YRE5  - y*ZRE5 , ZRE5  - z, XRE5*YRE5 ZRE5  - x, |
|-----------------------------------------------------------------------------|
|-------------------------------                                              |
|    5          3    3                                                        |
|YRE5  - y, YRE5 ZRE5  - x*XRE5)                                              |
+-----------------------------------------------------------------------------+

Ways to use ringToAlgebraMap :
==============================

  * "ringToAlgebraMap(RingMap)"
  * "ringToAlgebraMap(RingMap,ZZ)"

For the programmer
==================

The object ringToAlgebraMap, is a method function (Macaulay2Doc).

seminormalize -- seminormalize a reduced ring
*********************************************

Synopsis
========

  * Usage:
        seminormalize(S)
  * Inputs:
      * S, a ring (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * Strategy,
        => ..., default value {}, controls what strategy is used in
        calls to integralClosure
      * Variable, =>
        ..., default value Yy, set the name for new variables created by the
        function
  * Outputs:
      * a list (Macaulay2Doc), the first entry of which is the
        seminormalization of the ring, the second and thirds are maps between
        the ring, its seminormalization and its normalization

Description
===========

This seminormalizes a reduced ring and outputs a list, the first entry of which
is the seminormalized ring, the second is the map from the ring to its
seminormalization, and finally the map from the seminormalization to its
normalization. In our first example, the cusp, the seminormalization and
normalization are isomorphic.

+-----------------------------------------------------------------------------+
|i1 : R = QQ[x,y]/ideal(x^3 - y^2);                                           |
+-----------------------------------------------------------------------------+
|i2 : L = seminormalize(R)                                                    |
|                                                                             |
|                    QQ[Yy ..Yy ]                                             |
|                         0    2                                              |
|o2 = {---------------------------------------, map                           |
|         2                        2                                          |
|      (Yy  - Yy , Yy Yy  - Yy , Yy  - Yy Yy )                                |
|         2     1    1  2     0    1     0  2                                 |
|     ------------------------------------------------------------------------|
|                    QQ[Yy ..Yy ]                                             |
|                         0    2                                              |
|     (---------------------------------------, R, {Yy , Yy }), map           |
|         2                        2                  1    0                  |
|      (Yy  - Yy , Yy Yy  - Yy , Yy  - Yy Yy )                                |
|         2     1    1  2     0    1     0  2                                 |
|     ------------------------------------------------------------------------|
|                 QQ[Yy   , x..y]                                             |
|                      0,0                                                    |
|     (------------------------------------,                                  |
|                 2                2                                          |
|      (Yy   y - x , Yy   x - y, Yy    - x)                                   |
|         0,0          0,0         0,0                                        |
|     ------------------------------------------------------------------------|
|                   QQ[Yy ..Yy ]                                              |
|                        0    2                                               |
|     ---------------------------------------, {y, x, Yy   })}                |
|        2                        2                     0,0                   |
|     (Yy  - Yy , Yy Yy  - Yy , Yy  - Yy Yy )                                 |
|        2     1    1  2     0    1     0  2                                  |
|                                                                             |
|o2 : List                                                                    |
+-----------------------------------------------------------------------------+
|i3 : L#0                                                                     |
|                                                                             |
|                   QQ[Yy ..Yy ]                                              |
|                        0    2                                               |
|o3 = ---------------------------------------                                 |
|        2                        2                                           |
|     (Yy  - Yy , Yy Yy  - Yy , Yy  - Yy Yy )                                 |
|        2     1    1  2     0    1     0  2                                  |
|                                                                             |
|o3 : QuotientRing                                                            |
+-----------------------------------------------------------------------------+
|i4 : target(L#2)                                                             |
|                                                                             |
|                QQ[Yy   , x..y]                                              |
|                     0,0                                                     |
|o4 = ------------------------------------                                    |
|                2                2                                           |
|     (Yy   y - x , Yy   x - y, Yy    - x)                                    |
|        0,0          0,0         0,0                                         |
|                                                                             |
|o4 : QuotientRing                                                            |
+-----------------------------------------------------------------------------+

The previous example seminormalized a non-seminormal ring.  Let's try a
seminormal ring (the pinch point).

+-----------------------------------------------------------------------------+
|i5 : R = QQ[x,y,z]/ideal(x^2*y-z^2);                                         |
+-----------------------------------------------------------------------------+
|i6 : L = seminormalize(R)                                                    |
|                                                                             |
|      QQ[Yy ..Yy ]       QQ[Yy ..Yy ]                                        |
|           0    2             0    2                                         |
|o6 = {------------, map (------------, R, {Yy , Yy , Yy }), map              |
|        2        2         2        2        1    2    0                     |
|      Yy Yy  - Yy        Yy Yy  - Yy                                         |
|        1  2     0         1  2     0                                        |
|     ------------------------------------------------------------------------|
|                 QQ[Yy   , x..z]             QQ[Yy ..Yy ]                    |
|                      0,0                         0    2                     |
|     (-------------------------------------, ------------, {z, x, y})}       |
|                                   2           2        2                    |
|      (Yy   z - x*y, Yy   x - z, Yy    - y)  Yy Yy  - Yy                     |
|         0,0           0,0         0,0         1  2     0                    |
|                                                                             |
|o6 : List                                                                    |
+-----------------------------------------------------------------------------+
|i7 : L#0                                                                     |
|                                                                             |
|     QQ[Yy ..Yy ]                                                            |
|          0    2                                                             |
|o7 = ------------                                                            |
|       2        2                                                            |
|     Yy Yy  - Yy                                                             |
|       1  2     0                                                            |
|                                                                             |
|o7 : QuotientRing                                                            |
+-----------------------------------------------------------------------------+
|i8 : target(L#2)                                                             |
|                                                                             |
|                QQ[Yy   , x..z]                                              |
|                     0,0                                                     |
|o8 = -------------------------------------                                   |
|                                  2                                          |
|     (Yy   z - x*y, Yy   x - z, Yy    - y)                                   |
|        0,0           0,0         0,0                                        |
|                                                                             |
|o8 : QuotientRing                                                            |
+-----------------------------------------------------------------------------+

We conclude with an example of a ring where the seminormalization, the
normalization and the ring itself are all are distinct, the tacnode.

+-----------------------------------------------------------------------------+
|i9 : R = QQ[x,y]/ideal(y*(y-x^2));                                           |
+-----------------------------------------------------------------------------+
|i10 : L = seminormalize(R)                                                   |
|                                                                             |
|       QQ[Yy ..Yy ]       QQ[Yy ..Yy ]                                       |
|            0    1             0    1                    2                   |
|o10 = {------------, map (------------, R, {Yy  + Yy , Yy }), map            |
|          Yy Yy              Yy Yy            0     1    0                   |
|            0  1               0  1                                          |
|      -----------------------------------------------------------------------|
|                                             QQ[Yy ..Yy ]                    |
|                 QQ[Yy0, Yy1, Yy2]                0    1                     |
|      (------------------------------------, ------------, {Yy1, Yy0})}      |
|           2                                    Yy Yy                        |
|       (Yy2  - Yy2, Yy1*Yy2 - Yy1, Yy0*Yy2)       0  1                       |
|                                                                             |
|o10 : List                                                                   |
+-----------------------------------------------------------------------------+
|i11 : L#0                                                                    |
|                                                                             |
|      QQ[Yy ..Yy ]                                                           |
|           0    1                                                            |
|o11 = ------------                                                           |
|         Yy Yy                                                               |
|           0  1                                                              |
|                                                                             |
|o11 : QuotientRing                                                           |
+-----------------------------------------------------------------------------+
|i12 : target(L#2)                                                            |
|                                                                             |
|                QQ[Yy0, Yy1, Yy2]                                            |
|o12 = ------------------------------------                                   |
|          2                                                                  |
|      (Yy2  - Yy2, Yy1*Yy2 - Yy1, Yy0*Yy2)                                   |
|                                                                             |
|o12 : QuotientRing                                                           |
+-----------------------------------------------------------------------------+

Ways to use seminormalize :
===========================

  * "seminormalize(Ring)"

For the programmer
==================

The object seminormalize, is a method function with options (Macaulay2Doc).

seminormalize(...,Variable=>...) -- set the name for new variables created by the function
******************************************************************************************

Description
===========

This option sets the default variable for new variables created by the above
functions.  You must pass it a symbol.  We first give an example of this in the
context of seminormalization.

+-----------------------------------------------------------------------------+
|i1 : A = QQ[a,b]/ideal(a^2-b^5);                                             |
+-----------------------------------------------------------------------------+
|i2 : seminormalize(A, Variable=>X)                                           |
|                                                                             |
|                 QQ[X ..X ]                            QQ[X ..X ]            |
|                     0   2                                 0   2             |
|o2 = {-------------------------------, map (-------------------------------, |
|        2        2          3                 2        2          3          |
|      (X  - X , X X  - X , X  - X X )       (X  - X , X X  - X , X  - X X )  |
|        2    0   0 2    1   0    1 2          2    0   0 2    1   0    1 2   |
|     ------------------------------------------------------------------------|
|                                   QQ[Yy   , a..b]                           |
|                                        1,0                                  |
|     A, {X , X }), map (-------------------------------------,               |
|          1   0                2        2       2    2                       |
|                        (Yy   b  - a, Yy   b - b , Yy    - b)                |
|                           1,0          1,0          1,0                     |
|     ------------------------------------------------------------------------|
|                QQ[X ..X ]                                                   |
|                    0   2                                                    |
|     -------------------------------, {b, a, Yy   })}                        |
|       2        2          3                   1,0                           |
|     (X  - X , X X  - X , X  - X X )                                         |
|       2    0   0 2    1   0    1 2                                          |
|                                                                             |
|o2 : List                                                                    |
+-----------------------------------------------------------------------------+

Here is an example where we normalize a non-domain.

+-----------------------------------------------------+
|i3 : B = QQ[u,v]/ideal(u*v);                         |
+-----------------------------------------------------+
|i4 : betterNormalizationMap(B, Variable=>Y)          |
|                                                     |
|                  QQ[Y0, Y1, Y2]                     |
|o4 = map (-----------------------------, B, {Y1, Y0})|
|             2                                       |
|          (Y2  - Y2, Y1*Y2 - Y1, Y0*Y2)              |
|                                                     |
|                     QQ[Y0, Y1, Y2]                  |
|o4 : RingMap ----------------------------- <--- B    |
|                2                                    |
|             (Y2  - Y2, Y1*Y2 - Y1, Y0*Y2)           |
+-----------------------------------------------------+

We conclude with an example of taking the product of two rings.

+-----------------------------------------------------------------------------+
|i5 : C = QQ[x];                                                              |
+-----------------------------------------------------------------------------+
|i6 : D = QQ[y];                                                              |
+-----------------------------------------------------------------------------+
|i7 : ringProduct({C,D}, Variable=>z)                                         |
|                                                                             |
|                  QQ[z0, z1, z2, z3]                                         |
|o7 = {------------------------------------------, MutableList{...2...},      |
|                      2                                                      |
|      (z1 + z3 - 1, z3  - z3, z2*z3 - z2, z0*z3)                             |
|     ------------------------------------------------------------------------|
|     {{z0}, {z2}}}                                                           |
|                                                                             |
|o7 : List                                                                    |
+-----------------------------------------------------------------------------+

Further information
===================

  * Default value: Yy,
  * Function: seminormalize, -- seminormalize a reduced
    ring
  * Option key: Variable (Macaulay2Doc), -- specify a name for a
    variable

Functions with optional argument named Variable :
=================================================

  * conwayPolynomial(...,Variable=>...) (missing documentation)
  * "GF(...,Variable=>...)" -- see GF (Macaulay2Doc), -- make a finite
    field
  * "Grassmannian(...,Variable=>...)" -- see Grassmannian(ZZ,ZZ) (Macaulay2Doc),
    -- the Grassmannian of linear
    subspaces of a vector space
  * idealizer(...,Variable=>...) (IntegralClosure)
    -- Sets
    the name of the indexed variables introduced in computing the endomorphism
    ring Hom(J,J).
  * integralClosure(...,Variable=>...) (IntegralClosure),
    --
    set the base letter for the indexed variables introduced while computing
    the integral closure
  * "intersectInP(...,Variable=>...)" -- see
    intersectInP(...,BasisElementLimit=>...) (ReesAlgebra),
    --
    Option for intersectInP
  * "multiplicity(...,Variable=>...)" -- see
    intersectInP(...,BasisElementLimit=>...) (ReesAlgebra),
    --
    Option for intersectInP
  * makeS2(...,Variable=>...) (IntegralClosure)
    -- Sets the
    name of the indexed variables introduced in computing the S2-ification.
  * "ringFromFractions(...,Variable=>...)" -- see ringFromFractions (IntegralClosure),
    -- find presentation for f.g. ring
  * "Schubert(...,Variable=>...)" -- see Schubert(ZZ,ZZ,VisibleList) (Macaulay2Doc),
    -- find the Plücker
    ideal of a Schubert variety
  * "betterNormalizationMap(...,Variable=>...)"
  * "ringProduct(...,Variable=>...)"
  * seminormalize(...,Variable=>...)
    -- set the name for new
    variables created by the function
  * "distinguished(...,Variable=>...)" -- see
    symmetricKernel(...,Variable=>...) (ReesAlgebra),
    --
    Choose name for variables in the created ring
  * "isReduction(...,Variable=>...)" -- see
    symmetricKernel(...,Variable=>...) (ReesAlgebra),
    --
    Choose name for variables in the created ring
  * "jacobianDual(...,Variable=>...)" -- see
    symmetricKernel(...,Variable=>...) (ReesAlgebra),
    --
    Choose name for variables in the created ring
  * "normalCone(...,Variable=>...)" -- see
    symmetricKernel(...,Variable=>...) (ReesAlgebra),
    --
    Choose name for variables in the created ring
  * "reesAlgebra(...,Variable=>...)" -- see
    symmetricKernel(...,Variable=>...) (ReesAlgebra),
    --
    Choose name for variables in the created ring
  * "reesIdeal(...,Variable=>...)" -- see
    symmetricKernel(...,Variable=>...) (ReesAlgebra),
    --
    Choose name for variables in the created ring
  * "specialFiber(...,Variable=>...)" -- see
    symmetricKernel(...,Variable=>...) (ReesAlgebra),
    --
    Choose name for variables in the created ring
  * "specialFiberIdeal(...,Variable=>...)" -- see
    symmetricKernel(...,Variable=>...) (ReesAlgebra),
    --
    Choose name for variables in the created ring
  * symmetricKernel(...,Variable=>...) (ReesAlgebra),
    --
    Choose name for variables in the created ring

Yy -- default symbol for new variables in the seminormalization method
**********************************************************************

Description
===========

This is the default symbol for new variables created by the functions in this
packages, in particular the seminormalize method.

See also
========

  * seminormalize(...,Variable=>...)
    -- set the name for new
    variables created by the function

For the programmer
==================

The object Yy, is a symbol (Macaulay2Doc).