aInfinity -- aInfinity algebra and module structures on free resolutions

Synopsis

Usage:

mR = aInfinity R

mX = aInfinity(mR, X)
Inputs:
- R, a ring, of the form S/I, where S is a polynomial ring
- mR, a hash table, output of aInfinity R
Optional inputs:
- LengthLimit => an integer, default value null, Construct A-infinity structure to specified homological degree
- Check => a Boolean value, default value true, Verifies that the lifts in the construction were successful
- Order => a Boolean value, default value infinity, Restrict the arity of A-infinity structures produced
Outputs:
- mR, a hash table, A-infinity algebra structure on res coker presentation R
- mX, a hash table, A-infinity module structure over mR on res pushForward(map(R,S),M)

Description

Given an S-free resolution of R = S/I, set B = A_+[1] (so that B_m = A_(m-1) for m >= 2, B_i = 0 for i<2), and differentials have changed sign.

The A-infinity algebra structure is a sequence of degree -1 maps

mR#u: B_(u_1)**..**B_(u_t) -> B_(sum u -1), for sum u <= 2 + (pd_S R), and thus, since each u_i>= 2, for t <= 1 + (pd_S R)//2.

where u is a List of integers \geq 2, such that

mR#{v}: B_v -> B_(v-1) is the differential of B,

mR#{v_1,v_2} is the multiplication (which is a homotopy B**B \to B lifting the degree -2 map d**1 - 1**d: B_2**B_2 \to B_1 (which induces 0 in homology)

mR#u for n>2 is a homotopy for the negative of the sum of degree -2 maps of the form (+/-) mR(1**...** 1 ** mR ** 1 **..**), inserting m into each possible (consecutive) sub product, and i = 2...n-1. Here m_1 represents the differential both of B and of B^(**n).

Given mR, a similar description holds for the A-infinity module structure mX on the S-free resolution of an R-module X.

With the optional argument LengthLimit => n, only those A-infinity maps are constructed that would be used to compute the resolution of a module of projective dimension n-1.

i1 : S = ZZ/101[a,b,c]

o1 = S

o1 : PolynomialRing

i2 : R = S/(ideal(a)*ideal(a,b,c))

o2 = R

o2 : QuotientRing

i3 : mR = aInfinity R;

i4 : keys mR

o4 = {ring, {3, 2}, {2}, {3}, {2, 2}, resolution, {4}, {2, 3}}

o4 : List

i5 : res coker presentation R

      1      3      3      1
o5 = S  <-- S  <-- S  <-- S  <-- 0
                                  
     0      1      2      3      4

o5 : ChainComplex

i6 : mR#"resolution"

      3      3      1
o6 = S  <-- S  <-- S
                    
     2      3      4

o6 : Complex

i7 : mR#{2,2}

o7 = {3} | 0 -a 0  a 0 0  0 -c 0 |
     {3} | 0 0  -a 0 0 0  a b  0 |
     {3} | 0 0  0  0 0 -a 0 0  0 |

             3      9
o7 : Matrix S  <-- S

i8 : X = coker map(R^2,R^{2:-1},matrix{{a,b},{b,c}})

o8 = cokernel | a b |
              | b c |

                            2
o8 : R-module, quotient of R

i9 : mX = aInfinity(mR,X)

