This is ModuleDeformations.info, produced by Macaulay2, version 1.26.06

ModuleDeformations -- versal deformations of modules on hypersurfaces
*********************************************************************

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

Given a regular element $ f $ in $ R $, $ R $ a regular ring, a matrix
factorisation of $ f $ is a pair $ (A,B) $ of square matrices of the same size
over $ S $ such that $ AB = fI = BA $, where $ I $ is the identity matrix of
the same dimension. Matrix factorisations of $ f $ are equivalent to maximal
Cohen-Macaulay (MCM) modules on the hypersurface defined by $ f $: given a
matrix factorisation $ (A,B) $ of $f$, the cokernel of $ A $ is an MCM-module
over $ S/(f) $, and all MCM-modules over $ S/(f) $ arise in this way.

Let $ X $ be a germ of a hypersurface at a point 0 and $ M_0 $ be a maximal
Cohen-Macaulay module over $ X $. Let $ Y \rightarrow{} \Sigma $ a flat map of
germs of affine varieties at 0 whose fibre over 0 of $\Sigma$ is isomorphic to
$X$. A deformation of $ M_0 $ (in the deformation theory defined by the map $ Y
\rightarrow{} \Sigma $) is a pair $ (S,M) $ with $ S $ a germ equipped with a
map $ S \rightarrow{} \Sigma $ and $ M $ a module over $ S \times_\Sigma Y $
flat over $ S $, whose restriction to $ 0 \times_\Sigma X $ is isomorphic to $
M_0 $.

A deformation $ (T,M') $ is induced from$ (S,M) $ if there exists a map $
\phi:T \rightarrow{} S $ commuting with the maps $ T \rightarrow{} \Sigma $ and
$ S \rightarrow{} \Sigma $ and such that $ M' $ is isomorphic to $ (\phi
\times_\Sigma id_Y)*M $.

The deformation $ (S,M) $ is versal if any deformation of $ M_0 $ is induced
from $ (S,M) $.

In this package, a germ is represented as the coordinate ring R of an affine
variety and the distinguished point 0 of a germ is assumed to be the ideal
generated by the variables of R. It is an error if the ideal generated by the
variables of R is not prime, e.g. if it is all of R.

This package contains two entry points. One interface may be used only in the
absolute case, where $ \Sigma $ is a reduced point, and the module $ M_0 $ is
deformed over $ Y $ only. The other interface may be used when $ \Sigma $ is
the base space of a nontrivial deformation of $ X $ and $ Y $ is the total
space of the deformation. In such a case, $ M_0 $ is deformed also along the
given deformation of $ X $.

The implementation has been designed to take advantage of graded structure when
available. Thus the user is highly recommended to assign degrees to the inputs
so as to make the rings, homomorphism, and deformation module homogeneous when
possible. Doing so may greatly improve performance.

Author
======

  * Bradford Hovinen <hovinen@math.uni-hannover.de>

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

