This is AnalyzeSheafOnP1.info, produced by Macaulay2, version 1.20

AnalyzeSheafOnP1 -- Describe a graded module over k[x,y] without 0-dimensional torsion
**************************************************************************************

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

Any sheaf on P1 is the direct sum of line bundles-- and cyclic skyscraper
sheaves represented by modules of the form k[x,y]/(l^m) where l is an
kirreducible homogeneous polynomial and m is a non-negative integer. The
routine "analyze" computes the twists and the annihilators l^m that appear in
the decomposition, starting from a coherent sheaf on P1 or a graded module over
a polynomial ring on 2 variables.

+-----------------------------------------------------------------------+
|i1 : k = ZZ/5                                                          |
|                                                                       |
|o1 = k                                                                 |
|                                                                       |
|o1 : QuotientRing                                                      |
+-----------------------------------------------------------------------+
|i2 : S = k[a,b]                                                        |
|                                                                       |
|o2 = S                                                                 |
|                                                                       |
|o2 : PolynomialRing                                                    |
+-----------------------------------------------------------------------+
|i3 : M = S^1/ideal(a^3)++S^{-1}/(ideal b^2)++S^1/(ideal b^2)++ S^{-1,1}|
|                                                                       |
|o3 = cokernel {0}  | a3 0  0  |                                        |
|              {1}  | 0  b2 0  |                                        |
|              {0}  | 0  0  b2 |                                        |
|              {1}  | 0  0  0  |                                        |
|              {-1} | 0  0  0  |                                        |
|                                                                       |
|                            5                                          |
|o3 : S-module, quotient of S                                           |
+-----------------------------------------------------------------------+
|i4 : L = analyze M;                                                    |
+-----------------------------------------------------------------------+
|i5 : twists = L_0                                                      |
|                                                                       |
|o5 = {1, -1}                                                           |
|                                                                       |
|o5 : List                                                              |
+-----------------------------------------------------------------------+
|i6 : anns = L_1                                                        |
|                                                                       |
|         3   2   2                                                     |
|o6 = {-2a , b , b }                                                    |
|                                                                       |
|o6 : List                                                              |
+-----------------------------------------------------------------------+
|i7 : analyze sheaf M                                                   |
|                                                                       |
|                 3   2   2                                             |
|o7 = {{1, -1}, {a , b , b }, {1}  | 0 0 0 1 0 |, | a3 0  0  |}         |
|                             {-1} | 0 0 0 0 1 |  | 0  b2 0  |          |
|                                                 | 0  0  b2 |          |
|                                                                       |
|o7 : List                                                              |
+-----------------------------------------------------------------------+

Caveat
======

The script uses a linear nonzerodivisor, which would not exist over a finite
field in the case where every point of P1 is the support of one of the
skyscraper components.