o9 = HashTable{{1} => | a b 0  0  0  0  |                                }
                      | b c a2 ab ac bc |
               {2, 0} => {1} | a  0 0  0 c  0 |
                         {1} | 0  0 a  0 0  0 |
                         {2} | 0  1 0  0 0  0 |
                         {2} | -1 0 0  1 0  0 |
                         {2} | 0  0 -1 0 0  1 |
                         {2} | 0  0 0  0 -1 0 |
               {2, 1} => {3} | 1 0  0 a 0 c 0 0 -a 0 0 0 0 0 0  c  0 0 |
                         {3} | 0 -1 0 0 0 0 1 0 0  0 0 0 0 0 0  0  0 0 |
                         {3} | 0 0  0 0 a 0 1 0 0  0 0 0 0 0 -a -b 0 0 |
                         {3} | 0 0  0 0 0 a 0 1 0  0 a b 0 0 0  0  0 0 |
                         {3} | 0 0  0 0 0 a 0 0 0  0 0 b 1 0 0  0  0 c |
                         {3} | 0 0  0 0 0 0 0 0 0  0 0 0 0 1 0  0  0 0 |
               {2, 2, 0} => {4} | 0 0 0 0 0 0 0 0 0 0 0  0 1 0 0  0 0 0 |
                            {4} | 0 0 0 0 0 0 0 0 0 0 -1 0 0 0 -1 0 0 0 |
               {2, 2, 1} => 0
               {2, 2} => {4} | 0 0 0 a -a 0 0 a -a 0 0 0 0 b 0 c 0 0 |
                         {4} | 0 0 0 0 0  a 0 0 0  0 0 b 0 a 0 0 0 0 |
               {2, 3, 0} => 0
               {2} => {1} | 0  ab  0  0  0  -bc |
                      {1} | 0  -a2 0  0  0  ac  |
                      {2} | -b c   -c 0  0  0   |
                      {2} | a  -b  0  -c 0  0   |
                      {2} | 0  0   a  b  -b -c  |
                      {2} | 0  0   0  0  a  b   |
               {3, 0} => {3} | 0  1 0  0 0  0 |
                         {3} | -1 0 0  0 0  0 |
                         {3} | -1 0 0  1 0  0 |
                         {3} | 0  0 -1 0 0  1 |
                         {3} | 0  0 -1 0 0  0 |
                         {3} | 0  0 0  0 -1 0 |
               {3, 1} => {4} | 0 1 0 0 a 0 -1 0 0 0 0 -c 0  0 a b 0 0 |
                         {4} | 0 0 0 0 0 0 0  1 0 0 0 0  -1 0 0 0 0 0 |
               {3, 2, 0} => 0
               {3} => {3} | c  0  |
                      {3} | 0  c  |
                      {3} | -b c  |
                      {3} | a  -b |
                      {3} | 0  -b |
                      {3} | 0  a  |
               {4, 0} => {4} | 0  1 |
                         {4} | -1 0 |
               "module" => cokernel | a b |
                                    | b c |
                                2      6      6      2
               "resolution" => S  <-- S  <-- S  <-- S
                                                     
                               0      1      2      3

o9 : HashTable

Jesse Burke showed how to use mR,mX to make an R-free resolution

i10 : betti burkeResolution(X,8)

             0 1  2  3  4   5   6   7    8
o10 = total: 2 6 12 26 56 120 258 554 1190
          0: 2 2  6 12 26  56 120 258  554
          1: . 4  6 14 30  64 138 296  636

o10 : BettiTally

i11 : betti res(X, LengthLimit =>8)

             0 1 2 3  4  5  6   7   8
o11 = total: 2 2 2 6 12 26 56 120 258
          0: 2 2 2 6 12 26 56 120 258

o11 : BettiTally

i12 : Y = image presentation X

o12 = image | a b |
            | b c |

                              2
o12 : R-module, submodule of R

i13 : burkeResolution(Y,8)

       2      2      6      12      26      56      120      258      554
o13 = R  <-- R  <-- R  <-- R   <-- R   <-- R   <-- R    <-- R    <-- R
                                                                      
      0      1      2      3       4       5       6        7        8

o13 : Complex

References

Jesse Burke, Higher Homotopies and Golod Rings. arXiv:1508.03782v2, October 2015.

Caveat

Requires standard graded ring, module. Something to fix in a future version

Ways to use aInfinity:

aInfinity(HashTable,Module)
aInfinity(Module)
aInfinity(Ring)

For the programmer

The object aInfinity is a method function with options.