This is FiniteFittingIdeals.info, produced by Macaulay2, version 1.24.11

FiniteFittingIdeals -- Computing Fitting ideals and Quot schemes of points
**************************************************************************

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

This package implements an algorithm for computing Fitting ideals of finite
modules from the paper Gotzmann's persistence theorem for finite modules
arXiv:1411.7940 (see http://arxiv.org/abs/1411.7940 ) by Gustav Sædén Ståhl.

The following is an example illustrating the main functions provided in the
package.
  * Fitting ideals of finite modules

Author
======

  * Gustav Sædén Ståhl (see http://www.math.kth.se/~gss ) <gss@math.kth.se>

Version
=======

This documentation describes version 1.0 of FiniteFittingIdeals.

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

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

Exports
=======

  * Functions and commands
      * affinePart -- Replaces columns in a matrix with an
        identity matrix
      * co1Fitting -- Calculates the (n-1)'th Fitting ideal
        of a finite module
      * gaussCol -- Makes column reductions of a matrix
      * gotzmannTest -- Checks if a set of monomials is a
        Gotzmann set
      * nextDegree -- Lifts the kernel to the next degree
      * quotScheme -- Calculates the defining equations for
        Quot schemes of points
  * Methods
      * "affinePart(Matrix,List)" -- see affinePart, --
        Replaces columns in a matrix with an identity matrix
      * "affinePart(Matrix,ZZ)" -- see affinePart, --
        Replaces columns in a matrix with an identity matrix
      * "co1Fitting(Matrix)" -- see co1Fitting, -- Calculates
        the (n-1)'th Fitting ideal of a finite module
      * "co1Fitting(Module)" -- see co1Fitting, -- Calculates
        the (n-1)'th Fitting ideal of a finite module
      * "gaussCol(Matrix)" -- see gaussCol, -- Makes column
        reductions of a matrix
      * "gaussCol(MutableMatrix)" -- see gaussCol, -- Makes
        column reductions of a matrix
      * "gotzmannTest(List,RingElement)" -- see gotzmannTest,
        -- Checks if a set of monomials is a Gotzmann set
      * "gotzmannTest(Module,ZZ,List)" -- see gotzmannTest,
        -- Checks if a set of monomials is a Gotzmann set
      * "nextDegree(Matrix,ZZ,Ring)" -- see nextDegree, --
        Lifts the kernel to the next degree
      * "nextDegree(Module,ZZ,Ring)" -- see nextDegree, --
        Lifts the kernel to the next degree
      * "quotScheme(Module,ZZ,List)" -- see quotScheme, --
        Calculates the defining equations for Quot schemes of points

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

The object FiniteFittingIdeals, is a package (Macaulay2Doc).

affinePart -- Replaces columns in a matrix with an identity matrix
******************************************************************

Synopsis
========

  * Usage:
        affinePart(M,L)
        affinePart(M,n)
  * Inputs:
      * M, a matrix (Macaulay2Doc),
      * L, a list (Macaulay2Doc),
      * n, an integer (Macaulay2Doc),
  * Outputs:
      * a matrix (Macaulay2Doc),

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

Given an n\times m matrix M, with n<m, and a subset L\subseteq\{0,\dots,m-1\}\
of size n, this function replaces the columns with index L by an identity
matrix.

+------------------------------------------------+
|i1 : S=ZZ[a_1..a_8];                            |
+------------------------------------------------+
|i2 : M=matrix{toList(a_1..a_4),toList(a_5..a_8)}|
|                                                |
|o2 = | a_1 a_2 a_3 a_4 |                        |
|     | a_5 a_6 a_7 a_8 |                        |
|                                                |
|             2      4                           |
|o2 : Matrix S  <-- S                            |
+------------------------------------------------+
|i3 : affinePart(M,{0,2})                        |
|                                                |
|o3 = | 1 a_2 0 a_4 |                            |
|     | 0 a_6 1 a_8 |                            |
|                                                |
|             2      4                           |
|o3 : Matrix S  <-- S                            |
+------------------------------------------------+

See also
========

  * nextDegree -- Lifts the kernel to the next degree

Ways to use affinePart:
=======================

  * "affinePart(Matrix,List)"
  * "affinePart(Matrix,ZZ)"

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

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

co1Fitting -- Calculates the (n-1)'th Fitting ideal of a finite module
**********************************************************************

Synopsis
========

  * Usage:
        co1Fitting Q
  * Inputs:
      * Q, a matrix (Macaulay2Doc),
      * Q, a module (Macaulay2Doc),
  * Outputs:
      * an ideal (Macaulay2Doc),

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

Let S be a polynomial ring and consider a quotient Q=S^p/N where N is a
submodule generated in degrees at most d. If the graded component Q_d is free
of rank n, then N_d is free as well, and N_d\otimes S_1 \to S^p_{d+1} \to
Q_{d+1}\to 0 gives a free resolution of Q_{d+1}. Let K be the matrix
corresponding to the map  N_d\otimes S_1\to S^p_{d+1}. The function co1Fitting
calculates the (n-1)'th Fitting ideal of Q_{d+1} assuming that the basis of Q_d
was given by a Gotzmann set.

+----------------------------------------+
|i1 : S=ZZ[x_0,x_1];                     |
+----------------------------------------+
|i2 : R=S[a_1..a_4];                     |
+----------------------------------------+
|i3 : K=gens ker matrix{{1,a_2,a_3,a_4}} |
|                                        |
|o3 = {0, 0} | a_2 a_3 a_4 |             |
|     {1, 0} | -1  0   0   |             |
|     {1, 0} | 0   -1  0   |             |
|     {1, 0} | 0   0   -1  |             |
|                                        |
|             4      3                   |
|o3 : Matrix R  <-- R                    |
+----------------------------------------+
|i4 : K2=nextDegree(K,1,S)               |
|                                        |
|o4 = {-1, 0} | a_2 0   a_3 0   a_4 0   ||
|     {-1, 0} | -1  a_2 0   a_3 0   a_4 ||
|     {0, 0}  | 0   -1  0   0   0   0   ||
|     {0, 0}  | 0   0   -1  0   0   0   ||
|     {0, 0}  | 0   0   0   -1  -1  0   ||
|     {0, 0}  | 0   0   0   0   0   -1  ||
|                                        |
|             6      6                   |
|o4 : Matrix R  <-- R                    |
+----------------------------------------+
|i5 : co1Fitting(K2)                     |
|                                        |
|o5 = ideal(a a  - a )                   |
|            2 3    4                    |
|                                        |
|o5 : Ideal of R                         |
+----------------------------------------+

See also
========

  * gaussCol -- Makes column reductions of a matrix
  * nextDegree -- Lifts the kernel to the next degree
  * gotzmannTest -- Checks if a set of monomials is a
    Gotzmann set
  * affinePart -- Replaces columns in a matrix with an
    identity matrix

Ways to use co1Fitting:
=======================

  * "co1Fitting(Matrix)"
  * "co1Fitting(Module)"

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

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

Fitting ideals of finite modules -- An introductory example
***********************************************************

Consider a polynomial ring S=\mathbb{Z}[x_0,\dots,x_r], and a quotient Q=S^p/N
where N is a homogeneous submodule generated in degrees at most d. Suppose that
Q_d is free of rank n. We then have a short exact sequence 0\to N_d\to S_d^p\to
Q_d\to 0 where also N_d is free. Thus, N_d\otimes S_1\to S^p_{d+1}\to
Q_{d+1}\to 0 is a free presentation of Q_{d+1}. If the basis of Q_d can be
chosen as a so called Gotzmann set, then Q_{d+1} is free of rank n if and only
if the (n-1)'th Fitting ideal of Q_{d+1} is zero.

As an example, we consider a quotient Q of S^2=\mathbb{Z}[x_0,x_1]^2 such that
Q_1 is free of rank 1. As S^2_1=\mathbb{Z}<xe_1,ye_1,xe_2,ye_2> is a free
\mathbb{Z}^4-module we have that Q_1 is the cokernel of a (1\times 4)-matrix.

+---------------------------------+
|i1 : S=ZZ[x_0,x_1];              |
+---------------------------------+
|i2 : R=ZZ[a_1..a_4];             |
+---------------------------------+
|i3 : Q1=matrix{{a_1,a_2,a_3,a_4}}|
|                                 |
|o3 = | a_1 a_2 a_3 a_4 |         |
|                                 |
|             1      4            |
|o3 : Matrix R  <-- R             |
+---------------------------------+

Suppose that Q_1 has a basis given by xe_1, corresponding to the 0'th column.
We check that this is a Gotzmann set, and calculate a free presentation of Q_2.

+-------------------------------------+
|i4 : gotzmannTest(S^2,1,{0})         |
|                                     |
|o4 = true                            |
+-------------------------------------+
|i5 : Q1=affinePart(Q1,{0})           |
|                                     |
|o5 = | 1 a_2 a_3 a_4 |               |
|                                     |
|             1      4                |
|o5 : Matrix R  <-- R                 |
+-------------------------------------+
|i6 : N1=gens ker Q1                  |
|                                     |
|o6 = {0} | a_2 a_3 a_4 |             |
|     {1} | -1  0   0   |             |
|     {1} | 0   -1  0   |             |
|     {1} | 0   0   -1  |             |
|                                     |
|             4      3                |
|o6 : Matrix R  <-- R                 |
+-------------------------------------+
|i7 : N2=nextDegree(N1,1,S)           |
|                                     |
|o7 = {-1} | a_2 0   a_3 0   a_4 0   ||
|     {-1} | -1  a_2 0   a_3 0   a_4 ||
|     {0}  | 0   -1  0   0   0   0   ||
|     {0}  | 0   0   -1  0   0   0   ||
|     {0}  | 0   0   0   -1  -1  0   ||
|     {0}  | 0   0   0   0   0   -1  ||
|                                     |
|             6      6                |
|o7 : Matrix R  <-- R                 |
+-------------------------------------+

N_2 is the matrix corresponding to the map N_1\otimes S_1\to S^2_2, so Q_2 is
the cokernel. We want to calculate the (n-1)'th Fitting ideal of N_2 with n=1.

+---------------------+
|i8 : co1Fitting(N2)  |
|                     |
|o8 = ideal(a a  - a )|
|            2 3    4 |
|                     |
|o8 : Ideal of R      |
+---------------------+

Thus, the obstruction for Q_2 to be free of rank 1 is the equation a_2a_3-a_4.

A result is that the Quot scheme of rank n quotients of \mathcal{O}^p is cut
out by a single (n-1)'th Fitting ideal in the Grassmannian of locally free rank
n quotients of a push forward of \mathcal{O}(d)^p for d\ge n.

In the case above, we have the Grassmannian Gr(1,4)=\mathbb{P}^3, and the Quot
scheme is given by a (n-1)'th Fitting ideal. All of the above calculations can
also be done directly by:

+--------------------------+
|i9 : quotScheme(S^2,1,{0})|
|                          |
|o9 = ideal(a a  - a )     |
|            2 3    4      |
|                          |
|o9 : Ideal of ZZ[a ..a ]  |
|                  1   4   |
+--------------------------+

We can calculate much bigger examples with these function than with the
ordinary Fitting ideal function. As an example, we consider the following with
rank 2 quotients of S^2.

+------------------------------------------------------------------------+
|i10 : S=ZZ[x,y];                                                        |
+------------------------------------------------------------------------+
|i11 : R=ZZ[a_1..a_12];                                                  |
+------------------------------------------------------------------------+
|i12 : Q2=matrix{toList(a_1..a_6),toList(a_7..a_12)}                     |
|                                                                        |
|o12 = | a_1 a_2 a_3 a_4  a_5  a_6  |                                    |
|      | a_7 a_8 a_9 a_10 a_11 a_12 |                                    |
|                                                                        |
|              2      6                                                  |
|o12 : Matrix R  <-- R                                                   |
+------------------------------------------------------------------------+
|i13 : Q2=affinePart(Q2,{0,1})                                           |
|                                                                        |
|o13 = | 1 0 a_3 a_4  a_5  a_6  |                                        |
|      | 0 1 a_9 a_10 a_11 a_12 |                                        |
|                                                                        |
|              2      6                                                  |
|o13 : Matrix R  <-- R                                                   |
+------------------------------------------------------------------------+
|i14 : K3=nextDegree(gens ker Q2,2,S);                                   |
|                                                                        |
|              8      8                                                  |
|o14 : Matrix R  <-- R                                                   |
+------------------------------------------------------------------------+
|i15 : time I=co1Fitting(K3)                                             |
| -- used 0.00200012s (cpu); 0.00208186s (thread); 0s (gc)               |
|                                                                        |
|o15 = ideal (a a   + a  - a  , a a   - a , a a   + a  - a  , a a   - a )|
|              9 11    5    12   3 11    6   9 10    4    11   3 10    5 |
|                                                                        |
|o15 : Ideal of R                                                        |
+------------------------------------------------------------------------+
|i16 : time J=fittingIdeal(2-1,coker K3);                                |
| -- used 0.00473001s (cpu); 0.00483547s (thread); 0s (gc)               |
|                                                                        |
|o16 : Ideal of R                                                        |
+------------------------------------------------------------------------+
|i17 : I==J                                                              |
|                                                                        |
|o17 = true                                                              |
+------------------------------------------------------------------------+

Note that our method is a bit faster for this small example, and for rank 2
quotients of S^3=\mathbb{Z}[x,y]^3 the time difference is massive.

See also
========

  * gaussCol -- Makes column reductions of a matrix
  * co1Fitting -- Calculates the (n-1)'th Fitting ideal of a
    finite module
  * nextDegree -- Lifts the kernel to the next degree
  * gotzmannTest -- Checks if a set of monomials is a
    Gotzmann set
  * affinePart -- Replaces columns in a matrix with an
    identity matrix
  * quotScheme -- Calculates the defining equations for Quot
    schemes of points

gaussCol -- Makes column reductions of a matrix
***********************************************

Synopsis
========

  * Usage:
        gaussCol M
  * Inputs:
      * M, a matrix (Macaulay2Doc),
      * M, a mutable matrix (Macaulay2Doc),
  * Outputs:
      * a matrix (Macaulay2Doc),

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

This function does certain column reductions in a matrix M, if M is of a
certain type as in this example.

+----------------------------------------+
|i1 : S=ZZ[x,y];                         |
+----------------------------------------+
|i2 : R=S[a_1..a_4];                     |
+----------------------------------------+
|i3 : M=matrix{{1,a_2,a_3,a_4}};         |
|                                        |
|             1      4                   |
|o3 : Matrix R  <-- R                    |
+----------------------------------------+
|i4 : K=nextDegree(ker M,1,S)            |
|                                        |
|o4 = {-1, 0} | a_2 0   a_3 0   a_4 0   ||
|     {-1, 0} | -1  a_2 0   a_3 0   a_4 ||
|     {0, 0}  | 0   -1  0   0   0   0   ||
|     {0, 0}  | 0   0   -1  0   0   0   ||
|     {0, 0}  | 0   0   0   -1  -1  0   ||
|     {0, 0}  | 0   0   0   0   0   -1  ||
|                                        |
|             6      6                   |
|o4 : Matrix R  <-- R                    |
+----------------------------------------+

What it does is that it starts from the bottom right and if it finds a -1 then
it uses that column to reduces all other columns to a form with a zero in the
corresponding row. It then continues up left searching for the next -1 and
repeats the procedure.

+------------------------------------------------+
|i5 : gaussCol(K)                                |
|                                                |
|o5 = | a_2 a_2^2 a_3 a_2a_3 -a_2a_3+a_4 a_2a_4 ||
|     | -1  0     0   0      0           0      ||
|     | 0   -1    0   0      0           0      ||
|     | 0   0     -1  0      0           0      ||
|     | 0   0     0   -1     0           0      ||
|     | 0   0     0   0      0           -1     ||
|                                                |
|             6      6                           |
|o5 : Matrix R  <-- R                            |
+------------------------------------------------+

See also
========

  * nextDegree -- Lifts the kernel to the next degree
  * co1Fitting -- Calculates the (n-1)'th Fitting ideal of a
    finite module
  * affinePart -- Replaces columns in a matrix with an
    identity matrix

Ways to use gaussCol:
=====================

  * "gaussCol(Matrix)"
  * "gaussCol(MutableMatrix)"

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

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

gotzmannTest -- Checks if a set of monomials is a Gotzmann set
**************************************************************

Synopsis
========

  * Usage:
        gotzmannTest(M,d,L)
        gotzmannTest(B,x)
  * Inputs:
      * M, a module (Macaulay2Doc),
      * d, an integer (Macaulay2Doc),
      * L, a list (Macaulay2Doc),
      * B, a list (Macaulay2Doc),
      * x, a ring element (Macaulay2Doc),
  * Outputs:
      * a Boolean value (Macaulay2Doc),

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

For us, a Gotzmann set will be a set L of monomials of degree d in the
variables x_0,\dots,x_r with the property that if m\in L, then x_0 divides m
and if x_i divides m, then (x_0m)/x_i\in L. The function gotzmannTest checks if
a set of monomials fulfills this property.

+------------------------------+
|i1 : S=ZZ[x,y,z];             |
+------------------------------+
|i2 : L={x^3,x^2*y,x^2*z,x*y*z}|
|                              |
|       3   2    2             |
|o2 = {x , x y, x z, x*y*z}    |
|                              |
|o2 : List                     |
+------------------------------+
|i3 : gotzmannTest(L,x)        |
|                              |
|o3 = true                     |
+------------------------------+

A non example of a Gotzmann set is L_2=\{x^3,x^2y,xz^2\}.

+-------------------------+
|i4 : L2={x^3,x^2*y,x*z^2}|
|                         |
|       3   2      2      |
|o4 = {x , x y, x*z }     |
|                         |
|o4 : List                |
+-------------------------+
|i5 : gotzmannTest(L2,x)  |
|                         |
|o5 = false               |
+-------------------------+

L_2 is not a Gotzmann set since it does not contain x^2z.

When we consider a free S-module S^p with basis e_1,\dots,e_p, then we
generalize our notion of Gotzmann set for x so that a set L is a Gotzmann set
if it is a union of Gotzmann sets for x for e_1,\dots,e_p.

As an example in S^2=\mathbb{Z}[x,y,z]^2 we have a Gotzmann set
L=\{x^2e_1,xye_1,x^2e_2\}\ as it is a Gotzmann set in each coordinate. We can
test this be gotzmannTest(S^p,d,I), where d is the degree of the monomials, and
I is the index of the monomials of L listed in the lexicographical order
x<y<z<e_1<e_2. In our case we have d=2 and I=\{0,1,6\}\ since:

x^2e_1<xye_1<xze_1<y^2e_1<yze_1<z^2e_1<x^2e_2<xye_2<xze_2<y^2e_2<yze_2<z^2e_2.

+--------------------------------+
|i6 : gotzmannTest(S^2,2,{0,1,6})|
|                                |
|o6 = true                       |
+--------------------------------+

See also
========

  * affinePart -- Replaces columns in a matrix with an
    identity matrix

Ways to use gotzmannTest:
=========================

  * "gotzmannTest(List,RingElement)"
  * "gotzmannTest(Module,ZZ,List)"

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

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

nextDegree -- Lifts the kernel to the next degree
*************************************************

Synopsis
========

  * Usage:
        nextDegree M,d,S
  * Inputs:
      * M, a matrix (Macaulay2Doc),
      * M, a module (Macaulay2Doc),
      * d, an integer (Macaulay2Doc),
      * L, a ring (Macaulay2Doc),
  * Outputs:
      * a matrix (Macaulay2Doc),

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

Let S be a polynomial ring and consider a quotient Q=S^p/N where N is a
submodule generated in degrees at most d. If the graded component Q_d is free,
then N_d is free as well, and N_d\otimes S_1 \to S^p_{d+1} \to Q_{d+1}\to 0
gives a free resolution of Q_{d+1}. The function nextDegree takes the matrix
corresponding to the map N_d\to S^p_d and gives the matrix corresponding to the
map N_d\otimes S_1\to S^p_{d+1}.

+----------------------------------------+
|i1 : S=ZZ[x_0,x_1];                     |
+----------------------------------------+
|i2 : R=S[a_1..a_4];                     |
+----------------------------------------+
|i3 : K=gens ker matrix{{1,a_2,a_3,a_4}} |
|                                        |
|o3 = {0, 0} | a_2 a_3 a_4 |             |
|     {1, 0} | -1  0   0   |             |
|     {1, 0} | 0   -1  0   |             |
|     {1, 0} | 0   0   -1  |             |
|                                        |
|             4      3                   |
|o3 : Matrix R  <-- R                    |
+----------------------------------------+
|i4 : nextDegree(K,1,S)                  |
|                                        |
|o4 = {-1, 0} | a_2 0   a_3 0   a_4 0   ||
|     {-1, 0} | -1  a_2 0   a_3 0   a_4 ||
|     {0, 0}  | 0   -1  0   0   0   0   ||
|     {0, 0}  | 0   0   -1  0   0   0   ||
|     {0, 0}  | 0   0   0   -1  -1  0   ||
|     {0, 0}  | 0   0   0   0   0   -1  ||
|                                        |
|             6      6                   |
|o4 : Matrix R  <-- R                    |
+----------------------------------------+

See also
========

  * gaussCol -- Makes column reductions of a matrix
  * affinePart -- Replaces columns in a matrix with an
    identity matrix
  * co1Fitting -- Calculates the (n-1)'th Fitting ideal of a
    finite module

Ways to use nextDegree:
=======================

  * "nextDegree(Matrix,ZZ,Ring)"
  * "nextDegree(Module,ZZ,Ring)"

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

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

quotScheme -- Calculates the defining equations for Quot schemes of points
**************************************************************************

Synopsis
========

  * Usage:
        quotScheme(Q,n,L)
  * Inputs:
      * Q, a module (Macaulay2Doc),
      * n, an integer (Macaulay2Doc),
      * L, a list (Macaulay2Doc),
  * Outputs:
      * an ideal (Macaulay2Doc),

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

The Quot scheme of n points of \mathcal{O}^p on \mathbb{P}^r embeds as a closed
subscheme of the  Grassmannian of rank n quotients  of a push forward of
\mathcal{O}(d)^p. This function gives the defining equations of this closed
subscheme.

+--------------------------+
|i1 : S=ZZ[x_0,x_1];       |
+--------------------------+
|i2 : quotScheme(S^2,1,{0})|
|                          |
|o2 = ideal(a a  - a )     |
|            2 3    4      |
|                          |
|o2 : Ideal of ZZ[a ..a ]  |
|                  1   4   |
+--------------------------+

See also
========

  * co1Fitting -- Calculates the (n-1)'th Fitting ideal of a
    finite module

Ways to use quotScheme:
=======================

  * "quotScheme(Module,ZZ,List)"

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

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