next | previous | forward | backward | up | top | index | toc | Macaulay2 website
InverseSystems :: inverseSystem

inverseSystem -- Inverse systems with equivariance

Synopsis

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 polyomial 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

Ways to use inverseSystem :

For the programmer

The object inverseSystem is a method function with options.