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

InverseSystems -- Macaulay's Inverse Systems
********************************************

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

Inverse systems are often used to construct artinian Gorenstein ideals and
modules. For a brief introduction to that application, see Gorenstein.
Here we give a general introduction.

The graded Hopf algebra dual of the symmetric algebra $S := k[x_1,\dots,x_n]$
is the divided power algebra $D$. The dual basis to the monomial basis of $S$
is the basis consisting of monomials of the form $x_1^{(m_1)} \dots
x_n^{(m_n)}$. In characteristic zero, $S$ and $D$ are isomorphic as algebras,
with isomorphism sending $x_i^{a}$ to $a!x_i^{(a)}$. In general the
multiplication in $D$ is defined by the same formulas as in characteristic 0.
For example,

$x_1^{(1)}*x_1^{(1)} = 2*x_1^{(2)}$.

In positive characteristic $D$ and $S$ are not isomorphic; $D$ is not even a
finitely generated algebra.

We will be interested also in the local versions, where we take power series in
the divided powers. This is the ordinary linear dual of $S$. We denote it by
$D'$. As an $S$-module, $D'$ is the injective hull of the simple module
$S/(x_1,\dots,x_n)$.

Since $D$ is the graded dual of $S$, it may also be regarded as an $S$-module.
Any element of $D$ is annihilated by a power of $mm = (x_1,\dots,x_n)$, so the
action of $S$ on $D$ or $D'$ extends to an action of the power series ring
k[[x_1,\dots,x_n]].

F. S. Macaulay defined the inverse system of an $S'$-submodule M of $D'$ to be
the annihilator I of M in $S'$ (or in $S$).  If $M$ is finitely generated then
it is annihilated by some power of $mm$, and thus I is 0-dimensional.

Inversely, the (local) inverse system of an ideal in $S$ or $S'$ is by
definition the submodule of $D'$ that it annihilates.

In the 1880's these ideas were used by Max Noether, in the local version, as a
substitute for primary decomposition in the case of what he called multiple
points in the plane. F. S. Macaulay studied and greatly refined Noether's work,
and for example identified the ideals I that are annihilators of cyclic
submodules of $D'$ as the ideals such that one could do residuation in $S'/I$
-- that is, $S'/I$ is Gorenstein. Though the global version has also been
studied, we will only be concerned with the local version.

Any finitely generated submodule of D' generated by finite polynomials is
actually a submodule of D, and its dual will have only primary components
contained in $(x_1,\dots,x_n)$ so the distinction will not be important for us
on that side. However, it is important to note that when taking the inverse
system of an ideal, only the primary components contained in $(x_1,\dots,x_n)$
play a role.

%%%%%%%%%%%%%%%%%%%%%%%%

