# 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:
• Outputs:
• I1, an ideal, if r=1
• I1, , submodule of Sr
• M1,

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

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