Version 1.0 of this package was accepted for publication in volume 2 (see
https://msp.org/jsag/2010/2-1/ ) of The Journal of Software for Algebra and
Geometry: Macaulay2 (see https://msp.org/jsag/ ) on 2010-04-17, in the article
Deformations of Matrix Factorisations with Macaulay2 (see
https://msp.org/jsag/2010/2-1/p02.xhtml ) (DOI: 10.2140/jsag.2010.2.6 (see
https://doi.org/10.2140/jsag.2010.2.6 )). That version can be obtained from the
journal (see https://msp.org/jsag/2010/2-1/jsag-v2-n1-x02-code.zip ).

Version
=======

This documentation describes version 1.0 of ModuleDeformations, released 28
October 2009.

Citation
========

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

+-----------------------------------------------------------------------------+
|@misc{ModuleDeformationsSource,                                              |
|  title = {{ModuleDeformations: versal deformations of maximal Cohen-Macaulay|
|  author = {Bradford Hovinen},                                               |
|  howpublished = {A \emph{Macaulay2} package available at                    |
|    \url{https://github.com/Macaulay2/M2/tree/stable/M2/Macaulay2/packages}} |
|}                                                                            |
|                                                                             |
|@article{ModuleDeformationsArticle,                                          |
|  title = {{Deformations of Matrix Factorisations with \emph{Macaulay2}}},   |
|  author = {Bradford Hovinen},                                               |
|  journal = {The Journal of Software for Algebra and Geometry: Macaulay2},   |
|  volume = {2},                                                              |
|  year = {2010},                                                             |
|}                                                                            |
|-----------------------------------------------------------------------------|
|modules. Version~1.0}},                                                      |
+-----------------------------------------------------------------------------+

Exports
=======

  * Functions and commands
      * deformMCMModule -- versal deformation of
        MCM-module on hypersurface
  * Methods
      * deformMCMModule(Module), --
        deformation in the absolute case
      * deformMCMModule(Module,RingMap)
        -- deformation in the relative
        case
  * Other things
      * xi -- Indexed variable of deformation parameters

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

The object ModuleDeformations, is a package (Macaulay2Doc),
defined in ModuleDeformations.m2.

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

The source of this document is in ModuleDeformations.m2:361:0.

deformMCMModule -- versal deformation of MCM-module on hypersurface
*******************************************************************

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

This is the main interface for the package ModuleDeformations. It
has two signatures: one for the absolute case and one for the general case.
Both versions return a pair (S,M)where S is a ring representing the base space
of the deformation and M is a module representing the deformation module.

The module $M$ is not defined over the product $S \times{} Y$ but instead over
the polynomial ring in which $S \times{} Y$ is defined. Attempting to construct
$M$ over $S \times{} Y$ may result in computational blowup in certain cases.
Reducing $M$ modulo the defining equations of $S \times{} Y$ gives the
deformation module itself.

The function deformMCMModule returns an error if the given module M0 is not
maximal Cohen-Macaulay, if it is not defined over a hypersurface, or if its
module $Ext^1(M0,M0)$ of first-order deformations is not finite-dimensional as
a vector space. If M0 is free, then deformMCMModule returns a pair with a
trivial base space S and a free module M generated in the same degrees as M0.

The parameters of the base space, that is, the coordinates over which S is
defined, are labelled xi_1 through xi_d, where d is the dimension as a vector
space of the module of first-order deformations of the module being deformed.

The function deformMCMModule computes a deformation only up to a degree limit
given by the optional parameter DegreeLimit, whose default value is 10. The
procedure is optimized so that specifying too large a degree limit should not
result in substantial computational difficulties in most cases.

Ways to use deformMCMModule:
============================

  * deformMCMModule(Module) -- deformation
    in the absolute case
  * deformMCMModule(Module,RingMap)
    -- deformation in the relative case

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

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

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

The source of this document is in ModuleDeformations.m2:398:0.

deformMCMModule(...,DegreeLimit=>...) -- Compute only up to this exponent
*************************************************************************

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

This parameter is an integer $ n $ such that in the result of the computation
the versality criterion holds only after reducing the relevant rings modulo the
maximal homogeneous ideal to the power $ n+1 $. Concretely, this means that the
output may have incorrect terms with total exponent greater than $ n $. If the
input is positively graded, all deformation parameters have strictly positive
degree, and $ n $ is sufficiently large, then no terms of degree greater than $
n $ appear in the output, and the result is versal. In this case, the maximum
of $ d / deg x $ where $ d $ is the degree of the equation of the hypersurface
and $ x $ ranges over all variables in the ring of the hypersurface and all
deformation parameters, should suffice.

Functions with optional argument named DegreeLimit:
===================================================

  * "compose(Module,Module,Module,DegreeLimit=>...)" -- see compose (Macaulay2Doc),
    -- composition as a pairing on Hom-modules
  * deformMCMModule(...,DegreeLimit=>...)
    -- Compute only up
    to this exponent
  * "End(...,DegreeLimit=>...)" -- see End (Macaulay2Doc), -- module
    of endomorphisms
  * "gb(...,DegreeLimit=>...)" -- see gb (Macaulay2Doc), -- compute a
    Gröbner basis
  * "Hom(...,DegreeLimit=>...)" -- see Hom (Macaulay2Doc), -- module
    of homomorphisms
  * "homomorphism'(...,DegreeLimit=>...)" -- see homomorphism' (Macaulay2Doc),
    -- get the element of Hom from a homomorphism
  * kernel(...,DegreeLimit=>...) (Macaulay2Doc)
    -- stop after
    finding enough elements of a subring
  * "minimalBetti(...,DegreeLimit=>...)" -- see minimalBetti (Macaulay2Doc),
    -- minimal betti numbers of (the minimal free
    resolution of) a homogeneous ideal or module
  * normalCone(Ideal,DegreeLimit=>...) (missing documentation)
  * normalCone(Ideal,RingElement,DegreeLimit=>...) (missing documentation)
  * "pushForward(...,DegreeLimit=>...)" -- see
    pushForward(RingMap,Module) (Macaulay2Doc),
    -- compute the pushforward
    of a module along a ring map
  * quotient(...,DegreeLimit=>...) (missing documentation)
  * saturate(...,DegreeLimit=>...) (missing documentation)
  * "syz(...,DegreeLimit=>...)" -- see syz(Matrix) (Macaulay2Doc),
    -- compute the syzygy matrix

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

  * Default value: 10
  * Function: deformMCMModule, -- versal deformation of
    MCM-module on hypersurface
  * Option key: DegreeLimit (Macaulay2Doc), -- an optional
    argument
-------------------------------------------------------------------------------

The source of this document is in ModuleDeformations.m2:530:0.

deformMCMModule(Module) -- deformation in the absolute case
***********************************************************

  * Function: deformMCMModule,
  * Usage:
        deformMCMModule M0
  * Inputs:
      * M0, a module (Macaulay2Doc), the module to be deformed;
        it must be maximal Cohen-Macaulay
  * Optional inputs (Macaulay2Doc),:
      * DegreeLimit,
        => ..., default value 10, Compute only up to this exponent
  * Outputs:
      * S, a ring (Macaulay2Doc), a ring representing the base
        space of the versal deformation of M0
      * M, a module (Macaulay2Doc), a module representing the
        module of the versal deformation

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

This interface to deformMCMModule computes a deformation in the absolute case.
Its inputs consist only of the module M0 to deform.

If M0 is free, then deformMCMModule returns (QQ[], M), where M is isomorphic as
a graded module to M0.
+---------------------------------------------+
|i1 : R = QQ[x,y, Degrees => {3,4}]/(x^4-y^3);|
+---------------------------------------------+
|i2 : deformMCMModule R^1                     |
|                                             |
|             1                               |
|o2 = (QQ[], R )                              |
|                                             |
|o2 : Sequence                                |
+---------------------------------------------+

The next example computes a versal deformation of the maximal ideal of the E6
singularity. The deformation theory of this module is equivalent to that of the
residue field, whose versal deformation is the Hilbert scheme of one point on
the singularity.
+-----------------------------------------------------------+
|i3 : M0 = truncate(1,R^1)                                  |
|                                                           |
|o3 = image | x y |                                         |
|                                                           |
|                             1                             |
|o3 : R-module, submodule of R                              |
+-----------------------------------------------------------+
|i4 : (S,M) = deformMCMModule M0                            |
|                                                           |
|o4 = (S, cokernel {3} | y+xi_1  x3-x2xi_2+xxi_2^2-xi_2^3 |)|
|                  {4} | -x-xi_2 -y2+yxi_1-xi_1^2         | |
|                                                           |
|o4 : Sequence                                              |
+-----------------------------------------------------------+
|i5 : prune S                                               |
|                                                           |
|     QQ[xi ..xi ]                                          |
|          1    2                                           |
|o5 = ------------                                          |
|          3     4                                          |
|      - xi  - xi                                           |
|          1     2                                          |
|                                                           |
|o5 : QuotientRing                                          |
+-----------------------------------------------------------+
The base space of the deformation is therefore isomorphic to the singularity
itself. The substitution x => -xi_2, y => xi_1 shows that this is indeed the
case with the result of the computation above.

The resulting module $M$, when restricted to the product of the singularity
with the base space, is isomorphic to the ideal defining the diagonal embedding
of the singularity.

The following example demonstrates the performance advantage of making use of a
graded structure when possible. We deform the ideal generated by $ x^2, xy $
and $ y^2 $ of the $ E_6 $ curve singularity. In the first case, the module is
input as a graded module.
+-----------------------------------------------------------------------------+
|i6 : use R;                                                                  |
+-----------------------------------------------------------------------------+
|i7 : N0 = module ideal (x^2,y^2)                                             |
|                                                                             |
|o7 = image | x2 y2 |                                                         |
|                                                                             |
|                             1                                               |
|o7 : R-module, submodule of R                                                |
+-----------------------------------------------------------------------------+
|i8 : (S,N) = time deformMCMModule N0                                         |
| -- used 0.680304s (cpu); 0.464451s (thread); 0s (gc)                        |
|                                                                             |
|o8 = (S, cokernel {6} | x2-xxi_2-xi_1+xi_2^2-yxi_4^2-2xi_3xi_4^2+xi_2xi_4^3  |
|                  {8} | xxi_4-y+xi_3                                         |
|     ------------------------------------------------------------------------|
|     xyxi_4+2xxi_3xi_4-xxi_2xi_4^2+y2+yxi_3+xi_3^2-xi_1xi_4^2 |)             |
|     -x2-xxi_2-xi_1                                           |              |
|                                                                             |
|o8 : Sequence                                                                |
+-----------------------------------------------------------------------------+
|i9 : prune S                                                                 |
|                                                                             |
|                                                    QQ[xi ..xi ]             |
|                                                         1    4              |
|o9 = ------------------------------------------------------------------------|
|          2        2     3            2           3                3      2  |
|     (- xi  + xi xi  + xi  - 3xi xi xi  + xi xi xi , - 2xi xi  + xi  + 3xi xi|
|          1     1  2     3      1  3  4     1  2  4       1  2     2      3  |
|                                                                             |
|o9 : QuotientRing                                                            |
|-----------------------------------------------------------------------------|
|---------------------------------                                            |
|             2        3     2  3                                             |
|  - 3xi xi xi  - xi xi  + xi xi )                                            |
|4      2  3  4     1  4     2  4                                             |
+-----------------------------------------------------------------------------+
In the second case, we strip the grading from the module and rerun the
computation.
+-----------------------------------------------------------------------------+
|i10 : N0' = coker matrix entries presentation N0                             |
|                                                                             |
|o10 = cokernel | x2 y2  |                                                    |
|               | -y -x2 |                                                    |
|                                                                             |
|                             2                                               |
|o10 : R-module, quotient of R                                                |
+-----------------------------------------------------------------------------+
|i11 : (S',N') = time deformMCMModule N0'                                     |
| -- used 0.702273s (cpu); 0.562203s (thread); 0s (gc)                        |
|                                                                             |
|o11 = (S', cokernel | x2-xxi_4^3-xxi_2+xi_2xi_4^3-3xi_3xi_4^2+xi_2^2-xi_1    |
|                    | xxi_4-y+xi_3                                           |
|      -----------------------------------------------------------------------|
|      x2xi_4^2+xyxi_4+2xxi_3xi_4+y2+yxi_3+xi_3^2 |)                          |
|      -x2-xxi_2-xi_1                             |                           |
|                                                                             |
|o11 : Sequence                                                               |
+-----------------------------------------------------------------------------+
|i12 : prune S'                                                               |
|                                                                             |
|                                                   QQ[xi ..xi ]              |
|                                                        1    4               |
|o12 = -----------------------------------------------------------------------|
|               3            2        2     3     2    2  3            2      |
|      (xi xi xi  - 3xi xi xi  + xi xi  + xi  - xi , xi xi  - 3xi xi xi  - xi |
|         1  2  4      1  3  4     1  2     3     1    2  4      2  3  4     1|
|                                                                             |
|o12 : QuotientRing                                                           |
|-----------------------------------------------------------------------------|
|------------------------------                                               |
|  3     3      2                                                             |
|xi  + xi  + 3xi xi  - 2xi xi )                                               |
|  4     2      3  4      1  2                                                |
+-----------------------------------------------------------------------------+
On the author's computer, the second computation takes approximately of 10%
more processor time as the first. The user may see by inspection that the
outputs of the two computations are isomorphic. More complicated examples, such
as the square of the maximal ideal, show a much greater difference.

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

  * deformMCMModule(Module) -- deformation
    in the absolute case
-------------------------------------------------------------------------------

The source of this document is in ModuleDeformations.m2:462:0.

deformMCMModule(Module,RingMap) -- deformation in the relative case
*******************************************************************

  * Function: deformMCMModule,
  * Usage:
        (S,M) = deformMCMModule(M0,phi)
  * Inputs:
      * M0, a module (Macaulay2Doc), the module to be deformed
      * phi, a ring map (Macaulay2Doc), a ring homomorphism
        representing the map $\phi : Y \rightarrow{} \Sigma$
  * Optional inputs (Macaulay2Doc),:
      * DegreeLimit,
        => ..., default value 10, Compute only up to this exponent
  * Outputs:
      * S, a ring (Macaulay2Doc), a ring representing the base
        space of the versal deformation of M0
      * M, a module (Macaulay2Doc), a module representing the
        module of the versal deformation

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

This interface to deformMCMModule constructs a versal deformation of M0 in the
general case. That is, there is given a map of varieties $\phi:Y \rightarrow{}
\Sigma$ and a module M0 defined over the fibre over 0 of $\phi$. A versal
deformation of M0 is then constructed in the deformation theory so defined.
Thus its inputs consist of M0 and a ring homomorphism $\phi^*$ representing the
map $\phi:Y \rightarrow{}  \Sigma$. The procedure requires that M0 be an MCM
module over the ring \mathcal{O}_Y/\phi^*(m_\Sigma), where m_\Sigma is the
ideal generated by the variables of \mathcal{O}_\Sigma. Otherwise an error will
result.

If M0 is free, then deformMCMModule returns (S,M), where S is the source of phi
and M is a free module over the ambient ring of Y, generated in the same
degrees as M0.

+------------------------------------------------------------+
|i1 : OSigma = QQ[x, Degrees=>{2}];                          |
+------------------------------------------------------------+
|i2 : OY = QQ[y,z,x, Degrees=>{2,3,2}]/(z^2-(y-x)*y^2);      |
+------------------------------------------------------------+
|i3 : phi = map(OY,OSigma, {x})                              |
|                                                            |
|o3 = map (OY, OSigma, {x})                                  |
|                                                            |
|o3 : RingMap OY <-- OSigma                                  |
+------------------------------------------------------------+
|i4 : use OSigma                                             |
|                                                            |
|o4 = OSigma                                                 |
|                                                            |
|o4 : PolynomialRing                                         |
+------------------------------------------------------------+
|i5 : OX = trim (OY/phi(ideal x))                            |
|                                                            |
|o5 = OX                                                     |
|                                                            |
|o5 : QuotientRing                                           |
+------------------------------------------------------------+
|i6 : (OS,M) = deformMCMModule(module ideal (y,z),phi)       |
|                                                            |
|o6 = (OS, cokernel {2} | z+xi_1  y2-yx-yxi_2+xxi_2+xi_2^2 |)|
|                   {3} | -y-xi_2 -z+xi_1                  | |
|                                                            |
|o6 : Sequence                                               |
+------------------------------------------------------------+
|i7 : prune OS                                               |
|                                                            |
|      QQ[x, xi ..xi ]                                       |
|              1    2                                        |
|o7 = -----------------                                      |
|       2       2     3                                      |
|     xi  + x*xi  + xi                                       |
|       1       2     2                                      |
|                                                            |
|o7 : QuotientRing                                           |
+------------------------------------------------------------+
The above example deforms the maximal ideal of the A2 singularity onto the
Whitney umbrella $Y$ (whose ring is OY above, of which the former is a
hyperplane section given by the fibre over 0 of the map $Y \rightarrow{}
\Sigma$ defined by $\phi$ above. The resulting base space S (whose ring OS is
part of the output of deformMCMModule) is the Hilbert scheme of one point on
the Whitney umbrella, which is isomorphic to $Y$. The substitution y => -xi_2,
z => xi_1 shows this isomorphism.

The resulting module $M$, when restricted to the fibre product of $Y$ and $S$
over $\Sigma$, is isomorphic to the ideal defining the diagonal embedding of
$Y$.

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

  * deformMCMModule(Module,RingMap)
    -- deformation in the relative case
-------------------------------------------------------------------------------

The source of this document is in ModuleDeformations.m2:514:0.

xi -- Indexed variable of deformation parameters
************************************************

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

The object xi, is an indexed variable table (Macaulay2Doc).

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

The source of this document is in ModuleDeformations.m2:535:0.