This is LocalRings.info, produced by Macaulay2, version 1.25.11

LocalRings -- Localizations of polynomial rings at prime ideals
***************************************************************

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

This package defines the LocalRing, class for localizations of
polynomial rings and extends most basic commutative algebra computations to
such local rings. Moreover, the functions hilbertSamuelFunction,
and length(Module) (Macaulay2Doc),
for Artinian modules over a local ring are
implemented in this package.

For information about the classical way of working with local rings at maximal
ideals see replacements for functions from version 1.0.

The following is an example of defining the rational quartic curve in $\PP^3$
localized at a maximal ideal and a prime ideal using two different methods.

+-------------------------------------------------------+
|i1 : R = ZZ/32003[a..d];                               |
+-------------------------------------------------------+
|i2 : I = monomialCurveIdeal(R,{1,3,4})                 |
|                                                       |
|                        3      2     2    2    3    2  |
|o2 = ideal (b*c - a*d, c  - b*d , a*c  - b d, b  - a c)|
|                                                       |
|o2 : Ideal of R                                        |
+-------------------------------------------------------+
|i3 : M = ideal"a,b,c,d"; -- maximal ideal at the origin|
|                                                       |
|o3 : Ideal of R                                        |
+-------------------------------------------------------+
|i4 : P = ideal"a,b,c"; -- prime ideal                  |
|                                                       |
|o4 : Ideal of R                                        |
+-------------------------------------------------------+
|i5 : RM = R_M                                          |
|                                                       |
|o5 = RM                                                |
|                                                       |
|o5 : LocalRing, maximal ideal (a, b, c, d)             |
+-------------------------------------------------------+
|i6 : RP = localRing(R, P)                              |
|                                                       |
|o6 = RP                                                |
|                                                       |
|o6 : LocalRing, maximal ideal (a, b, c)                |
+-------------------------------------------------------+

An ideal, module, or chain complex may either be localized using promote (Macaulay2Doc),
or using the tensor (Macaulay2Doc),
product.

+--------------------------------+
|i7 : C = freeResolution I       |
|                                |
|      1      4      4      1    |
|o7 = R  <-- R  <-- R  <-- R     |
|                                |
|     0      1      2      3     |
|                                |
|o7 : Complex                    |
+--------------------------------+
|i8 : D = C ** RM;               |
+--------------------------------+
|i9 : E = pruneComplex D         |
|                                |
|       1       4       4       1|
|o9 = RM  <-- RM  <-- RM  <-- RM |
|                                |
|     0       1       2       3  |
|                                |
|o9 : Complex                    |
+--------------------------------+

The computation above shows that the rational quartic curve is not locally
Cohen-Macaulay at the origin. Therefore the curve is not Cohen-Macaulay

However, the curve is Cohen-Macaulay at the prime ideal $(a, b, c)$ (and in
fact any other prime ideal).

+--------------------------+
|i10 : D' = C ** RP;       |
+--------------------------+
|i11 : E' = pruneComplex D'|
|                          |
|        1       2       1 |
|o11 = RP  <-- RP  <-- RP  |
|                          |
|      0       1       2   |
|                          |
|o11 : Complex             |
+--------------------------+

The elementary definitions and operations are declared in localring.m2. Engine
routines for core computations are implemented in e/localring.hpp.

The following commutative algebra computations are implemented in this package:
syz (Macaulay2Doc), freeResolution (Complexes),
see mingens (Macaulay2Doc),
minimalPresentation (Macaulay2Doc), trim (Macaulay2Doc),
see length(Module) (Macaulay2Doc),
isSubset (Macaulay2Doc), inducedMap (Macaulay2Doc),
see quotient(Matrix,Matrix) (Macaulay2Doc),
see remainder(Matrix,Matrix) (Macaulay2Doc),
see quotient(Module,Module) (Saturation),
see saturate (Saturation),
see annihilator (Saturation). Most of
these routines rely on the functions liftUp, and
pruneComplex (PruneComplex), and take advantage of Nakayama's
lemma and flatness of local rings.

In addition, methods such as map (Macaulay2Doc), modulo (Macaulay2Doc),
see subquotient (Macaulay2Doc),
kernel (Macaulay2Doc), cokernel (Macaulay2Doc),
image (Macaulay2Doc), homology (Macaulay2Doc),
Hom (Macaulay2Doc), Ext (Macaulay2Doc), Tor (Macaulay2Doc),
etc. work over local rings automatically.

Caveat
======

Currently limited to localization at prime ideals rather than arbitrary
multiplicatively closed sets. Quotients of local rings are not implemented yet.
Moreover, certain functions (such as symbol%, radical, minimalPrimes,
leadingCoefficient) are ambiguous or not yet defined.

See also
========

  * PruneComplex -- Pruning chain complexes over
    polynomial and local rings

