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

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 = res I                    |
|                                  |
|      1      4      4      1      |
|o7 = R  <-- R  <-- R  <-- R  <-- 0|
|                                  |
|     0      1      2      3      4|
|                                  |
|o7 : ChainComplex                 |
+----------------------------------+
|i8 : D = C ** RM;                 |
+----------------------------------+
|i9 : E = pruneComplex D           |
|                                  |
|       1       4       4       1  |
|o9 = RM  <-- RM  <-- RM  <-- RM   |
|                                  |
|     0       1       2       3    |
|                                  |
|o9 : ChainComplex                 |
+----------------------------------+

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 : ChainComplex        |
+--------------------------+

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), resolution (Macaulay2Doc),
mingens (Macaulay2Doc), minimalPresentation (Macaulay2Doc),
see trim (Macaulay2Doc),
length(Module) (Macaulay2Doc), isSubset (Macaulay2Doc),
see inducedMap (Macaulay2Doc),
quotient(Matrix,Matrix) (Macaulay2Doc),
remainder(Matrix,Matrix) (Macaulay2Doc),
quotient(Module,Module) (Saturation),
saturate (Saturation), 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),
see kernel (Macaulay2Doc),
cokernel (Macaulay2Doc), image (Macaulay2Doc),
homology (Macaulay2Doc), Hom (Macaulay2Doc), Ext (Macaulay2Doc),
see 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.

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

The source code from which this documentation is derived is in the file
LocalRings.m2 (see common/share/Macaulay2/LocalRings.m2 ). The auxiliary files
accompanying it are in the directory LocalRings/ (see
common/share/Macaulay2/LocalRings/ ).

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

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) -- Computes 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) -- computes 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).

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

Synopsis
========

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

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

Synopsis
========

  * 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 = res 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).

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

Synopsis
========

  * Function: baseRing (Macaulay2Doc),

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

See baseRing(Ring) (Macaulay2Doc),

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

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

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

Synopsis
========

  * Function: char (Macaulay2Doc),

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

See char(Ring) (Macaulay2Doc),

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

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

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

Synopsis
========

  * Function: coefficientRing (Macaulay2Doc),

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

See coefficientRing(Ring) (Macaulay2Doc),

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

  * coefficientRing(LocalRing) -- get
    the coefficient ring

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

Synopsis
========

  * Function: degreeLength (Macaulay2Doc),

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

See degreeLength(Ring) (Macaulay2Doc),

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

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

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

Synopsis
========

  * Function: degrees (Macaulay2Doc),

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

See degrees(Ring) (Macaulay2Doc),

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

  * degrees(LocalRing) -- degrees of generators

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

Synopsis
========

  * Function: dim (Macaulay2Doc),

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

See dim(Ring) (Macaulay2Doc),

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

  * dim(LocalRing) -- compute the Krull dimension

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

Synopsis
========

  * Function: frac (Macaulay2Doc),

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

See frac(Ring) (Macaulay2Doc),

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

  * frac(LocalRing) -- construct a fraction field

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

Synopsis
========

  * Function: generators (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * CoefficientRing (Macaulay2Doc), => ...,
        default value null, null

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

See generators(Ring) (Macaulay2Doc),

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

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

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

Synopsis
========

  * Function: isCommutative (Macaulay2Doc),

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

See isCommutative(Ring) (Macaulay2Doc),

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

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

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

Synopsis
========

  * 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

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

Synopsis
========

  * Function: numgens (Macaulay2Doc),

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

See numgens(Ring) (Macaulay2Doc),

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

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

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

Synopsis
========

  * 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)      |
| -- 0.318195 seconds 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      |
| -- 0.0251189 seconds elapsed                                                |
|                                                                             |
|o11 = {1, 2, 3, 4, 5, 6}                                                     |
|                                                                             |
|o11 : List                                                                   |
+-----------------------------------------------------------------------------+
|i12 : elapsedTime hilbertSamuelFunction(q, N, 0, 5) -- 6(n+1) -- 0.32 seconds|
| -- 0.343035 seconds 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) -- Computes 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).

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
resolution (Macaulay2Doc),:

+---------------------------------------------------+
|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 : res coker matrix{{x,y*z},{z*w,x}}            |
|                                                   |
|       2      2                                    |
|o27 = R  <-- R                                     |
|                                                   |
|      0      1                                     |
|                                                   |
|o27 : ChainComplex                                 |
+---------------------------------------------------+
|i28 : oo.dd                                        |
|                                                   |
|           2                 2                     |
|o28 = 0 : R  <------------- R  : 1                 |
|                | yz x  |                          |
|                | x  zw |                          |
|                                                   |
|o28 : ChainComplexMap                              |
+---------------------------------------------------+

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

Synopsis
========

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

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

Synopsis
========

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

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

Synopsis
========

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

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

Synopsis
========

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

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

Synopsis
========

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

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

Synopsis
========

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

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

Synopsis
========

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

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

This method has option inputs that it inherits from

See resolution (Macaulay2Doc).

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