Going from a submodule of D to an ideal of S (or from a submodule of D^r to a
submodule of S^r:

Because D and D' are not finitely generated S-modules Macaulay2 cannot deal
with them directly. These scripts can only deal with a finitely generated
submodule M of D or D'. Such a module is represented here by a row matrix, of
ordinary polynomials, whose entries are thought of as generators of M.

More generally, we represent a finitely generated submodule of $D^r$ as an
$r$-rowed matrix M of ordinary polynomials.

In the default behavior of the script

inverseSystem M = inverseSystem(M, DividedPowers => false)

a monomial $x^a$ is taken to represent $a!x^{(a)} \in D'$, where, if $a =
(a_1,\dots,a_n)$, then $a! = a_1!*\dots*a_n!$. This means that the script
should not be used in the default way unless the characteristic is greater than
the highest degree to which a variable appears.

To make $x^a$ represent $x^{(a)}$, for example in small characteristics, use

inverseSystem(Matrix, DividedPowers=>true)

(which was and remains the default behavior of the script "fromDual").

The reason for the default choice is that the general linear group GL_n(k) acts
on both S and D, and it is reasonable to expect that the operations defined by
inverseSystem should be equivariant. This is the case for the default setting,
but with DividedPowers=>true it is not the case. For example,

+--------------------------+
|i1 : S = QQ[x,y]          |
|                          |
|o1 = S                    |
|                          |
|o1 : PolynomialRing       |
+--------------------------+
|i2 : J = inverseSystem x^2|
|                          |
|                3         |
|o2 = ideal (y, x )        |
|                          |
|o2 : Ideal of S           |
+--------------------------+

differs only by a linear change of coordinates from the ideal

+-------------------------------+
|i3 : J' = inverseSystem (x+y)^2|
|                               |
|                    3          |
|o3 = ideal (x - y, y )         |
|                               |
|o3 : Ideal of S                |
+-------------------------------+

But is has very different properties than the ideal

+----------------------------------------------------------------+
|i4 : J'' = inverseSystem(matrix{{(x+y)^2}}, DividedPowers=>true)|
|                                                                |
|                    2   2    2                                  |
|o4 = ideal (x*y - 2y , x  - y )                                 |
|                                                                |
|o4 : Ideal of S                                                 |
+----------------------------------------------------------------+
|i5 : betti res J''                                              |
|                                                                |
|            0 1 2                                               |
|o5 = total: 1 2 1                                               |
|         0: 1 . .                                               |
|         1: . 2 .                                               |
|         2: . . 1                                               |
|                                                                |
|o5 : BettiTally                                                 |
+----------------------------------------------------------------+

With the default behavior (DividedPowers=>false), inverseSystem is equivariant
in a precise sense: If G is an $n\times n$ invertible scalar matrix, then G
defines an automorphism g: S\to S by change of variables. Also g also acts on 1
x m matrices M, componentwise and (transpose g)^{-1} (inverseSystem M) =
inverseSystem(g M), as illustrated below:

+-----------------------------------------------------------------------------+
|i6 : kk = QQ                                                                 |
|                                                                             |
|o6 = QQ                                                                      |
|                                                                             |
|o6 : Ring                                                                    |
+-----------------------------------------------------------------------------+
|i7 : n = 3                                                                   |
|                                                                             |
|o7 = 3                                                                       |
+-----------------------------------------------------------------------------+
|i8 : S = kk[a,b,c]                                                           |
|                                                                             |
|o8 = S                                                                       |
|                                                                             |
|o8 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i9 : M = matrix{{a^2,b^3+c^3}}                                               |
|                                                                             |
|o9 = | a2 b3+c3 |                                                            |
|                                                                             |
|             1       2                                                       |
|o9 : Matrix S  <--- S                                                        |
+-----------------------------------------------------------------------------+
|i10 : G = random(S^3, S^3)                                                   |
|                                                                             |
|o10 = | 9/2 1/2 3/2 |                                                        |
|      | 1/2 1   3/4 |                                                        |
|      | 9/4 3/4 7/4 |                                                        |
|                                                                             |
|              3       3                                                      |
|o10 : Matrix S  <--- S                                                       |
+-----------------------------------------------------------------------------+
|i11 : g = map(S,S,(vars S)*G)                                                |
|                                                                             |
|                  9    1    9   1        3   3    3    7                     |
|o11 = map (S, S, {-a + -b + -c, -a + b + -c, -a + -b + -c})                  |
|                  2    2    4   2        4   2    4    4                     |
|                                                                             |
|o11 : RingMap S <--- S                                                       |
+-----------------------------------------------------------------------------+
|i12 : g' = map(S,S,(vars S)*(transpose G))                                   |
|                                                                             |
|                  9    1    3   1        3   9    3    7                     |
|o12 = map (S, S, {-a + -b + -c, -a + b + -c, -a + -b + -c})                  |
|                  2    2    2   2        4   4    4    4                     |
|                                                                             |
|o12 : RingMap S <--- S                                                       |
+-----------------------------------------------------------------------------+
|i13 : h =  map(S,S,(vars S)*(transpose G)^(-1))                              |
|                                                                             |
|                  19     4    18   13    72    42     30    36    68         |
|o13 = map (S, S, {--a + --b - --c, --a + --b - --c, - --a - --b + --c})      |
|                  47    47    47   47    47    47     47    47    47         |
|                                                                             |
|o13 : RingMap S <--- S                                                       |
+-----------------------------------------------------------------------------+
|i14 : inverseSystem M                                                        |
|                                                                             |
|                             3    3   3                                      |
|o14 = ideal (b*c, a*c, a*b, b  - c , a )                                     |
|                                                                             |
|o14 : Ideal of S                                                             |
+-----------------------------------------------------------------------------+
|i15 : g'(inverseSystem g(M))                                                 |
|                                                                             |
|               24675      7943      50901     4935      1833      893        |
|o15 = ideal (- -----a*b - ----a*c - -----b*c, ----a*b + ----a*c + ---b*c, -  |
|                 2          8         8         2         2        4         |
|      -----------------------------------------------------------------------|
|                                   73467 3   26433 2    42111   2   8379 3   |
|      2961a*b - 5076a*c - 47b*c, - -----a  + -----a b + -----a*b  + ----b  - |
|                                     64        64         64         64      |
|      -----------------------------------------------------------------------|
|      128133 2    34989        37563 2    65989   2   38437   2   8379 3     |
|      ------a c + -----a*b*c + -----b c - -----a*c  + -----b*c  - ----c ,    |
|        64          32           64         64          64         64        |
|      -----------------------------------------------------------------------|
|      78003 3   48033 2    6021   2   441 3   122067 2    17379              |
|      -----a  + -----a b + ----a*b  - ---b  + ------a c + -----a*b*c -       |
|        32        32        32         32       32          16               |
|      -----------------------------------------------------------------------|
|      1977 2    48321   2   2023   2   441 3                                 |
|      ----b c + -----a*c  - ----b*c  + ---c )                                |
|       32         32         32         32                                   |
|                                                                             |
|o15 : Ideal of S                                                             |
+-----------------------------------------------------------------------------+

These may look different, but...

+-----------------------------------------------+
|i16 : g'(inverseSystem g(M)) == inverseSystem M|
|                                               |
|o16 = true                                     |
+-----------------------------------------------+

Equivalently,

+----------------------------------------------+
|i17 : h(inverseSystem M) == inverseSystem g(M)|
|                                              |
|o17 = true                                    |
+----------------------------------------------+

There is a similar equivariance for the dual action of inverseSystem on ideals.

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

Going from an ideal of S to a submodule of D, or from a submodule of S^r to a
submodule of D^r.

If $I$ is an ideal of $S$, homogeneous or not, we regard $I$ as an ideal of
$S'$, and similarly with submodules of S^n. In either case we allow the
function to accept either a submodule or its matrix of generators (a matrix
with target S^n, possibly with generators in different degrees.

If I is an ideal or a submodule, then M = inverseSystem(d, I) M1 =
inverseSystem(d, I, DividedPowers => true)

both return 1 x m matrices whose entries are the minimal generators of the
annihilator of $I$ in $D'$, correct up to degree d. In the matrix $M$ a term
$x^a$ is to be interpreted as $a! x^{(a)}$, while in the matrix $M1$ it is
interpreted as $x^{(a)}$. Of course the first computation is only valid if all
the powers of variables appearing in the generators of $I$ are < char k.

%%%%%%%%%%%%%%%%%%%%%%%%%%%%5 The functor inverseSystem ( -- ) and
inverseSystem (d ,-- ) are inverse contravariant isomorphisms between the
categories of bounded length submodules of D^r and bounded co-length submodules
of S^r (the bound depends on d in an obvious way.)

+-----------------------------------------------------------------------------+
|i18 : S = ZZ/101[a,b,c]                                                      |
|                                                                             |
|o18 = S                                                                      |
|                                                                             |
|o18 : PolynomialRing                                                         |
+-----------------------------------------------------------------------------+
|i19 : M = random(S^{0,1}, S^{-1,-1,-2,-2})                                   |
|                                                                             |
|o19 = {0}  | -13a-15b-47c                 -43a-28b+38c                       |
|      {-1} | 22a2-47ab+43b2+7ac+36bc+33c2 45a2+47ab-17b2+15ac+35bc+40c2      |
|      -----------------------------------------------------------------------|
|      2a2-34ab-23b2+19ac-11bc+11c2                                           |
|      11a3-28a2b-47ab2+15b3-3a2c-7abc-13b2c+29ac2+30bc2+39c3                 |
|      -----------------------------------------------------------------------|
|      16a2-48ab+39b2-16ac+48bc-38c2                         |                |
|      46a3+a2b-23ab2-37b3+22a2c+2abc-10b2c-47ac2-18bc2+27c3 |                |
|                                                                             |
|              2       4                                                      |
|o19 : Matrix S  <--- S                                                       |
+-----------------------------------------------------------------------------+
|i20 : d = 6                                                                  |
|                                                                             |
|o20 = 6                                                                      |
+-----------------------------------------------------------------------------+
|i21 : N = inverseSystem(d, M)                                                |
|                                                                             |
|o21 = {0}  | 36a5-23a4b-48a3b2+43a2b3+40ab4-25b5+36a4c                       |
|      {-1} | 9a6+32a5b-18a4b2+38a3b3+9a2b4-43ab5-11b6-                       |
|      -----------------------------------------------------------------------|
|      -31a3bc-49a2b2c+4ab3c-10b4c-50a3c2+48a2bc2+13ab2c2+45b3c2-29a2c3+46abc3|
|      3a5c-30a4bc+33a3b2c+26a2b3c+28ab4c-7b5c-41a4c2-34a3bc2+22a2b2c2+14ab3c2|
|      -----------------------------------------------------------------------|
|      -39b2c3+22ac4+49bc4+16c5                                               |
|      +26b4c2+38a3c3+49a2bc3+9ab2c3+31b3c3+10a2c4+45abc4-39b2c4-32ac5-11bc5+ |
|      -----------------------------------------------------------------------|
|           -3a4+4a3b-8a2b2-17ab3+b4-22a3c+32a2bc-9ab2c+                      |
|      11c6 -24a5+8a4b-17a3b2-44a2b3-30ab4-b5-9a4c-2a3bc                      |
|      -----------------------------------------------------------------------|
|      29b3c-a2c2+13abc2-25b2c2                                               |
|      -14a2b2c-23ab3c-47b4c-46a3c2-36a2bc2-ab2c2-b3c2+31a2c3+41abc3+3b2c3-   |
|      -----------------------------------------------------------------------|
|                       |                                                     |
|      43ac4-33bc4+43c5 |                                                     |
|                                                                             |
|              2       2                                                      |
|o21 : Matrix S  <--- S                                                       |
+-----------------------------------------------------------------------------+
|i22 : image M == inverseSystem N                                             |
|                                                                             |
|o22 = true                                                                   |
+-----------------------------------------------------------------------------+

but with a smaller value of d this would not work:

+-----------------------------------------------------------------------------+
|i23 : d = 5                                                                  |
|                                                                             |
|o23 = 5                                                                      |
+-----------------------------------------------------------------------------+
|i24 : N = inverseSystem(d, M)                                                |
|                                                                             |
|o24 = {0}  | -49a4-42a3b-47a2b2-30ab3+50b4+10a3c-2a2bc+41ab2c+13b3c+36a2c2+  |
|      {-1} | -42a5-39a4b+7a3b2+8a2b3-21ab4+17b5-23a4c-48a3bc-50a2b2c+11ab3c  |
|      -----------------------------------------------------------------------|
|      2abc2+17ac3                                                            |
|      -21b4c-32a3c2+33a2bc2+31ab2c2-31b3c2+37a2c3-44abc3+38b2c3+24ac4-48bc4+ |
|      -----------------------------------------------------------------------|
|           9a4+13a3b+24a2b2+15ab3+47b4+29a3c+30ab2c-41b3c-                   |
|      15c5 -24a5+28a4b-a3b2-23a2b3+27ab4-27b5+20a4c+19a3bc                   |
|      -----------------------------------------------------------------------|
|      29a2c2-25abc2+17bc3                                                    |
|      -44a2b2c-39ab3c-4b4c+5a3c2+25a2bc2-8ab2c2-27b3c2+50a2c3+25abc3+10b2c3+ |
|      -----------------------------------------------------------------------|
|                    -18a4+43a3b-30a2b2+45ab3-10b4+13a3c-32a2bc-9ab2c-        |
|      2ac4-45bc4-c5 -23a5-37a4b-40a3b2+36a2b3-33ab4-20b5-15a4c-24a3bc        |
|      -----------------------------------------------------------------------|
|      31b3c-3a2c2+24abc2-21c4                                                |
|      +27a2b2c+30ab3c+9b4c+5a3c2+4a2bc2-28ab2c2-28b3c2+44a2c3-31abc3+27b2c3+ |
|      -----------------------------------------------------------------------|
|                       -3a4+4a3b-8a2b2-17ab3+b4-22a3c+32a2bc-9ab2c+          |
|      42ac4+44bc4+13c5 -24a5+8a4b-17a3b2-44a2b3-30ab4-b5-9a4c-2a3bc          |
|      -----------------------------------------------------------------------|
|      29b3c-a2c2+13abc2-25b2c2                                               |
|      -14a2b2c-23ab3c-47b4c-46a3c2-36a2bc2-ab2c2-b3c2+31a2c3+41abc3+3b2c3-   |
|      -----------------------------------------------------------------------|
|                       |                                                     |
|      43ac4-33bc4+43c5 |                                                     |
|                                                                             |
|              2       4                                                      |
|o24 : Matrix S  <--- S                                                       |
+-----------------------------------------------------------------------------+
|i25 : image M != inverseSystem N                                             |
|                                                                             |
|o25 = true                                                                   |
+-----------------------------------------------------------------------------+

There is at present no direct way to compare inverseSystem(d, inverseSystem M)
and M, since the matrices representing these submodules are really representing
sets of generators in D^r. However, we can check equality of containment by
applying inverseSystem again:

+-----------------------------------------------------------------------------+
|i26 : M = random(S^{0,1}, S^{-1,-1,-2,-2})                                   |
|                                                                             |
|o26 = {0}  | -22a-9b-20c                  32a-32b+24c                        |
|      {-1} | -15a2-49ab+9b2-20ac-26bc-8c2 39a2-33ab-39b2+44ac+22bc+43c2      |
|      -----------------------------------------------------------------------|
|      -30a2-39b2-19ac+4bc-49c2                                               |
|      -8a3-3a2b+16ab2+6b3-30a2c-6abc+3b2c-9ac2+25bc2-41c3                    |
|      -----------------------------------------------------------------------|
|      -48a2+33ab+36b2+17ac+13bc-11c2                          |              |
|      36a3-22a2b-28ab2+40b3+41a2c+35abc-31b2c-35ac2-2bc2-49c3 |              |
|                                                                             |
|              2       4                                                      |
|o26 : Matrix S  <--- S                                                       |
+-----------------------------------------------------------------------------+
|i27 : inverseSystem(inverseSystem(d,gens inverseSystem M)) == inverseSystem M|
|                                                                             |
|o27 = true                                                                   |
+-----------------------------------------------------------------------------+

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% Method: To represent finitely generated
S-submodule of $D'$ as an S-module we use the map of modules S/(x_1^d,\dots,
x_n^d) -> D' sending $x^a$ to contract(x^a, product(n, j-> x_i^{d-1})), and its
inverse, which is of course defined only on divided monomials of small degree.

Caveat
======

The translations used involve multiplying or dividing by scalars; if the
polynomials involved have maximum degree n, then n! must be invertible for
theUsing the tool of translation to make sense.

See also
========

  * inverseSystem -- Inverse systems with equivariance
  * fromDual -- Ideal from inverse system
  * toDual -- finds the inverse system to an ideal up to a given
    degree
  * DividedPowers -- Option for inverseSystem
  * fromDividedPowers -- Translates from divided
    power monomial basis to ordinary monomial basis
  * toDividedPowers -- Translates to divided power
    monomial basis from ordinary monomial basis

Authors
=======

  * David Eisenbud <de@msri.org>
  * Mats Boij <boij@kth.se>

Version
=======

This documentation describes version 1.1 of InverseSystems.

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

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

Exports
=======

  * Functions and commands
      * fromDividedPowers -- Translates from divided
        power monomial basis to ordinary monomial basis
      * fromDual -- Ideal from inverse system
      * inverseSystem -- Inverse systems with
        equivariance
      * isStandardGradedPolynomialRing,
        -- Checks whether a ring is a polynomial ring over a field with
        variables of degree 1
      * toDividedPowers -- Translates to divided power
        monomial basis from ordinary monomial basis
      * toDual -- finds the inverse system to an ideal up to a
        given degree
  * Methods
      * "fromDividedPowers(Matrix)" -- see fromDividedPowers,
        -- Translates from divided power monomial basis to
        ordinary monomial basis
      * "fromDividedPowers(RingElement)" -- see fromDividedPowers,
        -- Translates from divided power monomial basis to
        ordinary monomial basis
      * "fromDual(Matrix)" -- see fromDual, -- Ideal from
        inverse system
      * "fromDual(RingElement)" -- see fromDual, -- Ideal from
        inverse system
      * "inverseSystem(Ideal)" -- see inverseSystem, --
        Inverse systems with equivariance
      * "inverseSystem(Matrix)" -- see inverseSystem, --
        Inverse systems with equivariance
      * "inverseSystem(RingElement)" -- see inverseSystem,
        -- Inverse systems with equivariance
      * "inverseSystem(ZZ,Ideal)" -- see inverseSystem, --
        Inverse systems with equivariance
      * "inverseSystem(ZZ,Matrix)" -- see inverseSystem,
        -- Inverse systems with equivariance
      * "isStandardGradedPolynomialRing(Ring)" -- see
        isStandardGradedPolynomialRing, --
        Checks whether a ring is a polynomial ring over a field with variables
        of degree 1
      * "toDividedPowers(Matrix)" -- see toDividedPowers,
        -- Translates to divided power monomial basis from
        ordinary monomial basis
      * "toDividedPowers(RingElement)" -- see toDividedPowers,
        -- Translates to divided power monomial basis from
        ordinary monomial basis
      * "toDual(ZZ,Ideal)" -- see toDual, -- finds the inverse
        system to an ideal up to a given degree
      * "toDual(ZZ,Matrix)" -- see toDual, -- finds the inverse
        system to an ideal up to a given degree
  * Symbols
      * DividedPowers -- Option for inverseSystem
      * Gorenstein -- Constructing Gorenstein Rings and
        Modules

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

The object InverseSystems, is a package (Macaulay2Doc).

DividedPowers -- Option for inverseSystem
*****************************************

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

Caveat
======

See also
========

  * inverseSystem -- Inverse systems with equivariance

Functions with optional argument named DividedPowers :
======================================================

  * "fromDual(...,DividedPowers=>...)" -- see fromDual, --
    Ideal from inverse system
  * "inverseSystem(...,DividedPowers=>...)" -- see inverseSystem,
    -- Inverse systems with equivariance
  * "toDual(...,DividedPowers=>...)" -- see toDual, -- finds the
    inverse system to an ideal up to a given degree

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

The object DividedPowers, is a symbol (Macaulay2Doc).

fromDividedPowers -- Translates from divided power monomial basis to ordinary monomial basis
********************************************************************************************

Synopsis
========

  * Usage:
        f1 = fromDividedPowers f
  * Inputs:
      * f, a ring element (Macaulay2Doc),
      * f, a matrix (Macaulay2Doc),
  * Outputs:
      * f1, a ring element (Macaulay2Doc),
      * f1, a matrix (Macaulay2Doc),

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

If f is a polynomial, or a matrix of polynomials, written in the divided power
monomial basis, then f1 is the corresponding object written in the ordinary
monomial basis.

+-------------------------------------+
|i1 : S = ZZ/101[x,y]                 |
|                                     |
|o1 = S                               |
|                                     |
|o1 : PolynomialRing                  |
+-------------------------------------+
|i2 : x^2 == fromDividedPowers (2*x^2)|
|                                     |
|o2 = true                            |
+-------------------------------------+

See also
========

  * toDividedPowers -- Translates to divided power
    monomial basis from ordinary monomial basis

Ways to use fromDividedPowers :
===============================

  * "fromDividedPowers(Matrix)"
  * "fromDividedPowers(RingElement)"

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

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

fromDual -- Ideal from inverse system
*************************************

Synopsis
========

  * Usage:
        M  = fromDual f
  * Inputs:
      * f, a matrix (Macaulay2Doc),
      * f, a ring element (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * DividedPowers => ..., default value true
  * Outputs:
      * M, a matrix (Macaulay2Doc), whose image is the inverse
        system

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

The matrix (or ring element) f is interpreted as an element of the linear dual
of the base polynomial ring, where the monomial in f are interpreted as
monomials in the divided power basis (the dual basis of the monomial basis of
ring f. Thus

fromDual f = gens inverseSystem (f, DividedPowers => true).

See the documentation nodes for InverseSystems for the theory, and
inverseSystem for the function. Note that the operation of fromDual is not
equivariant with respect to the general linear group, acting by change of
basis. This not a bug, but follows because fromDual uses the divided power
basis. If equivariant behavior is desired, use the option DividedPowers=>false
(which is the default behavior of inverseSystem):

+---------------------------------------------------------------+
|i1 : S = ZZ/101[x,y]                                           |
|                                                               |
|o1 = S                                                         |
|                                                               |
|o1 : PolynomialRing                                            |
+---------------------------------------------------------------+
|i2 : f1 = x^2                                                  |
|                                                               |
|      2                                                        |
|o2 = x                                                         |
|                                                               |
|o2 : S                                                         |
+---------------------------------------------------------------+
|i3 : f2 = (x+y)^2                                              |
|                                                               |
|      2           2                                            |
|o3 = x  + 2x*y + y                                             |
|                                                               |
|o3 : S                                                         |
+---------------------------------------------------------------+
|i4 : betti res ideal fromDual f1                               |
|                                                               |
|            0 1 2                                              |
|o4 = total: 1 2 1                                              |
|         0: 1 1 .                                              |
|         1: . . .                                              |
|         2: . 1 1                                              |
|                                                               |
|o4 : BettiTally                                                |
+---------------------------------------------------------------+
|i5 : betti res ideal fromDual f2                               |
|                                                               |
|            0 1 2                                              |
|o5 = total: 1 2 1                                              |
|         0: 1 . .                                              |
|         1: . 2 .                                              |
|         2: . . 1                                              |
|                                                               |
|o5 : BettiTally                                                |
+---------------------------------------------------------------+
|i6 : betti res (I = ideal fromDual(f2, DividedPowers => false))|
|                                                               |
|            0 1 2                                              |
|o6 = total: 1 2 1                                              |
|         0: 1 1 .                                              |
|         1: . . .                                              |
|         2: . 1 1                                              |
|                                                               |
|o6 : BettiTally                                                |
+---------------------------------------------------------------+
|i7 : I == inverseSystem (f2, DividedPowers => false)           |
|                                                               |
|o7 = true                                                      |
+---------------------------------------------------------------+
|i8 : inverseSystem (f2, DividedPowers => true)                 |
|                                                               |
|                    2   2    2                                 |
|o8 = ideal (x*y - 2y , x  - y )                                |
|                                                               |
|o8 : Ideal of S                                                |
+---------------------------------------------------------------+
|i9 : ideal fromDual(f2, DividedPowers => false)                |
|                                                               |
|                    3   3                                      |
|o9 = ideal (x - y, x , y )                                     |
|                                                               |
|o9 : Ideal of S                                                |
+---------------------------------------------------------------+
|i10 : ideal fromDual(f2, DividedPowers => true)                |
|                                                               |
|                     2   2    2   3   3                        |
|o10 = ideal (x*y - 2y , x  - y , x , y )                       |
|                                                               |
|o10 : Ideal of S                                               |
+---------------------------------------------------------------+

Caveat
======

The Base ring of the input must be a standard graded polynomial ring over a
field.

Logically, the output of fromDual should be an ideal, not a matrix, but the
original function was converted from the classic Macaulay, where this
distinction was not made.

See also
========

  * InverseSystems -- Macaulay's Inverse Systems
  * inverseSystem -- Inverse systems with equivariance
  * fromDual -- Ideal from inverse system

Ways to use fromDual :
======================

  * "fromDual(Matrix)"
  * "fromDual(RingElement)"

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

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

Gorenstein -- Constructing Gorenstein Rings and Modules
*******************************************************

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

Each artinian graded (or local) Gorenstein ring is the inverse system of a
unique element of D, and inverse systems are often used to construct such
examples. (Higher-dimensional Gorenstein rings also correspond to special
inverse systems, though these are not finitely generated submodules of D. See
"The structure of the inverse system of Gorenstein k-algebras" by Joan Elias
and Maria Evelina Rossi, Adv. Math. (2017) 306-327, for a recent treatment with
computational intent.)

For example, studying artinian Gorenstein rings of codimension 4, one might
consider those corresponding to the sum of n d-th powers of linear forms. For
example with n= 4,5 and d=3:

+-----------------------------------------------------------+
|i1 : S = ZZ/101[a,b,c,d]                                   |
|                                                           |
|o1 = S                                                     |
|                                                           |
|o1 : PolynomialRing                                        |
+-----------------------------------------------------------+
|i2 : nPowers = (S, n,d) ->sum(apply(n, j->(random(1,S))^d))|
|                                                           |
|o2 = nPowers                                               |
|                                                           |
|o2 : FunctionClosure                                       |
+-----------------------------------------------------------+
|i3 : minimalBetti inverseSystem nPowers(S,4,3)             |
|                                                           |
|            0 1  2 3 4                                     |
|o3 = total: 1 9 16 9 1                                     |
|         0: 1 .  . . .                                     |
|         1: . 6  8 3 .                                     |
|         2: . 3  8 6 .                                     |
|         3: . .  . . 1                                     |
|                                                           |
|o3 : BettiTally                                            |
+-----------------------------------------------------------+
|i4 : minimalBetti inverseSystem nPowers (S,5,3)            |
|                                                           |
|            0 1  2 3 4                                     |
|o4 = total: 1 6 10 6 1                                     |
|         0: 1 .  . . .                                     |
|         1: . 6  5 . .                                     |
|         2: . .  5 6 .                                     |
|         3: . .  . . 1                                     |
|                                                           |
|o4 : BettiTally                                            |
+-----------------------------------------------------------+

One can also construct self-dual modules with more generators by taking the
inverseSystem of a submodule that is isomorphic to its dual, for example the
image of a symmetric or skew-symmetric matrix:

+------------------------------------------------+
|i5 : Msymm = matrix"0,a,b;a,0,c;b,c,0"          |
|                                                |
|o5 = | 0 a b |                                  |
|     | a 0 c |                                  |
|     | b c 0 |                                  |
|                                                |
|             3       3                          |
|o5 : Matrix S  <--- S                           |
+------------------------------------------------+
|i6 : Mskew = matrix"0,a,b;-a,0,c;-b,-c,0"       |
|                                                |
|o6 = | 0  a  b |                                |
|     | -a 0  c |                                |
|     | -b -c 0 |                                |
|                                                |
|             3       3                          |
|o6 : Matrix S  <--- S                           |
+------------------------------------------------+
|i7 : minimalBetti coker gens inverseSystem Msymm|
|                                                |
|            0  1  2  3 4                        |
|o7 = total: 3 10 14 10 3                        |
|         0: 3  9  7  1 .                        |
|         1: .  1  7  9 3                        |
|                                                |
|o7 : BettiTally                                 |
+------------------------------------------------+
|i8 : minimalBetti coker gens inverseSystem Mskew|
|                                                |
|            0 1  2 3 4                          |
|o8 = total: 3 9 12 9 3                          |
|         0: 3 9  6 . .                          |
|         1: . .  6 9 3                          |
|                                                |
|o8 : BettiTally                                 |
+------------------------------------------------+

For an interesting series of examples, consider the d-th Hessian matrices
obtained by taking the d-th mixed partials of a form of some degree e>2d. The
ranks of such matrices are connected to the Lefschetz properties of the
corresponding artinian Gorenstein rings, as explained in "The Lefschetz
properties", Springer Lecture Notes in Math. 2080, by T. Harima, T. Maeno, H.
Morita, Y. Numata, A. Wachi  and J. Watanabe.

+-----------------------------------------------------------------------------+
|i9 : Hessian = (d,f) ->(                                                     |
|         S = ring f;                                                         |
|         B = basis(d,S);                                                     |
|         diff(transpose B, diff(B,f))                                        |
|         )                                                                   |
|                                                                             |
|o9 = Hessian                                                                 |
|                                                                             |
|o9 : FunctionClosure                                                         |
+-----------------------------------------------------------------------------+
|i10 : S = ZZ/101[x_1..x_4]                                                   |
|                                                                             |
|o10 = S                                                                      |
|                                                                             |
|o10 : PolynomialRing                                                         |
+-----------------------------------------------------------------------------+
|i11 : f = nPowers (S,6,4)                                                    |
|                                                                             |
|         4      3        2 2        3      4      3        2          2      |
|o11 = 33x  - 20x x  - 44x x  + 33x x  + 32x  - 19x x  - 37x x x  + x x x  -  |
|         1      1 2      1 2      1 2      2      1 3      1 2 3    1 2 3    |
|      -----------------------------------------------------------------------|
|        3        2 2          2    2 2       3        3      4      3        |
|      6x x  + 37x x  - 16x x x  - x x  - 2x x  - 40x x  + 10x  - 47x x  +    |
|        2 3      1 3      1 2 3    2 3     1 3      2 3      3      1 4      |
|      -----------------------------------------------------------------------|
|       2            2        3        2                       2              |
|      x x x  - 16x x x  - 27x x  + 13x x x  + 41x x x x  + 40x x x  -        |
|       1 2 4      1 2 4      2 4      1 3 4      1 2 3 4      2 3 4          |
|      -----------------------------------------------------------------------|
|           2          2        3        2 2         2      2 2          2    |
|      18x x x  - 49x x x  + 38x x  + 39x x  - 7x x x  - 32x x  - 24x x x  +  |
|         1 3 4      2 3 4      3 4      1 4     1 2 4      2 4      1 3 4    |
|      -----------------------------------------------------------------------|
|             2    2 2       3        3       3      4                        |
|      48x x x  - x x  + 7x x  - 10x x  + 3x x  + 16x                         |
|         2 3 4    3 4     1 4      2 4     3 4      4                        |
|                                                                             |
|o11 : S                                                                      |
+-----------------------------------------------------------------------------+
|i12 : minimalBetti coker gens inverseSystem f                                |
|                                                                             |
|             0 1  2 3 4                                                      |
|o12 = total: 1 6 10 6 1                                                      |
|          0: 1 .  . . .                                                      |
|          1: . 4  2 . .                                                      |
|          2: . 2  6 2 .                                                      |
|          3: . .  2 4 .                                                      |
|          4: . .  . . 1                                                      |
|                                                                             |
|o12 : BettiTally                                                             |
+-----------------------------------------------------------------------------+
|i13 : minimalBetti coker gens inverseSystem Hessian(1, f)                    |
|                                                                             |
|             0  1  2  3 4                                                    |
|o13 = total: 4 13 18 13 4                                                    |
|          1: 4 10  6  1 .                                                    |
|          2: .  2  6  2 .                                                    |
|          3: .  1  6 10 4                                                    |
|                                                                             |
|o13 : BettiTally                                                             |
+-----------------------------------------------------------------------------+
|i14 : minimalBetti coker gens inverseSystem Hessian(2, f)                    |
|                                                                             |
|             0  1  2  3 4                                                    |
|o14 = total: 6 24 36 24 6                                                    |
|          2: 6 24 36 24 6                                                    |
|                                                                             |
|o14 : BettiTally                                                             |
+-----------------------------------------------------------------------------+

See also
========

  * inverseSystem -- Inverse systems with equivariance

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

The object Gorenstein, is a symbol (Macaulay2Doc).

inverseSystem -- Inverse systems with equivariance
**************************************************

Synopsis
========

  * Usage:
        I1 = inverseSystem M
        M1 = inverseSystem I
  * Inputs:
      * M, a matrix (Macaulay2Doc), if r rows, then represents a
        submodule of D'^r
      * M, a ring element (Macaulay2Doc),
      * I, an ideal (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * DividedPowers => ..., default value false
  * Outputs:
      * I1, an ideal (Macaulay2Doc), if r=1
      * I1, a module (Macaulay2Doc), submodule of S^r
      * M1, a matrix (Macaulay2Doc),

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

Inverse systems are often used to construct artinian Gorenstein ideals and
modules. For that application see Gorenstein.

Let S = k[x_1..x_n] be a standard graded polynomial ring, and let D be its
dual, the divided power algebra, regarded as an S-module.  Let M be an rxm
matrix of polynomials, and let I be an ideal of S.

From a submodule of D^r to a submodule of S^r (or to an ideal, if r=1):

We think of the columns of M as generators of an  S-submodule MM of D^r, and
inverseSystem M returns the annihilator of MM in S^r = Hom_{graded}(D^r,k). In
the default behavior a monomial $x^a$ in an entry of the matrix M is taken to
represent $a!x^(a) \in D'$, where, $a = (a_1,\dots,a_n)$ then $a! =
a_1!*\dots*a_n!$. Use

inverseSystem(M, DividedPowers => false)

to make the monomials of entries of M represent the dual basis of the monomial
basis of S, that is, the divided powers of the generators of D as an algebra.

From an ideal of S to a submodule of D:

If $I$ is an ideal of $S$, homogeneous or not, we regard $I$ as an ideal of the
localization $S'$ of $S$ at $(x_1,\dots,x_n)$. If $S'/I$ is of finite length
then

M = inverseSystem I

and

M1 = inverseSystem(I, DividedPowers => false)

each return a 1 x m matrix whose entries are the minimal generators of the
annihilator of $I$ in $D$. In the matrix $M$ a term $x^a$ is to be interpreted
as $a! x^(a)$, while in the matrix $M'$ it is interpreted as $x^(a)$. Of course
the first computation is only valid if all the powers of variables appearing in
the generators of $I$ are < char k.

To make these computations it is necessary to represent some sufficiently large
finitely generated S-submodule of $D$ (this will automatically be an
$S'$-submodule. To do this we use the map of modules D-> S/(x_1^d,\dots, x_n^d)
sending $x^{(a)}$ to contract(x^a, product(n, j-> x_i^{d-1})), defined only
when the variables in $x^{(a)}$ appear only with powers < d.

+-----------------------------+
|i1 : setRandomSeed 0         |
|                             |
|o1 = 0                       |
+-----------------------------+
|i2 : kk = QQ                 |
|                             |
|o2 = QQ                      |
|                             |
|o2 : Ring                    |
+-----------------------------+
|i3 : S = kk[a,b,c]           |
|                             |
|o3 = S                       |
|                             |
|o3 : PolynomialRing          |
+-----------------------------+
|i4 : map(S,S,0_S*vars S)     |
|                             |
|o4 = map (S, S, {0, 0, 0})   |
|                             |
|o4 : RingMap S <--- S        |
+-----------------------------+
|i5 : p = (a+b)^2             |
|                             |
|      2           2          |
|o5 = a  + 2a*b + b           |
|                             |
|o5 : S                       |
+-----------------------------+
|i6 : q = toDividedPowers p   |
|                             |
|       2            2        |
|o6 = 2a  + 2a*b + 2b         |
|                             |
|o6 : S                       |
+-----------------------------+
|i7 : p' = fromDividedPowers q|
|                             |
|      2           2          |
|o7 = a  + 2a*b + b           |
|                             |
|o7 : S                       |
+-----------------------------+
|i8 : p'==p                   |
|                             |
|o8 = true                    |
+-----------------------------+

Here are some codimension 4 Gorenstein rings with different Betti tables,
computed by inverseSystem from quartic polynomials

+----------------------------------------------------------------------+
|i9 : kk = ZZ/101                                                      |
|                                                                      |
|o9 = kk                                                               |
|                                                                      |
|o9 : QuotientRing                                                     |
+----------------------------------------------------------------------+
|i10 : S = kk[a..d]                                                    |
|                                                                      |
|o10 = S                                                               |
|                                                                      |
|o10 : PolynomialRing                                                  |
+----------------------------------------------------------------------+
|i11 : f1 = matrix"a2b2+c2d2"; -- gives 1,4,6,4,1                      |
|                                                                      |
|              1       1                                               |
|o11 : Matrix S  <--- S                                                |
+----------------------------------------------------------------------+
|i12 : f2 = matrix"a2b2+b2c2+c2d2"; --gives 1,4,7,4,1;                 |
|                                                                      |
|              1       1                                               |
|o12 : Matrix S  <--- S                                                |
+----------------------------------------------------------------------+
|i13 : f3 = matrix"a2b2+b2c2+c2d2+c2a2"; -- gives 1,4,8,4,1            |
|                                                                      |
|              1       1                                               |
|o13 : Matrix S  <--- S                                                |
+----------------------------------------------------------------------+
|i14 : f4 = matrix"a2b2+b2c2+c2d2+c2a2+a2d2"; --gives 1,4,8,4,1        |
|                                                                      |
|              1       1                                               |
|o14 : Matrix S  <--- S                                                |
+----------------------------------------------------------------------+
|i15 : f5 = matrix"a2b2+b2c2+c2d2+c2a2+a2d2+b2d2+b4"; --gives 1,4,9,4,1|
|                                                                      |
|              1       1                                               |
|o15 : Matrix S  <--- S                                                |
+----------------------------------------------------------------------+
|i16 : f6 = matrix"a2b2+b2c2+c2d2+c2a2+a2d2+b2d2"; --gives 1,4,10,4,1  |
|                                                                      |
|              1       1                                               |
|o16 : Matrix S  <--- S                                                |
+----------------------------------------------------------------------+
|i17 : F = {f1,f2,f3,f4,f5,f6};                                        |
+----------------------------------------------------------------------+
|i18 : netList (F/(f->betti res inverseSystem f))                      |
|                                                                      |
|      +-------------------+                                           |
|      |       0 1  2 3 4  |                                           |
|o18 = |total: 1 9 16 9 1  |                                           |
|      |    0: 1 .  . . .  |                                           |
|      |    1: . 4  4 1 .  |                                           |
|      |    2: . 4  8 4 .  |                                           |
|      |    3: . 1  4 4 .  |                                           |
|      |    4: . .  . . 1  |                                           |
|      +-------------------+                                           |
|      |       0 1  2 3 4  |                                           |
|      |total: 1 9 16 9 1  |                                           |
|      |    0: 1 .  . . .  |                                           |
|      |    1: . 3  2 . .  |                                           |
|      |    2: . 6 12 6 .  |                                           |
|      |    3: . .  2 3 .  |                                           |
|      |    4: . .  . . 1  |                                           |
|      +-------------------+                                           |
|      |       0  1  2  3 4|                                           |
|      |total: 1 11 20 11 1|                                           |
|      |    0: 1  .  .  . .|                                           |
|      |    1: .  2  1  . .|                                           |
|      |    2: .  9 18  9 .|                                           |
|      |    3: .  .  1  2 .|                                           |
|      |    4: .  .  .  . 1|                                           |
|      +-------------------+                                           |
|      |       0  1  2  3 4|                                           |
|      |total: 1 10 18 10 1|                                           |
|      |    0: 1  .  .  . .|                                           |
|      |    1: .  2  .  . .|                                           |
|      |    2: .  8 18  8 .|                                           |
|      |    3: .  .  .  2 .|                                           |
|      |    4: .  .  .  . 1|                                           |
|      +-------------------+                                           |
|      |       0  1  2  3 4|                                           |
|      |total: 1 16 30 16 1|                                           |
|      |    0: 1  .  .  . .|                                           |
|      |    1: .  .  .  . .|                                           |
|      |    2: . 16 30 16 .|                                           |
|      |    3: .  .  .  . .|                                           |
|      |    4: .  .  .  . 1|                                           |
|      +-------------------+                                           |
|      |       0  1  2  3 4|                                           |
|      |total: 1 16 30 16 1|                                           |
|      |    0: 1  .  .  . .|                                           |
|      |    1: .  .  .  . .|                                           |
|      |    2: . 16 30 16 .|                                           |
|      |    3: .  .  .  . .|                                           |
|      |    4: .  .  .  . 1|                                           |
|      +-------------------+                                           |
+----------------------------------------------------------------------+

Caveat
======

Because inverseSystem involves a conversion between the bases of the dual, it
should not be used in the default mode unless the characteristic is greater
than the highest degree to which a variable appears. To make $x^a$ represent
$x^(a)$, for example in small characteristics use

inverseSystem(Matrix, DividedPowers=>false)

(which was the default behavior of the old script "fromDual").

See also
========

  * DividedPowers -- Option for inverseSystem
  * fromDividedPowers -- Translates from divided
    power monomial basis to ordinary monomial basis
  * toDividedPowers -- Translates to divided power
    monomial basis from ordinary monomial basis
  * fromDual -- Ideal from inverse system
  * toDual -- finds the inverse system to an ideal up to a given
    degree
  * isStandardGradedPolynomialRing, --
    Checks whether a ring is a polynomial ring over a field with variables of
    degree 1

Ways to use inverseSystem :
===========================

  * "inverseSystem(Ideal)"
  * "inverseSystem(Matrix)"
  * "inverseSystem(RingElement)"
  * "inverseSystem(ZZ,Ideal)"
  * "inverseSystem(ZZ,Matrix)"

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

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

isStandardGradedPolynomialRing -- Checks whether a ring is a polynomial ring over a field with variables of degree 1
********************************************************************************************************************

Synopsis
========

  * Usage:
        b = isStandardGradedPolynomialRing R
  * Inputs:
      * R, a ring (Macaulay2Doc),
  * Outputs:
      * b, a Boolean value (Macaulay2Doc),

See also
========

  * isPolynomialRing (Macaulay2Doc) -- whether
    something is a polynomial ring

Ways to use isStandardGradedPolynomialRing :
============================================

  * "isStandardGradedPolynomialRing(Ring)"

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

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

toDividedPowers -- Translates to divided power monomial basis from ordinary monomial basis
******************************************************************************************

Synopsis
========

  * Usage:
        f1 = toDividedPowers f
  * Inputs:
      * f, a ring element (Macaulay2Doc),
      * f, a matrix (Macaulay2Doc),
  * Outputs:
      * f1, a ring element (Macaulay2Doc),
      * f1, a matrix (Macaulay2Doc),

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

If f is a polynomial, or a matrix of polynomials, then f1 is the corresponding
object written in the divided power monomial basis, where for example $x^2$
denotes $x^{(2)}$

+-----------------------------------+
|i1 : S = ZZ/101[x,y]               |
|                                   |
|o1 = S                             |
|                                   |
|o1 : PolynomialRing                |
+-----------------------------------+
|i2 : 2*x^2 == toDividedPowers (x^2)|
|                                   |
|o2 = true                          |
+-----------------------------------+

See also
========

  * fromDividedPowers -- Translates from divided
    power monomial basis to ordinary monomial basis

Ways to use toDividedPowers :
=============================

  * "toDividedPowers(Matrix)"
  * "toDividedPowers(RingElement)"

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

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

toDual -- finds the inverse system to an ideal up to a given degree
*******************************************************************

Synopsis
========

  * Usage:
        M = toDual (ZZ, I)
  * Inputs:
      * I, an ideal (Macaulay2Doc), in a standard graded
        polynomial ring
  * Optional inputs (Macaulay2Doc),:
      * DividedPowers => ..., default value true
  * Outputs:
      * M, a matrix (Macaulay2Doc), interpreted as list of
        generators of inverse system to I

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

If I is an ideal, then toDual(d,I) = inverseSystem(d, I). See the documentation
of InverseSystems for the basic theory and of inverseSystem for the function.

If I is a matrix, then the code first replaces it with the ideal generated by
the entries.

Caveat
======

The Base ring of the input must be a standard graded polynomial ring over a
field.

See also
========

  * InverseSystems -- Macaulay's Inverse Systems
  * inverseSystem -- Inverse systems with equivariance
  * fromDual -- Ideal from inverse system

Ways to use toDual :
====================

  * "toDual(ZZ,Ideal)"
  * "toDual(ZZ,Matrix)"

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

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