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|
+-------------------+
|
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").
The object inverseSystem is a method function with options.