inverseSystem -- Inverse systems with equivariance

Synopsis

• Usage:
I1 = inverseSystem M
M1 = inverseSystem I
• Inputs:
• M, , if r rows, then represents a submodule of D'^r
• M, ,
• I, an ideal,
• Optional inputs:
• DividedPowers => ..., default value false
• Outputs:
• I1, an ideal, if r=1
• I1, , submodule of S^r
• M1, ,

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").

• 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 .