Authors
=======

  * Mahrud Sayrafi (see https://math.umn.edu/~mahrud/ ) <mahrud@umn.edu>
  * Mike Stillman (see http://www.math.cornell.edu/~mike/ )
    <mike@math.cornell.edu>
  * David Eisenbud (see http://www.msri.org/~de/ ) <de@msri.org>

Version
=======

This documentation describes version 2.1 of LocalRings, released May 08, 2021.

Citation
========

If you have used this package in your research, please cite it as follows:

+----------------------------------------------------------------------------+
|@misc{LocalRingsSource,                                                     |
|  title = {{LocalRings: operations over a local ring R_p. Version~2.1}},    |
|  author = {Mahrud Sayrafi and Mike Stillman and David Eisenbud},           |
|  howpublished = {A \emph{Macaulay2} package available at                   |
|    \url{https://github.com/Macaulay2/M2/tree/stable/M2/Macaulay2/packages}}|
|}                                                                           |
|                                                                            |
+----------------------------------------------------------------------------+

Exports
=======

  * Types
      * LocalRing -- The class of all local rings
  * Functions and commands
      * hilbertSamuelFunction -- Computes the
        Hilbert-Samuel Function of Modules over Local Rings
      * liftUp -- Lifts various objects over R_P to R.
      * localComplement -- find the splitting of the
        target of a map
      * localMingens -- finds a minimal set of generators
      * localModulo -- find the pre-image (pullback) of
        image of a map over a local ring
      * localPrune -- find a minimal presentation
      * localResolution -- find a resolution over a
        local ring
      * localRing -- Constructor for local rings
      * localsyz -- find syzygies
      * setMaxIdeal -- set the maximal ideal for local ring
        methods
  * Methods
      * baseRing(LocalRing) -- produce the ring
        from which a ring was formed
      * char(LocalRing) -- get the characteristic
        of the ring or field
      * coefficientRing(LocalRing), --
        get the coefficient ring
      * degreeLength(LocalRing) -- the
        length of the degree vector
      * degrees(LocalRing) -- degrees of
        generators
      * dim(LocalRing) -- compute the Krull
        dimension
      * frac(LocalRing) -- construct a fraction
        field
      * generators(LocalRing) -- the list of
        generators of a ring
      * "hilbertSamuelFunction(Ideal,Module,ZZ)" -- see
        hilbertSamuelFunction, -- Computes the
        Hilbert-Samuel Function of Modules over Local Rings
      * "hilbertSamuelFunction(Ideal,Module,ZZ,ZZ)" -- see
        hilbertSamuelFunction, -- Computes the
        Hilbert-Samuel Function of Modules over Local Rings
      * "hilbertSamuelFunction(Module,ZZ)" -- see hilbertSamuelFunction,
        -- Computes the Hilbert-Samuel Function of
        Modules over Local Rings
      * "hilbertSamuelFunction(Module,ZZ,ZZ)" -- see
        hilbertSamuelFunction, -- Computes the
        Hilbert-Samuel Function of Modules over Local Rings
      * isCommutative(LocalRing), --
        whether a ring is commutative
      * isWellDefined(LocalRing), --
        whether a local ring is well defined
      * "liftUp(Ideal,Ring)" -- see liftUp, -- Lifts various
        objects over R_P to R.
      * "liftUp(Matrix,Ring)" -- see liftUp, -- Lifts various
        objects over R_P to R.
      * "liftUp(Module,Ring)" -- see liftUp, -- Lifts various
        objects over R_P to R.
      * "liftUp(MutableMatrix,Ring)" -- see liftUp, -- Lifts
        various objects over R_P to R.
      * "liftUp(RingElement,Ring)" -- see liftUp, -- Lifts
        various objects over R_P to R.
      * "liftUp(Thing)" -- see liftUp, -- Lifts various objects
        over R_P to R.
      * "localComplement(Matrix)" -- see localComplement,
        -- find the splitting of the target of a map
      * "localMingens(Matrix)" -- see localMingens, --
        finds a minimal set of generators
      * "localModulo(Matrix,Matrix)" -- see localModulo, --
        find the pre-image (pullback) of image of a map over a local ring
      * "localPrune(Module)" -- see localPrune, -- find a
        minimal presentation
      * "localResolution(Ideal)" -- see localResolution,
        -- find a resolution over a local ring
      * "localResolution(Module)" -- see localResolution,
        -- find a resolution over a local ring
      * "max(LocalRing)" -- see LocalRing, -- The class of all
        local rings
      * "localRing(EngineRing,Ideal)" -- see localRing, --
        Constructor for local rings
      * "localRing(Ring,Ideal)" -- see localRing, --
        Constructor for local rings
      * "PolynomialRing _ Ideal" -- see localRing, --
        Constructor for local rings
      * "PolynomialRing _ RingElement" -- see localRing, --
        Constructor for local rings
      * "localsyz(Matrix)" -- see localsyz, -- find syzygies
      * numgens(LocalRing) -- number of
        generators of a polynomial ring
      * "setMaxIdeal(Ideal)" -- see setMaxIdeal, -- set the
        maximal ideal for local ring methods
  * Symbols
      * "maxIdeal" -- see LocalRing, -- The class of all local
        rings
      * "residueMap" -- see LocalRing, -- The class of all
        local rings

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

The object LocalRings, is a package (Macaulay2Doc),
defined in LocalRings.m2, with auxiliary files in LocalRings/.

-------------------------------------------------------------------------------

The source of this document is in LocalRings/doc.m2:64:0.

LocalRing -- The class of all local rings
*****************************************

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

Currently only localizations at prime ideals of a polynomial ring are
supported.

+-------------------------------------------------------------------+
|i1 : S = QQ[x,y,z,w];                                              |
+-------------------------------------------------------------------+
|i2 : I = ideal"xz-y2,yw-z2,xw-yz"; -- The twisted cubic curve      |
|                                                                   |
|o2 : Ideal of S                                                    |
+-------------------------------------------------------------------+
|i3 : R = S_I                                                       |
|                                                                   |
|o3 = R                                                             |
|                                                                   |
|                                  2           2                    |
|o3 : LocalRing, maximal ideal (- y  + x*z, - z  + y*w, - y*z + x*w)|
+-------------------------------------------------------------------+
|i4 : K = frac(S/I)                                                 |
|                                                                   |
|o4 = K                                                             |
|                                                                   |
|o4 : FractionField                                                 |
+-------------------------------------------------------------------+

The maximal ideal and a residue map to the residue field are stored in the
ring.

+------------------------------------------------+
|i5 : max R                                      |
|                                                |
|               2           2                    |
|o5 = ideal (- y  + x*z, - z  + y*w, - y*z + x*w)|
|                                                |
|o5 : Ideal of R                                 |
+------------------------------------------------+
|i6 : R.maxIdeal                                 |
|                                                |
|               2           2                    |
|o6 = ideal (- y  + x*z, - z  + y*w, - y*z + x*w)|
|                                                |
|o6 : Ideal of S                                 |
+------------------------------------------------+
|i7 : R.residueMap                               |
|                                                |
|o7 = map (K, R, {x, y, z, w})                   |
|                                                |
|o7 : RingMap K <-- R                            |
+------------------------------------------------+

Objects over the base ring can be localized easily.

+------------------------------------------------+
|i8 : I ** R                                     |
|                                                |
|               2           2                    |
|o8 = ideal (- y  + x*z, - z  + y*w, - y*z + x*w)|
|                                                |
|o8 : Ideal of R                                 |
+------------------------------------------------+

See also
========

  * PolynomialRing (Macaulay2Doc) -- the class of all
    ordered monoid rings
  * hilbertSamuelFunction -- Computes the
    Hilbert-Samuel Function of Modules over Local Rings
  * length(Module) (Macaulay2Doc) -- compute the
    length of a module

Functions and methods returning a local ring:
=============================================

  * localRing -- Constructor for local rings
  * "PolynomialRing _ Ideal" -- see localRing, -- Constructor
    for local rings
  * "PolynomialRing _ RingElement" -- see localRing, --
    Constructor for local rings

Methods that use a local ring:
==============================

  * baseRing(LocalRing) -- produce the ring
    from which a ring was formed
  * char(LocalRing) -- get the characteristic of
    the ring or field
  * coefficientRing(LocalRing) -- get
    the coefficient ring
  * degreeLength(LocalRing) -- the length
    of the degree vector
  * degrees(LocalRing) -- degrees of generators
  * dim(LocalRing) -- compute the Krull dimension
  * frac(LocalRing) -- construct a fraction field
  * generators(LocalRing) -- the list of
    generators of a ring
  * isCommutative(LocalRing) -- whether a
    ring is commutative
  * isWellDefined(LocalRing) -- whether a
    local ring is well defined
  * "max(LocalRing)"
  * numgens(LocalRing) -- number of generators
    of a polynomial ring

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

The object LocalRing, is a type (Macaulay2Doc),
with ancestor classes EngineRing (Macaulay2Doc), < Ring (Macaulay2Doc)
< Type (Macaulay2Doc) < MutableHashTable (Macaulay2Doc)
< HashTable (Macaulay2Doc) <
Thing (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in LocalRings/doc.m2:234:0.

localRing -- Constructor for local rings
****************************************

  * Usage:
        R_P
        R_f
        localRing(R, P)
  * Inputs:
      * R, a polynomial ring (Macaulay2Doc), the base
        ring for the localization
      * P, an ideal (Macaulay2Doc), a prime ideal for the
        localization
      * f, a ring element (Macaulay2Doc), a ring element to
        localize (not yet implemented)
  * Outputs:
      * a local ring, the local ring $R_{\mathfrac p}$

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

This is the constructor for the type LocalRing.

+-------------------------------------------------------------------+
|i1 : R = QQ[x,y,z,w];                                              |
+-------------------------------------------------------------------+
|i2 : P = ideal"xz-y2,yw-z2,xw-yz"; -- The twisted cubic curve      |
|                                                                   |
|o2 : Ideal of R                                                    |
+-------------------------------------------------------------------+
|i3 : I = ideal"xz-y2,z(yw-z2)-w(xw-yz)";                           |
|                                                                   |
|o3 : Ideal of R                                                    |
+-------------------------------------------------------------------+
|i4 : RP = R_P                                                      |
|                                                                   |
|o4 = RP                                                            |
|                                                                   |
|                                  2           2                    |
|o4 : LocalRing, maximal ideal (- y  + x*z, - z  + y*w, - y*z + x*w)|
+-------------------------------------------------------------------+
|i5 : M = RP^1/promote(I, RP)                                       |
|                                                                   |
|o5 = cokernel | -y2+xz -z3+2yzw-xw2 |                              |
|                                                                   |
|                              1                                    |
|o5 : RP-module, quotient of RP                                     |
+-------------------------------------------------------------------+
|i6 : length M                                                      |
|                                                                   |
|o6 = 2                                                             |
+-------------------------------------------------------------------+

Note that the ideal $P$ is assumed to be prime. Use
isWellDefined(LocalRing), to confirm that a local
ring is well defined.

Ways to use localRing:
======================

  * "localRing(EngineRing,Ideal)"
  * "localRing(Ring,Ideal)"

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

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

-------------------------------------------------------------------------------

The source of this document is in LocalRings/doc.m2:234:0.

liftUp -- Lifts various objects over R_P to R.
**********************************************

  * Usage:
        I = liftUp IP
        M = liftUp(MP, R)
  * Inputs:
      * MP, a matrix (Macaulay2Doc), a matrix, module, or ideal
        over a local ring RP
      * R, a ring (Macaulay2Doc), a ring, RP is a localization of R
  * Outputs:
      * M, a matrix (Macaulay2Doc), a matrix, module, or ideal
        over the ring R

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

Given an object, for instance an ideal IP, over a local ring (RP, P), this
method returns the preimage of that object under the canonical map R -> RP
after clearing denominators of IP.

For matrices (hence most other objects as well), clearing denominators is
performed columnwise.

In conjunction with pruneComplex, liftUp is used to implement many of the
elementary operations over local rings such as syz.

Here is an example of computing the syzygy over a local ring using liftUp and
pruneComplex:

+-------------------------------------------------------------+
|i1 : R = ZZ/32003[vars(0..5)];                               |
+-------------------------------------------------------------+
|i2 : I = ideal"abc-def,ab2-cd2-c,-b3+acd";                   |
|                                                             |
|o2 : Ideal of R                                              |
+-------------------------------------------------------------+
|i3 : C = freeResolution I;                                   |
+-------------------------------------------------------------+
|i4 : M = ideal gens R;                                       |
|                                                             |
|o4 : Ideal of R                                              |
+-------------------------------------------------------------+
|i5 : RM = localRing(R, M);                                   |
+-------------------------------------------------------------+
|i6 : F = C.dd_2;                                             |
|                                                             |
|             4      6                                        |
|o6 : Matrix R  <-- R                                         |
+-------------------------------------------------------------+
|i7 : FM = F ** RM                                            |
|                                                             |
|o7 = {3} | 0    0    -b3+acd   -abc+def  0       a2c2-b2ef  ||
|     {3} | cef  ac2  ab2-cd2-c 0         abc-def -ac2d+abef ||
|     {3} | -ac2 -b2c 0         ab2-cd2-c -b3+acd -a2bc+b2cd ||
|     {5} | b    d    0         0         0       1          ||
|                                                             |
|              4       6                                      |
|o7 : Matrix RM  <-- RM                                       |
+-------------------------------------------------------------+

This is the process for finding the syzygy of FM:

+-----------------------------+
|i8 : f = liftUp FM;          |
|                             |
|             4      6        |
|o8 : Matrix R  <-- R         |
+-----------------------------+
|i9 : g = syz f;              |
|                             |
|             6      5        |
|o9 : Matrix R  <-- R         |
+-----------------------------+
|i10 : h = syz g;             |
|                             |
|              5      2       |
|o10 : Matrix R  <-- R        |
+-----------------------------+
|i11 : C = {g ** RM, h ** RM};|
+-----------------------------+

Now we prune the map h, which is the first map from the right:

+---------------------------------------------------------+
|i12 : C = first pruneComplex(C, 1, Direction => "right");|
+---------------------------------------------------------+
|i13 : g' = C#0;                                          |
+---------------------------------------------------------+

Scale each row with the common denominator of the corresponding column in FM:

+---------------------------------------------+
|i14 : N = transpose entries FM;              |
+---------------------------------------------+
|i15 : for i from 0 to numcols FM - 1 do      |
|        rowMult(g', i, N_i/denominator//lcm);|
+---------------------------------------------+

The syzygy of FM is:

+--------------------------------------+
|i16 : GM = map(source FM, , matrix g')|
|                                      |
|o16 = {6} | -d d2+1 0   |             |
|      {6} | b  -bd  -1  |             |
|      {6} | 0  ef   -ac |             |
|      {6} | 0  -ac  b2  |             |
|      {6} | -c 0    ab  |             |
|      {7} | 0  -b   d   |             |
|                                      |
|               6       3              |
|o16 : Matrix RM  <-- RM               |
+--------------------------------------+
|i17 : kernel FM == image GM           |
|                                      |
|o17 = true                            |
+--------------------------------------+

Caveat
======

This is NOT the same as lift. Not tested with quotients properly.

See also
========

  * pruneComplex (PruneComplex) -- Prunes a chain complex
    or list of mutable matrices

Ways to use liftUp:
===================

  * "liftUp(Ideal,Ring)"
  * "liftUp(Matrix,Ring)"
  * "liftUp(Module,Ring)"
  * "liftUp(MutableMatrix,Ring)"
  * "liftUp(RingElement,Ring)"
  * "liftUp(Thing)"

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

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

-------------------------------------------------------------------------------

The source of this document is in LocalRings/doc.m2:305:0.

baseRing(LocalRing) -- produce the ring from which a ring was formed
********************************************************************

  * Function: baseRing (Macaulay2Doc),

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

See baseRing(Ring) (Macaulay2Doc),

Ways to use this method:
========================

  * baseRing(LocalRing) -- produce the ring
    from which a ring was formed
-------------------------------------------------------------------------------

The source of this document is in LocalRings/doc.m2:375:0.

char(LocalRing) -- get the characteristic of the ring or field
**************************************************************

  * Function: char (Macaulay2Doc),

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

See char(Ring) (Macaulay2Doc),

Ways to use this method:
========================

  * char(LocalRing) -- get the characteristic of
    the ring or field
-------------------------------------------------------------------------------

The source of this document is in LocalRings/doc.m2:375:0.

coefficientRing(LocalRing) -- get the coefficient ring
******************************************************

  * Function: coefficientRing (Macaulay2Doc),

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

See coefficientRing(Ring) (Macaulay2Doc),

Ways to use this method:
========================

  * coefficientRing(LocalRing) -- get
    the coefficient ring
-------------------------------------------------------------------------------

The source of this document is in LocalRings/doc.m2:375:0.

degreeLength(LocalRing) -- the length of the degree vector
**********************************************************

  * Function: degreeLength (Macaulay2Doc),

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

See degreeLength(Ring) (Macaulay2Doc),

Ways to use this method:
========================

  * degreeLength(LocalRing) -- the length
    of the degree vector
-------------------------------------------------------------------------------

The source of this document is in LocalRings/doc.m2:375:0.

degrees(LocalRing) -- degrees of generators
*******************************************

  * Function: degrees (Macaulay2Doc),

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

See degrees(Ring) (Macaulay2Doc),

Ways to use this method:
========================

  * degrees(LocalRing) -- degrees of generators
-------------------------------------------------------------------------------

The source of this document is in LocalRings/doc.m2:375:0.

dim(LocalRing) -- compute the Krull dimension
*********************************************

  * Function: dim (Macaulay2Doc),

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

See dim(Ring) (Macaulay2Doc),

Ways to use this method:
========================

  * dim(LocalRing) -- compute the Krull dimension
-------------------------------------------------------------------------------

The source of this document is in LocalRings/doc.m2:375:0.

frac(LocalRing) -- construct a fraction field
*********************************************

  * Function: frac (Macaulay2Doc),

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

See frac(Ring) (Macaulay2Doc),

Ways to use this method:
========================

  * frac(LocalRing) -- construct a fraction field
-------------------------------------------------------------------------------

The source of this document is in LocalRings/doc.m2:375:0.

generators(LocalRing) -- the list of generators of a ring
*********************************************************

  * Function: generators (Macaulay2Doc),

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

See generators(Ring) (Macaulay2Doc),

Ways to use this method:
========================

  * generators(LocalRing) -- the list of
    generators of a ring
-------------------------------------------------------------------------------

The source of this document is in LocalRings/doc.m2:375:0.

isCommutative(LocalRing) -- whether a ring is commutative
*********************************************************

  * Function: isCommutative (Macaulay2Doc),

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

See isCommutative(Ring) (Macaulay2Doc),

Ways to use this method:
========================

  * isCommutative(LocalRing) -- whether a
    ring is commutative
-------------------------------------------------------------------------------

The source of this document is in LocalRings/doc.m2:375:0.

isWellDefined(LocalRing) -- whether a local ring is well defined
****************************************************************

  * Function: isWellDefined (Macaulay2Doc),

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

This method checks whether the local ring was produced by localization at a
prime ideal.

+-------------------------------------------------------------+
|i1 : R = QQ[x,y,z,w]                                         |
|                                                             |
|o1 = R                                                       |
|                                                             |
|o1 : PolynomialRing                                          |
+-------------------------------------------------------------+
|i2 : P = ideal"xz-y2,yw-z2,xw-yz"; -- The twisted cubic curve|
|                                                             |
|o2 : Ideal of R                                              |
+-------------------------------------------------------------+
|i3 : isWellDefined R_P                                       |
|                                                             |
|o3 = true                                                    |
+-------------------------------------------------------------+
|i4 : Q = ideal"xz-y2,z(yw-z2)-w(xw-yz)";                     |
|                                                             |
|o4 : Ideal of R                                              |
+-------------------------------------------------------------+
|i5 : isWellDefined R_Q                                       |
|                                                             |
|o5 = false                                                   |
+-------------------------------------------------------------+

See also
========

  * isPrime (Macaulay2Doc) -- whether a integer or polynomial is
    prime

Ways to use this method:
========================

  * isWellDefined(LocalRing) -- whether a
    local ring is well defined
-------------------------------------------------------------------------------

The source of this document is in LocalRings/doc.m2:234:0.

numgens(LocalRing) -- number of generators of a polynomial ring
***************************************************************

  * Function: numgens (Macaulay2Doc),

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

See numgens(Ring) (Macaulay2Doc),

Ways to use this method:
========================

  * numgens(LocalRing) -- number of generators
    of a polynomial ring
-------------------------------------------------------------------------------

The source of this document is in LocalRings/doc.m2:375:0.

hilbertSamuelFunction -- Computes the Hilbert-Samuel Function of Modules over Local Rings
*****************************************************************************************

  * Usage:
        h = hilbertSamuelFunction(M, n)
        L = hilbertSamuelFunction(M, n0, n1)
        h = hilbertSamuelFunction(q, M, n)
        L = hilbertSamuelFunction(q, M, n0, n1)
  * Inputs:
      * M, a module (Macaulay2Doc), a module over a local ring
      * n, an integer (Macaulay2Doc), single input to the function
      * n0, an integer (Macaulay2Doc), first input to the function
      * n1, an integer (Macaulay2Doc), last input to the function
      * q, an ideal (Macaulay2Doc), a parameter ideal
  * Outputs:
      * h, an integer (Macaulay2Doc), the integer output of the
        Hilbert-Samuel function
      * L, a sequence (Macaulay2Doc), an sequence of integer
        outputs of the Hilbert-Samuel function

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

Given a module over a local ring, a parameter ideal, and an integer, this
method computes the Hilbert-Samuel function for the module. If parameter ideal
is not given, the maximal ideal is assumed.

Note: If computing at index n is fast but slows down at n+1, try computing at
range (n, n+1). On the other hand, if computing at range (n, n+m) is slow, try
breaking up the range.

To learn more read Eisenbud, Commutative Algebra, Chapter 12.

Here is an example from Computations in Algebraic Geometry with Macaulay2, pp.
61:

+-----------------------------------------------------+
|i1 : R = QQ[x,y,z];                                  |
+-----------------------------------------------------+
|i2 : RP = localRing(R, ideal gens R);                |
+-----------------------------------------------------+
|i3 : I = ideal"x5+y3+z3,x3+y5+z3,x3+y3+z5"           |
|                                                     |
|             5    3    3   5    3    3   5    3    3 |
|o3 = ideal (x  + y  + z , y  + x  + z , z  + x  + y )|
|                                                     |
|o3 : Ideal of RP                                     |
+-----------------------------------------------------+
|i4 : M = RP^1/I                                      |
|                                                     |
|o4 = cokernel | x5+y3+z3 y5+x3+z3 z5+x3+y3 |         |
|                                                     |
|                              1                      |
|o4 : RP-module, quotient of RP                       |
+-----------------------------------------------------+
|i5 : elapsedTime hilbertSamuelFunction(M, 0, 6)      |
| -- .243973s elapsed                                 |
|                                                     |
|o5 = {1, 3, 6, 7, 6, 3, 1}                           |
|                                                     |
|o5 : List                                            |
+-----------------------------------------------------+
|i6 : oo//sum                                         |
|                                                     |
|o6 = 27                                              |
+-----------------------------------------------------+

An example of using a parameter ideal:

+-----------------------------------------------------------------------------+
|i7 : R = ZZ/32003[x,y];                                                      |
+-----------------------------------------------------------------------------+
|i8 : RP = localRing(R, ideal gens R);                                        |
+-----------------------------------------------------------------------------+
|i9 : N = RP^1                                                                |
|                                                                             |
|       1                                                                     |
|o9 = RP                                                                      |
|                                                                             |
|o9 : RP-module, free                                                         |
+-----------------------------------------------------------------------------+
|i10 : q = ideal"x2,y3"                                                       |
|                                                                             |
|              2   3                                                          |
|o10 = ideal (x , y )                                                         |
|                                                                             |
|o10 : Ideal of RP                                                            |
+-----------------------------------------------------------------------------+
|i11 : elapsedTime hilbertSamuelFunction(N, 0, 5) -- n+1 -- 0.02 seconds      |
| -- .0721732s elapsed                                                        |
|                                                                             |
|o11 = {1, 2, 3, 4, 5, 6}                                                     |
|                                                                             |
|o11 : List                                                                   |
+-----------------------------------------------------------------------------+
|i12 : elapsedTime hilbertSamuelFunction(q, N, 0, 5) -- 6(n+1) -- 0.32 seconds|
| -- .382311s elapsed                                                         |
|                                                                             |
|o12 = {6, 12, 18, 24, 30, 36}                                                |
|                                                                             |
|o12 : List                                                                   |
+-----------------------------------------------------------------------------+

Caveat
======

Hilbert-Samuel function with respect to a parameter ideal other than the
maximal ideal can be slower.

See also
========

  * length(Module) (Macaulay2Doc) -- compute the
    length of a module

Ways to use hilbertSamuelFunction:
==================================

  * "hilbertSamuelFunction(Ideal,Module,ZZ)"
  * "hilbertSamuelFunction(Ideal,Module,ZZ,ZZ)"
  * "hilbertSamuelFunction(Module,ZZ)"
  * "hilbertSamuelFunction(Module,ZZ,ZZ)"

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

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

-------------------------------------------------------------------------------

The source of this document is in LocalRings/doc.m2:371:0.

replacements for functions from version 1.0
*******************************************

This page describes the replacements for functions implemented in version 1.0
of this package by Mike Stillman and David Eisenbud. That version implemented
functionality for finding minimal generators, syzygies and resolutions for
polynomial rings localized at a maximal ideal.

Defining a local ring using setMaxIdeal, and
localRing,:

+-------------------------------------------------+
|i1 : S = ZZ/32003[x,y,z,w]                       |
|                                                 |
|o1 = S                                           |
|                                                 |
|o1 : PolynomialRing                              |
+-------------------------------------------------+
|i2 : P = ideal(x,y,z,w)                          |
|                                                 |
|o2 = ideal (x, y, z, w)                          |
|                                                 |
|o2 : Ideal of S                                  |
+-------------------------------------------------+
|i3 : setMaxIdeal P -- version 1.0                |
|                                                 |
|o3 = ideal (x, y, z, w)                          |
|                                                 |
|o3 : Ideal of S                                  |
+-------------------------------------------------+
|i4 : R = localRing(S, P) -- version 2.0 and above|
|                                                 |
|o4 = R                                           |
|                                                 |
|o4 : LocalRing, maximal ideal (x, y, z, w)       |
+-------------------------------------------------+

Computing syzygies using localsyz, and syz (Macaulay2Doc),:

+------------------------------------------+
|i5 : use S                                |
|                                          |
|o5 = S                                    |
|                                          |
|o5 : PolynomialRing                       |
+------------------------------------------+
|i6 : m = matrix{{x,y*z},{z*w,x}}          |
|                                          |
|o6 = | x  yz |                            |
|     | zw x  |                            |
|                                          |
|             2      2                     |
|o6 : Matrix S  <-- S                      |
+------------------------------------------+
|i7 : m * localsyz m                       |
|                                          |
|o7 = 0                                    |
|                                          |
|             2                            |
|o7 : Matrix S  <-- 0                      |
+------------------------------------------+
|i8 : use R                                |
|                                          |
|o8 = R                                    |
|                                          |
|o8 : LocalRing, maximal ideal (x, y, z, w)|
+------------------------------------------+
|i9 : m = matrix{{x,y*z},{z*w,x}}          |
|                                          |
|o9 = | x  yz |                            |
|     | zw x  |                            |
|                                          |
|             2      2                     |
|o9 : Matrix R  <-- R                      |
+------------------------------------------+
|i10 : m * syz m                           |
|                                          |
|o10 = 0                                   |
|                                          |
|              2                           |
|o10 : Matrix R  <-- 0                     |
+------------------------------------------+

Computing syzygies using localMingens, and mingens (Macaulay2Doc),:

+-----------------------------------------------+
|i11 : use S                                    |
|                                               |
|o11 = S                                        |
|                                               |
|o11 : PolynomialRing                           |
+-----------------------------------------------+
|i12 : localMingens matrix{{x-1,x,y},{x-1,x,y}} |
|                                               |
|o12 = | x-1 |                                  |
|      | x-1 |                                  |
|                                               |
|              2      1                         |
|o12 : Matrix S  <-- S                          |
+-----------------------------------------------+
|i13 : use R                                    |
|                                               |
|o13 = R                                        |
|                                               |
|o13 : LocalRing, maximal ideal (x, y, z, w)    |
+-----------------------------------------------+
|i14 : mingens image matrix{{x-1,x,y},{x-1,x,y}}|
|                                               |
|o14 = | x-1 |                                  |
|      | x-1 |                                  |
|                                               |
|              2      1                         |
|o14 : Matrix R  <-- R                          |
+-----------------------------------------------+

Computing syzygies using localModulo, and modulo (Macaulay2Doc),:

+---------------------------------------------------+
|i15 : use S                                        |
|                                                   |
|o15 = S                                            |
|                                                   |
|o15 : PolynomialRing                               |
+---------------------------------------------------+
|i16 : localModulo(matrix {{x-1,y}}, matrix {{y,z}})|
|                                                   |
|o16 = {1} | z y    0  |                            |
|      {1} | 0 -x+1 -1 |                            |
|                                                   |
|              2      3                             |
|o16 : Matrix S  <-- S                              |
+---------------------------------------------------+
|i17 : use R                                        |
|                                                   |
|o17 = R                                            |
|                                                   |
|o17 : LocalRing, maximal ideal (x, y, z, w)        |
+---------------------------------------------------+
|i18 : modulo(matrix {{x-1,y}}, matrix {{y,z}})     |
|                                                   |
|o18 = {1} | 0  y    z |                            |
|      {1} | -1 -x+1 0 |                            |
|                                                   |
|              2      3                             |
|o18 : Matrix R  <-- R                              |
+---------------------------------------------------+

Computing syzygies using localPrune, and prune (Macaulay2Doc),:

+--------------------------------------------------+
|i19 : use S                                       |
|                                                  |
|o19 = S                                           |
|                                                  |
|o19 : PolynomialRing                              |
+--------------------------------------------------+
|i20 : localPrune image matrix{{x-1,x,y},{x-1,x,y}}|
|                                                  |
|       1                                          |
|o20 = S                                           |
|                                                  |
|o20 : S-module, free, degrees {1}                 |
+--------------------------------------------------+
|i21 : use R                                       |
|                                                  |
|o21 = R                                           |
|                                                  |
|o21 : LocalRing, maximal ideal (x, y, z, w)       |
+--------------------------------------------------+
|i22 : prune image matrix{{x-1,x,y},{x-1,x,y}}     |
|                                                  |
|       1                                          |
|o22 = R                                           |
|                                                  |
|o22 : R-module, free, degrees {1}                 |
+--------------------------------------------------+

Computing syzygies using localResolution, and
freeResolution (Complexes),:

+---------------------------------------------------+
|i23 : use S                                        |
|                                                   |
|o23 = S                                            |
|                                                   |
|o23 : PolynomialRing                               |
+---------------------------------------------------+
|i24 : localResolution coker matrix{{x,y*z},{z*w,x}}|
|                                                   |
|       2      2                                    |
|o24 = S  <-- S  <-- 0                              |
|                                                   |
|      0      1      2                              |
|                                                   |
|o24 : ChainComplex                                 |
+---------------------------------------------------+
|i25 : oo.dd                                        |
|                                                   |
|           2                 2                     |
|o25 = 0 : S  <------------- S  : 1                 |
|                | yz x  |                          |
|                | x  zw |                          |
|                                                   |
|           2                                       |
|      1 : S  <----- 0 : 2                          |
|                0                                  |
|                                                   |
|o25 : ChainComplexMap                              |
+---------------------------------------------------+
|i26 : use R                                        |
|                                                   |
|o26 = R                                            |
|                                                   |
|o26 : LocalRing, maximal ideal (x, y, z, w)        |
+---------------------------------------------------+
|i27 : freeResolution coker matrix{{x,y*z},{z*w,x}} |
|                                                   |
|       2      2                                    |
|o27 = R  <-- R                                     |
|                                                   |
|      0      1                                     |
|                                                   |
|o27 : Complex                                      |
+---------------------------------------------------+
|i28 : oo.dd                                        |
|                                                   |
|           2                 2                     |
|o28 = 0 : R  <------------- R  : 1                 |
|                | yz x  |                          |
|                | x  zw |                          |
|                                                   |
|o28 : ComplexMap                                   |
+---------------------------------------------------+

-------------------------------------------------------------------------------

The source of this document is in LocalRings/doc.m2:133:0.

setMaxIdeal -- set the maximal ideal for local ring methods
***********************************************************

  * Usage:
        setMaxIdeal I
  * Inputs:
      * I, an ideal (Macaulay2Doc), a maximal ideal of the ring R
  * Outputs:
      * an ideal (Macaulay2Doc), same ideal as input

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

The function adds new structure to the ring which specifies a maximal ideal
which allows the user to employ local ring methods.
+---------------------------------------------------+
|i1 : R = ZZ/32003[x,y,z,w,SkewCommutative=>true]   |
|                                                   |
|o1 = R                                             |
|                                                   |
|o1 : PolynomialRing, 4 skew commutative variable(s)|
+---------------------------------------------------+
|i2 : setMaxIdeal(ideal(x,y,z,w))                   |
|                                                   |
|o2 = ideal (x, y, z, w)                            |
|                                                   |
|o2 : Ideal of R                                    |
+---------------------------------------------------+

See also
========

  * localComplement -- find the splitting of the target
    of a map
  * localsyz -- find syzygies
  * localMingens -- finds a minimal set of generators
  * localModulo -- find the pre-image (pullback) of image
    of a map over a local ring
  * localPrune -- find a minimal presentation
  * localResolution -- find a resolution over a local
    ring
  * residueMap -- The class of all local rings
  * maxIdeal -- The class of all local rings

Ways to use setMaxIdeal:
========================

  * "setMaxIdeal(Ideal)"

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

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

-------------------------------------------------------------------------------

The source of this document is in LocalRings/legacy.m2:156:0.

localComplement -- find the splitting of the target of a map
************************************************************

  * Usage:
        localComplement m
  * Inputs:
      * m, a matrix (Macaulay2Doc), representing a homomorphism
        of free modules over a local ring
  * Outputs:
      * a matrix (Macaulay2Doc), the complement of the image of
        the homomorphism represented by m

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

The function finds a splitting of the target of m as a direct sum of the image
of m and the image of the output.
+------------------------------+
|i1 : R = ZZ/32003[x,y]        |
|                              |
|o1 = R                        |
|                              |
|o1 : PolynomialRing           |
+------------------------------+
|i2 : m = matrix{{x,y-1},{0,x}}|
|                              |
|o2 = | x y-1 |                |
|     | 0 x   |                |
|                              |
|             2      2         |
|o2 : Matrix R  <-- R          |
+------------------------------+
|i3 : setMaxIdeal(ideal(x,y))  |
|                              |
|o3 = ideal (x, y)             |
|                              |
|o3 : Ideal of R               |
+------------------------------+
|i4 : localComplement m        |
|                              |
|o4 = | 0 |                    |
|     | 1 |                    |
|                              |
|             2      1         |
|o4 : Matrix R  <-- R          |
+------------------------------+

See also
========

  * setMaxIdeal -- set the maximal ideal for local ring
    methods
  * localsyz -- find syzygies
  * localMingens -- finds a minimal set of generators
  * localModulo -- find the pre-image (pullback) of image
    of a map over a local ring
  * localPrune -- find a minimal presentation
  * localResolution -- find a resolution over a local
    ring
  * residueMap -- The class of all local rings
  * maxIdeal -- The class of all local rings

Ways to use localComplement:
============================

  * "localComplement(Matrix)"

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

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

-------------------------------------------------------------------------------

The source of this document is in LocalRings/legacy.m2:177:0.

localsyz -- find syzygies
*************************

  * Usage:
        localsyz m
  * Inputs:
      * m, a matrix (Macaulay2Doc),
  * Outputs:
      * a matrix (Macaulay2Doc), giving minimal generators of the
        syzygies taking into account the local structure

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

+---------------------------------------------------+
|i1 : R = ZZ/32003[x,y,z,w,SkewCommutative=>true]   |
|                                                   |
|o1 = R                                             |
|                                                   |
|o1 : PolynomialRing, 4 skew commutative variable(s)|
+---------------------------------------------------+
|i2 : m = matrix{{x,y*z},{z*w,x}}                   |
|                                                   |
|o2 = | x  yz |                                     |
|     | zw x  |                                     |
|                                                   |
|             2      2                              |
|o2 : Matrix R  <-- R                               |
+---------------------------------------------------+
|i3 : setMaxIdeal(ideal(x,y,z,w))                   |
|                                                   |
|o3 = ideal (x, y, z, w)                            |
|                                                   |
|o3 : Ideal of R                                    |
+---------------------------------------------------+
|i4 : localsyz m                                    |
|                                                   |
|o4 = {2} | -yz -x |                                |
|     {2} | x   zw |                                |
|                                                   |
|             2      2                              |
|o4 : Matrix R  <-- R                               |
+---------------------------------------------------+
|i5 : m * localsyz m                                |
|                                                   |
|o5 = 0                                             |
|                                                   |
|             2      2                              |
|o5 : Matrix R  <-- R                               |
+---------------------------------------------------+

See also
========

  * setMaxIdeal -- set the maximal ideal for local ring
    methods
  * localComplement -- find the splitting of the target
    of a map
  * localMingens -- finds a minimal set of generators
  * localModulo -- find the pre-image (pullback) of image
    of a map over a local ring
  * localPrune -- find a minimal presentation
  * localResolution -- find a resolution over a local
    ring
  * residueMap -- The class of all local rings
  * maxIdeal -- The class of all local rings

Ways to use localsyz:
=====================

  * "localsyz(Matrix)"

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

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

-------------------------------------------------------------------------------

The source of this document is in LocalRings/legacy.m2:198:0.

localMingens -- finds a minimal set of generators
*************************************************

  * Usage:
        localMingens m
  * Inputs:
      * m, a matrix (Macaulay2Doc),
  * Outputs:
      * a matrix (Macaulay2Doc), the matrix of minimal generators

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

We get a minimal set for the homogeneous case, but not necessarily otherwise.
+----------------------------------------------+
|i1 : R=QQ[a,b]                                |
|                                              |
|o1 = R                                        |
|                                              |
|o1 : PolynomialRing                           |
+----------------------------------------------+
|i2 : setMaxIdeal ideal gens R                 |
|                                              |
|o2 = ideal (a, b)                             |
|                                              |
|o2 : Ideal of R                               |
+----------------------------------------------+
|i3 : mingens image matrix{{a-1,a,b},{a-1,a,b}}|
|                                              |
|o3 = | 1 b a-1 |                              |
|     | 1 b a-1 |                              |
|                                              |
|             2      3                         |
|o3 : Matrix R  <-- R                          |
+----------------------------------------------+
|i4 : localMingens matrix {{a-1,a,b},{a-1,a,b}}|
|                                              |
|o4 = | a-1 |                                  |
|     | a-1 |                                  |
|                                              |
|             2      1                         |
|o4 : Matrix R  <-- R                          |
+----------------------------------------------+

See also
========

  * setMaxIdeal -- set the maximal ideal for local ring
    methods
  * localComplement -- find the splitting of the target
    of a map
  * localsyz -- find syzygies
  * localModulo -- find the pre-image (pullback) of image
    of a map over a local ring
  * localPrune -- find a minimal presentation
  * localResolution -- find a resolution over a local
    ring
  * residueMap -- The class of all local rings
  * maxIdeal -- The class of all local rings

Ways to use localMingens:
=========================

  * "localMingens(Matrix)"

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

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

-------------------------------------------------------------------------------

The source of this document is in LocalRings/legacy.m2:219:0.

localModulo -- find the pre-image (pullback) of image of a map over a local ring
********************************************************************************

  * Usage:
        localModulo(m,n)
  * Inputs:
      * m, a matrix (Macaulay2Doc),
      * n, a matrix (Macaulay2Doc),
  * Outputs:
      * a matrix (Macaulay2Doc), whose image is the pre-image
        (pullback) of the image of n under m

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

The maps m and n must have the same target, and their sources and targets must
be free. If m is null, then it is taken to be the identity. If n is null, it is
taken to be zero.
+-----------------------------+
|i1 : R = QQ[x,y,z]           |
|                             |
|o1 = R                       |
|                             |
|o1 : PolynomialRing          |
+-----------------------------+
|i2 : setMaxIdeal ideal vars R|
|                             |
|o2 = ideal (x, y, z)         |
|                             |
|o2 : Ideal of R              |
+-----------------------------+
|i3 : m = matrix {{x-1, y}}   |
|                             |
|o3 = | x-1 y |               |
|                             |
|             1      2        |
|o3 : Matrix R  <-- R         |
+-----------------------------+
|i4 : n = matrix {{y,z}}      |
|                             |
|o4 = | y z |                 |
|                             |
|             1      2        |
|o4 : Matrix R  <-- R         |
+-----------------------------+
|i5 : modulo (m,n)            |
|                             |
|o5 = {1} | 0  z 0 y    |     |
|     {1} | -1 0 z -x+1 |     |
|                             |
|             2      4        |
|o5 : Matrix R  <-- R         |
+-----------------------------+
|i6 : localModulo (m,n)       |
|                             |
|o6 = {1} | z y    0  |       |
|     {1} | 0 -x+1 -1 |       |
|                             |
|             2      3        |
|o6 : Matrix R  <-- R         |
+-----------------------------+

See also
========

  * setMaxIdeal -- set the maximal ideal for local ring
    methods
  * localComplement -- find the splitting of the target
    of a map
  * localsyz -- find syzygies
  * localMingens -- finds a minimal set of generators
  * localPrune -- find a minimal presentation
  * localResolution -- find a resolution over a local
    ring
  * residueMap -- The class of all local rings
  * maxIdeal -- The class of all local rings

Ways to use localModulo:
========================

  * "localModulo(Matrix,Matrix)"

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

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

-------------------------------------------------------------------------------

The source of this document is in LocalRings/legacy.m2:243:0.

localPrune -- find a minimal presentation
*****************************************

  * Usage:
        localPrune M
  * Inputs:
      * M, a module (Macaulay2Doc),
  * Outputs:
      * a module (Macaulay2Doc),

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

The output is a minimal presentation of the input.
+------------------------------------+
|i1 : R=QQ[a,b]                      |
|                                    |
|o1 = R                              |
|                                    |
|o1 : PolynomialRing                 |
+------------------------------------+
|i2 : setMaxIdeal ideal gens R       |
|                                    |
|o2 = ideal (a, b)                   |
|                                    |
|o2 : Ideal of R                     |
+------------------------------------+
|i3 : m = matrix{{a-1,a,b},{a-1,a,b}}|
|                                    |
|o3 = | a-1 a b |                    |
|     | a-1 a b |                    |
|                                    |
|             2      3               |
|o3 : Matrix R  <-- R                |
+------------------------------------+
|i4 : prune m                        |
|                                    |
|o4 = | a-1 a b |                    |
|     | a-1 a b |                    |
|                                    |
|             2      3               |
|o4 : Matrix R  <-- R                |
+------------------------------------+
|i5 : localPrune image m             |
|                                    |
|      1                             |
|o5 = R                              |
|                                    |
|o5 : R-module, free, degrees {1}    |
+------------------------------------+

See also
========

  * setMaxIdeal -- set the maximal ideal for local ring
    methods
  * localComplement -- find the splitting of the target
    of a map
  * localsyz -- find syzygies
  * localMingens -- finds a minimal set of generators
  * localModulo -- find the pre-image (pullback) of image
    of a map over a local ring
  * localResolution -- find a resolution over a local
    ring
  * residueMap -- The class of all local rings
  * maxIdeal -- The class of all local rings

Ways to use localPrune:
=======================

  * "localPrune(Module)"

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

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

-------------------------------------------------------------------------------

The source of this document is in LocalRings/legacy.m2:265:0.

localResolution -- find a resolution over a local ring
******************************************************

  * Usage:
        localResolution M
  * Inputs:
      * M, a module (Macaulay2Doc),
      *  or
      * an ideal (Macaulay2Doc),
      * Strategy, see freeResolution(...,Strategy=>...) (Complexes),
      * SyzygyLimit, see freeResolution(...,SyzygyLimit=>...) (Complexes),
      * HardDegreeLimit, see freeResolution(...,HardDegreeLimit=>...) (Complexes),
      * LengthLimit, see freeResolution(...,LengthLimit=>...) (Complexes),
      * StopBeforeComputation, see
        freeResolution(...,StopBeforeComputation=>...) (Complexes),
      * DegreeLimit, see freeResolution(...,DegreeLimit=>...) (Complexes),
      * ParallelizeByDegree, see
        freeResolution(...,ParallelizeByDegree=>...) (Complexes),
      * SortStrategy, see freeResolution(...,SortStrategy=>...) (Complexes),
      * PairLimit, see freeResolution(...,PairLimit=>...) (Complexes),
  * Optional inputs (Macaulay2Doc),:
      * DegreeLimit => ..., default value infinity
      * HardDegreeLimit => ..., default value {}
      * LengthLimit => ..., default value infinity
      * PairLimit => ..., default value infinity
      * ParallelizeByDegree => ..., default value false
      * SortStrategy => ..., default value 0
      * StopBeforeComputation => ..., default value false
      * Strategy => ..., default value null
      * SyzygyLimit => ..., default value infinity
  * Outputs:
      * a chain complex (OldChainComplexes),

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

This method has option inputs that it inherits from

See freeResolution (Complexes).

This function iterates

See localsyz, to obtain a resolution over the local ring.
+-----------------------------------------------------------------------------+
|i1 : R = ZZ/32003[x,y,z,w,SkewCommutative=>true]                             |
|                                                                             |
|o1 = R                                                                       |
|                                                                             |
|o1 : PolynomialRing, 4 skew commutative variable(s)                          |
+-----------------------------------------------------------------------------+
|i2 : m = matrix{{x,y*z},{z*w,x}}                                             |
|                                                                             |
|o2 = | x  yz |                                                               |
|     | zw x  |                                                               |
|                                                                             |
|             2      2                                                        |
|o2 : Matrix R  <-- R                                                         |
+-----------------------------------------------------------------------------+
|i3 : setMaxIdeal(ideal(x,y,z,w))                                             |
|                                                                             |
|o3 = ideal (x, y, z, w)                                                      |
|                                                                             |
|o3 : Ideal of R                                                              |
+-----------------------------------------------------------------------------+
|i4 : C = localResolution(coker m, LengthLimit=>10)                           |
|                                                                             |
|      2      2      2      2      2      2      2      2      2      2      2|
|o4 = R  <-- R  <-- R  <-- R  <-- R  <-- R  <-- R  <-- R  <-- R  <-- R  <-- R |
|                                                                             |
|     0      1      2      3      4      5      6      7      8      9      10|
|                                                                             |
|o4 : ChainComplex                                                            |
+-----------------------------------------------------------------------------+
|i5 : C = localResolution(coker m)                                            |
|                                                                             |
|      2      2      2      2      2      2      2      2      2      2      2|
|o5 = R  <-- R  <-- R  <-- R  <-- R  <-- R  <-- R  <-- R  <-- R  <-- R  <-- R |
|                                                                             |
|     0      1      2      3      4      5      6      7      8      9      10|
|                                                                             |
|o5 : ChainComplex                                                            |
+-----------------------------------------------------------------------------+
|i6 : C^2                                                                     |
|                                                                             |
|o6 = 0                                                                       |
|                                                                             |
|o6 : R-module                                                                |
+-----------------------------------------------------------------------------+
|i7 : C.dd_4                                                                  |
|                                                                             |
|o7 = {6} | -zw x  |                                                          |
|     {6} | -x  yz |                                                          |
|                                                                             |
|             2      2                                                        |
|o7 : Matrix R  <-- R                                                         |
+-----------------------------------------------------------------------------+
+----------------------------------------------+
|i8 : R = QQ[x,y,z]                            |
|                                              |
|o8 = R                                        |
|                                              |
|o8 : PolynomialRing                           |
+----------------------------------------------+
|i9 : setMaxIdeal ideal vars R                 |
|                                              |
|o9 = ideal (x, y, z)                          |
|                                              |
|o9 : Ideal of R                               |
+----------------------------------------------+
|i10 : m = matrix {{x-1, y, z-1}}              |
|                                              |
|o10 = | x-1 y z-1 |                           |
|                                              |
|              1      3                        |
|o10 : Matrix R  <-- R                         |
+----------------------------------------------+
|i11 : C = resolution coker m                  |
|                                              |
|       1      3      3      1                 |
|o11 = R  <-- R  <-- R  <-- R  <-- 0           |
|                                              |
|      0      1      2      3      4           |
|                                              |
|o11 : ChainComplex                            |
+----------------------------------------------+
|i12 : C.dd                                    |
|                                              |
|           1                     3            |
|o12 = 0 : R  <----------------- R  : 1        |
|                | x-1 y z-1 |                 |
|                                              |
|           3                             3    |
|      1 : R  <------------------------- R  : 2|
|                {1} | -y  -z+1 0    |         |
|                {1} | x-1 0    -z+1 |         |
|                {1} | 0   x-1  y    |         |
|                                              |
|           3                   1              |
|      2 : R  <--------------- R  : 3          |
|                {2} | z-1 |                   |
|                {2} | -y  |                   |
|                {2} | x-1 |                   |
|                                              |
|           1                                  |
|      3 : R  <----- 0 : 4                     |
|                0                             |
|                                              |
|o12 : ChainComplexMap                         |
+----------------------------------------------+
|i13 : LC = localResolution coker m            |
|                                              |
|       1      3      2                        |
|o13 = R  <-- R  <-- R  <-- 0                  |
|                                              |
|      0      1      2      3                  |
|                                              |
|o13 : ChainComplex                            |
+----------------------------------------------+
|i14 : LC.dd                                   |
|                                              |
|           1                     3            |
|o14 = 0 : R  <----------------- R  : 1        |
|                | z-1 y x-1 |                 |
|                                              |
|           3                         2        |
|      1 : R  <--------------------- R  : 2    |
|                {1} | -x+1 y    |             |
|                {1} | 0    -z+1 |             |
|                {1} | z-1  0    |             |
|                                              |
|           2                                  |
|      2 : R  <----- 0 : 3                     |
|                0                             |
|                                              |
|o14 : ChainComplexMap                         |
+----------------------------------------------+

See also
========

  * setMaxIdeal -- set the maximal ideal for local ring
    methods
  * localComplement -- find the splitting of the target
    of a map
  * localsyz -- find syzygies
  * localMingens -- finds a minimal set of generators
  * localModulo -- find the pre-image (pullback) of image
    of a map over a local ring
  * localPrune -- find a minimal presentation
  * residueMap -- The class of all local rings
  * maxIdeal -- The class of all local rings

Ways to use localResolution:
============================

  * "localResolution(Ideal)"
  * "localResolution(Module)"

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

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

-------------------------------------------------------------------------------

The source of this document is in LocalRings/legacy.m2:300:0.