# eagon -- compute the Eagon double complex

## Synopsis

• Usage:
E = eagon(R,b)
• Inputs:
• R, a ring,
• b, an integer, how far to carry the computation; -1 means "delete EagonData"
• Optional inputs:
• CompressBeta => ..., default value true
• Verbose => ..., default value false
• Outputs:

## Description

eagon(R,b) computes the first b columns of the Eagon double complex Y^*_* of R, and caches them in a HashTable of class EagonData in of R.cache.EagonData. (The command eagon(R,-1) removes this.)

Following Gulliksen-Levin we think of Y^n_* as the n-th column, and Y^*_i as the i-th row. The columns Y^n are not acyclic. The i-th row is a resolution of the i-th module of boundaries in the Koszul complex K of the variables of R; in particular, the "Eagon Resolution" is the 0-th row,

Y^b_0 \to...\to Y^1_0 \to Y^0_0.

Let X_i be the free module R**H_i(K), which is also the R**F_i, where F is a minimal free resolution of R as a module over the polynomial ring on the same set of variables.

We count X_i as having homological degree i+1. With this convention, Y^*_0 has the form K\otimes T(F'), where T denotes the tensor algebra and F' is the F_1++F_2++... .

The module Y^n_i = Eagon#{0,n,i} is described in Gulliksen-Levin as: Y^0 = koszul vars R Y^{n+1}_0 = Y^n_1; and for i>0, Y^{n+1}_i = Y^n_{i+1} ++ Y^n_0**X_i

Note that Y^n_i == 0 for i>1+length koszul vars R - n,

The i-th homology of Y^n_* is H_i(Y^n) = H_0(Y^n_*)**X_i (proved in Gulliksen-Levin). Part of the inductive construction will be a map inducing this isomorphism

alpha^n_i = eagonBeta^n_i + dHor^n_0**1: Y^n_0**X_i \to Y^{n-1}_{i+1} ++ Y^{n-1}_0**X_i = Y^n

Assume that the differential of Y^n and the maps dVert^n and alpha^n are known. We take

dHor^{n+1}_0: Y^{n+1}_0 = Y^n_1 -> Y^n_0 to be dVert^n_1.

The remaining horizontal differentials dHor^{n+1}_i: Y^{n+1} \to Y^n have source and target as follows:

Y^{n+1}_i = Y^n_{i+1} ++ Y^n_0**X_i -> Y^n_i = Y^{n-1}_{i+1} ++ Y^{n-1}_0**X_i.

We take dHor^{n+1}_i to be the sum of two maps:

dVert^n_{i+1} Y^n_{i+1} -> Y^n_i ++ Y^{n-1}_0**X_i.

and alpha^{n+1}_i = eagonBeta^{n+1}_i + dHor^n_0**1: Y^n_0**X_i \to Y^n_i ++ Y^{n-1}_0**X(i).

It remains to define eagonBeta^{n+1}_i; we take this to be the negative of

a lifting along the map from Y^{n+1}_{i-1} \subset Y^n_i to Y^n_{i-1} of the composite

dVert^{n+1}_{i-1} * (dHor^n_0 ** X_i): Y^n_0**X_i -> Y^{n-1}_0.

 i1 : S = ZZ/101[a,b,c] o1 = S o1 : PolynomialRing i2 : I = ideal(a,b)*ideal"a3,b3,c3" 4 3 3 3 4 3 o2 = ideal (a , a*b , a*c , a b, b , b*c ) o2 : Ideal of S i3 : R = S/I o3 = R o3 : QuotientRing i4 : needsPackage "DGAlgebras"; isGolod R o5 = true i6 : E = eagon(R,6) o6 = EagonData in .cache computed to length 6 o6 : EagonData

We can see the vertical and horizontal strands, and the eagonBeta maps

 i7 : verticalStrand(E,3) 27 81 81 27 o7 = R <-- R <-- R <-- R 0 1 2 3 o7 : ChainComplex i8 : horizontalStrand(E,2) 3 9 27 81 243 729 o8 = R <-- R <-- R <-- R <-- R <-- R 0 1 2 3 4 5 o8 : ChainComplex i9 : horizontalStrand (E,0) 1 3 9 27 81 243 o9 = R <-- R <-- R <-- R <-- R <-- R 0 1 2 3 4 5 o9 : ChainComplex i10 : F = eagonResolution E 1 3 9 27 81 243 729 o10 = R <-- R <-- R <-- R <-- R <-- R <-- R 0 1 2 3 4 5 6 o10 : ChainComplex i11 : eagonBeta E +----------------------------------------------------------------+ |+-------+--------+ | o11 = || |(0, {1})| | |+-------+--------+ | ||(1, {})| * | | |+-------+--------+ | +----------------------------------------------------------------+ |+-------+--------+ | || |(1, {1})| | |+-------+--------+ | ||(2, {})| * | | |+-------+--------+ | +----------------------------------------------------------------+ |+--------+--------+-----------+ | || |(2, {1})|(0, {1, 1})| | |+--------+--------+-----------+ | || (3, {})| * | . | | |+--------+--------+-----------+ | ||(0, {2})| . | . | | |+--------+--------+-----------+ | +----------------------------------------------------------------+ |+--------+--------+-----------+-----------+ | || |(3, {1})|(0, {2, 1})|(1, {1, 1})| | |+--------+--------+-----------+-----------+ | ||(0, {3})| . | . | . | | |+--------+--------+-----------+-----------+ | ||(1, {2})| . | . | . | | |+--------+--------+-----------+-----------+ | +----------------------------------------------------------------+ |+-----------+-----------+-----------+-----------+--------------+| || |(0, {3, 1})|(1, {2, 1})|(2, {1, 1})|(0, {1, 1, 1})|| |+-----------+-----------+-----------+-----------+--------------+| || (1, {3}) | . | . | . | . || |+-----------+-----------+-----------+-----------+--------------+| || (2, {2}) | . | . | . | . || |+-----------+-----------+-----------+-----------+--------------+| ||(0, {1, 2})| . | . | . | . || |+-----------+-----------+-----------+-----------+--------------+| +----------------------------------------------------------------+

With the default option CompressBeta => true, only a subset of the components of Y^{n+1}_{i-1} are used. To see the effect of CompressBeta => true, consider:

 i12 : eagon(R,-1) EagonData removed from R.cache i13 : E = eagon(R,6, Verbose =>true) Used 1 of 1 blocks of eagonBeta (2, 1) Used 1 of 1 blocks of eagonBeta (2, 2) Used 1 of 1 blocks of eagonBeta (2, 3) Used 1 of 1 blocks of eagonBeta (2, 4) Used 1 of 2 blocks of eagonBeta (3, 1) Used 1 of 2 blocks of eagonBeta (3, 2) Used 1 of 2 blocks of eagonBeta (3, 3) Used 1 of 1 blocks of eagonBeta (3, 4) Used 1 of 3 blocks of eagonBeta (4, 1) Used 1 of 3 blocks of eagonBeta (4, 2) Used 1 of 2 blocks of eagonBeta (4, 3) Used 1 of 1 blocks of eagonBeta (4, 4) Used 1 of 5 blocks of eagonBeta (5, 1) Used 1 of 4 blocks of eagonBeta (5, 2) Used 1 of 2 blocks of eagonBeta (5, 3) Used 1 of 1 blocks of eagonBeta (5, 4) Used 1 of 7 blocks of eagonBeta (6, 1) Used 1 of 5 blocks of eagonBeta (6, 2) Used 1 of 2 blocks of eagonBeta (6, 3) Used 1 of 1 blocks of eagonBeta (6, 4) o13 = EagonData in .cache computed to length 6 o13 : EagonData i14 : eagon(R,-1) EagonData removed from R.cache i15 : En = eagon(R,6,CompressBeta => false) o15 = EagonData in .cache computed to length 6 o15 : EagonData i16 : eagonBeta (E,4), eagonBeta(E,5) +--------+--------+-----------+ o16 = (| |(2, {1})|(0, {1, 1})|, +--------+--------+-----------+ | (3, {})| * | . | +--------+--------+-----------+ |(0, {2})| . | . | +--------+--------+-----------+ ----------------------------------------------------------------------- +--------+--------+-----------+-----------+ | |(3, {1})|(0, {2, 1})|(1, {1, 1})|) +--------+--------+-----------+-----------+ |(0, {3})| . | . | . | +--------+--------+-----------+-----------+ |(1, {2})| . | . | . | +--------+--------+-----------+-----------+ o16 : Sequence i17 : eagonBeta (En,4), eagonBeta(En,5) +--------+--------+-----------+ o17 = (| |(2, {1})|(0, {1, 1})|, +--------+--------+-----------+ | (3, {})| * | . | +--------+--------+-----------+ |(0, {2})| * | . | +--------+--------+-----------+ ----------------------------------------------------------------------- +--------+--------+-----------+-----------+ | |(3, {1})|(0, {2, 1})|(1, {1, 1})|) +--------+--------+-----------+-----------+ |(0, {3})| . | . | * | +--------+--------+-----------+-----------+ |(1, {2})| * | . | * | +--------+--------+-----------+-----------+ o17 : Sequence

There are also ways to investigate the components of dVert, dHor, and eagonBeta; see picture, DisplayBlocks, and mapComponent.