Author
======

  * David Eisenbud (see http://www.msri.org/~de ) <de@msri.org>

Version
=======

This documentation describes version 0.1 of AnalyzeSheafOnP1.

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

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

Exports
=======

  * Functions and commands
      * analyze -- Compute the decomposition of a sheaf on P1
      * doubleDualMap -- map from a module to its double
        dual
      * isNZD -- tests whether a ring element is a non
        zerodivisor on a module
      * killH0 -- removes 0-dimensional torsion
      * showSheafOnP1 -- Prints the analysis of a sheaf
        on P1
  * Methods
      * "analyze(CoherentSheaf)" -- see analyze, -- Compute the
        decomposition of a sheaf on P1
      * "analyze(Module)" -- see analyze, -- Compute the
        decomposition of a sheaf on P1
      * "doubleDualMap(Module)" -- see doubleDualMap, --
        map from a module to its double dual
      * "isNZD(RingElement,Module)" -- see isNZD, -- tests whether
        a ring element is a non zerodivisor on a module
      * "killH0(Module)" -- see killH0, -- removes 0-dimensional
        torsion
      * "showSheafOnP1(CoherentSheaf)" -- see showSheafOnP1,
        -- Prints the analysis of a sheaf on P1
      * "showSheafOnP1(Module)" -- see showSheafOnP1, --
        Prints the analysis of a sheaf on P1

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

The object AnalyzeSheafOnP1, is a package (Macaulay2Doc).

analyze -- Compute the decomposition of a sheaf on P1
*****************************************************

Synopsis
========

  * Usage:
        L=analyze M
  * Inputs:
      * M, a module (Macaulay2Doc),
      * M, a coherent sheaf (Macaulay2Doc),
  * Outputs:
      * L, a list (Macaulay2Doc), L_0 = map from M to double dual
        of M, L_1 is the smith normal form pres of the torsion of M

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

The routine decomposes the sheaf associated to M into a direct of twists of the
structure sheaf and cycle torsion part modules. It returns a list L ={freegens,
anns, e, D} where:

freegens is the list of the twists;

anns is the list of annihilators;

e is the map from M' to its double dual, where M' = is the result of reducing M
mod 0-dimensional torsion, if necessary;

D is a presentation of the torsion part in the appropriate version of Smith
normal form.

To compute this Smith normal form, we dehomogenize with respect to a linear
form that is a nonzerodivisor on M', use the routine smithNormalForm, and then
rehomogenize. To find this nonzerodivisor we try first the first variable, then
the second, then up to 100 random choices

The routine returns an error if the base ring is not a polynomial ring in 2
variables over a field or if after 100 tries it finds no linear form that is a
nonzerodivisor on the module.

+--------------------------------------------------------------+
|i1 : setRandomSeed 0                                          |
|                                                              |
|o1 = 0                                                        |
+--------------------------------------------------------------+
|i2 : S = ZZ/101[a,b]                                          |
|                                                              |
|o2 = S                                                        |
|                                                              |
|o2 : PolynomialRing                                           |
+--------------------------------------------------------------+
|i3 : mm = ideal vars S                                        |
|                                                              |
|o3 = ideal (a, b)                                             |
|                                                              |
|o3 : Ideal of S                                               |
+--------------------------------------------------------------+
|i4 : M0 = mm^3*S^{3} ++ S^{-1};                               |
+--------------------------------------------------------------+
|i5 : M1 =S^1/ideal(a^3)++S^{-1}/(ideal b^2)++S^1/(ideal b^2) ;|
+--------------------------------------------------------------+
|i6 : M = M0++M1;                                              |
+--------------------------------------------------------------+
|i7 : L = analyze M0;                                          |
+--------------------------------------------------------------+
|i8 : freegens = L_0                                           |
|                                                              |
|o8 = {1, -3}                                                  |
|                                                              |
|o8 : List                                                     |
+--------------------------------------------------------------+
|i9 : anns = L_1                                               |
|                                                              |
|o9 = {}                                                       |
|                                                              |
|o9 : List                                                     |
+--------------------------------------------------------------+
|i10 : e = L_2                                                 |
|                                                              |
|o10 = {1}  | 0  0   0   0  1 |                                |
|      {-3} | a3 a2b ab2 b3 0 |                                |
|                                                              |
|o10 : Matrix                                                  |
+--------------------------------------------------------------+
|i11 : D = L_3                                                 |
|                                                              |
|o11 = 0                                                       |
|                                                              |
|o11 : Matrix 0 <--- 0                                         |
+--------------------------------------------------------------+

See also
========

  * doubleDualMap -- map from a module to its double dual
  * showSheafOnP1 -- Prints the analysis of a sheaf on P1

Ways to use analyze :
=====================

  * "analyze(CoherentSheaf)"
  * "analyze(Module)"

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

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

doubleDualMap -- map from a module to its double dual
*****************************************************

Synopsis
========

  * Usage:
        e = doubleDualMap M
  * Inputs:
      * M, a module (Macaulay2Doc),
  * Outputs:
      * e, a matrix (Macaulay2Doc), map from M to double dual

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

provide the natural map M --> Hom(Hom(M,S),S), where S = ring M.

Ways to use doubleDualMap :
===========================

  * "doubleDualMap(Module)"

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

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

isNZD -- tests whether a ring element is a non zerodivisor on a module
**********************************************************************

Synopsis
========

  * Usage:
        t = isNZD(X,M)
  * Inputs:
      * X, a ring element (Macaulay2Doc),
      * M, a module (Macaulay2Doc),
  * Outputs:
      * t, a Boolean value (Macaulay2Doc),

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

returns true if "0 == ker (X*id_M)"

Ways to use isNZD :
===================

  * "isNZD(RingElement,Module)"

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

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

killH0 -- removes 0-dimensional torsion
***************************************

Synopsis
========

  * Usage:
        M' = killH0 M
  * Inputs:
      * M, a module (Macaulay2Doc),
  * Outputs:
      * M', a module (Macaulay2Doc),

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

"M' = M/(saturate 0_M)"

Ways to use killH0 :
====================

  * "killH0(Module)"

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

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

showSheafOnP1 -- Prints the analysis of a sheaf on P1
*****************************************************

Synopsis
========

  * Usage:
        showSheafOnP1 M
  * Inputs:
      * M, a module (Macaulay2Doc),
      * M, a coherent sheaf (Macaulay2Doc),

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

prints out the twists of the line bundle summands and the annihilators of the
(cyclic) torsion components.

See also
========

  * AnalyzeSheafOnP1 -- Describe a graded module over k[x,y]
    without 0-dimensional torsion

Ways to use showSheafOnP1 :
===========================

  * "showSheafOnP1(CoherentSheaf)"
  * "showSheafOnP1(Module)"

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

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