next | previous | forward | backward | up | top | index | toc | Macaulay2 web site
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[x1..xn] 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 Dr to a submodule of Sr (or to an ideal, if r=1):

We think of the columns of M as generators of an S-submodule MM of Dr, and inverseSystem M returns the annihilator of MM in Sr = Homgraded(Dr,k). In the default behavior a monomial xa in an entry of the matrix M is taken to represent a!x(a) ∈D’, where, a = (a1,…,an) then a! = a1!*…*an!. 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 (x1,…,xn). 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 xa 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/(x1d,…, xnd) sending x(a) to contract(xa, product(n, j-> xid-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 xa 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 :