findTrivialMasseyOperation -- Finds a trivial Massey operation on a set of generators of H(A)

Synopsis

Usage:

tmo = findTrivialMasseyOperation(A)
Inputs:
- A, an instance of the type DGAlgebra,
Optional inputs:
- GenDegreeLimit => ..., default value infinity, Option to specify the maximum degree to look for generators
- TMOLimit => ..., default value infinity, Option to specify the maximum arity of a trivial Massey operation, if one exists.
Outputs:
- seq, a sequence, A sequence seq whose first entry reports whether a trivial Massey operation has been found, and the second entry is a hash table with keys given by monomials in a generating set of the positive degree homology of A and values the element that bounds the Massey product corresponding to that monomial.

Description

This function the element that bounds all potentially nonzero Massey products (before taking homology class). The maximum degree of a generating cycle is specified in the option GenDegreeLimit, if needed.

Golod rings are defined by being those rings whose Koszul complex K^R has a trivial Massey operation. Also, the existence of a trivial Massey operation on a DG algebra A forces the multiplication on H(A) to be trivial. An example of a ring R such that H(K^R) has trivial multiplication, yet K^R does not admit a trivial Massey operation is unknown. Such an example cannot be monomially defined, by a result of Jollenbeck and Berglund.

This is an example of a Golod ring. It is Golod since it is the Stanley-Reisner ideal of a flag complex whose 1-skeleton is chordal [Jollenbeck-Berglund].

i1 : Q = ZZ/101[x_1..x_6]

o1 = Q

o1 : PolynomialRing

i2 : I = ideal (x_3*x_5,x_4*x_5,x_1*x_6,x_3*x_6,x_4*x_6)

o2 = ideal (x x , x x , x x , x x , x x )
             3 5   4 5   1 6   3 6   4 6

o2 : Ideal of Q

i3 : R = Q/I

o3 = R

o3 : QuotientRing

i4 : A = koszulComplexDGA(R)

o4 = {Ring => R                               }
      Underlying algebra => R[T ..T ]
                               1   6
      Differential => {x , x , x , x , x , x }
                        1   2   3   4   5   6

o4 : DGAlgebra

i5 : isHomologyAlgebraTrivial(A,GenDegreeLimit=>3)

o5 = true

i6 : cycleList = getGenerators(A)

o6 = {x T , x T , x T , x T , x T , -x T T , -x T T , -x T T , -x T T , -
       5 4   5 3   6 4   6 3   6 1    5 3 4    6 1 3    6 3 4    6 1 4   
     ------------------------------------------------------------------------
     x T T  + x T T , - x T T  + x T T , x T T T , x T T T  - x T T T }
      6 4 5    5 4 6     6 3 5    5 3 6   6 1 3 4   6 3 4 5    5 3 4 6

o6 : List

i7 : (hasTMO, tmoSoFar) = findTrivialMasseyOperation(A)

o7 = (true, HashTable{{0, 1} => -x T T T         })
                                  5 3 4 5
                      {0, 3, 4} => x T T T T T
                                    6 1 3 4 5 6
                      {0, 3} => -x T T T
                                  6 3 4 5
                      {0, 4, 3} => -x T T T T T
                                     6 1 3 4 5 6
                      {0, 4} => -x T T T
                                  6 1 4 5
                      {0, 6} => x T T T T
                                 6 1 3 4 5
                      {0, 10} => -x T T T T
                                   5 3 4 5 6
                      {0} => x T
                              5 4
                      {1, 0} => x T T T
                                 5 3 4 5
                      {1, 2, 4} => -x T T T T T
                                     6 1 3 4 5 6
                      {1, 2} => x T T T
                                 6 3 4 5
                      {1, 4, 2} => x T T T T T
                                    6 1 3 4 5 6
                      {1, 4} => -x T T T
                                  6 1 3 5
                      {1, 8} => -x T T T T
                                  6 1 3 4 5
                      {1, 9} => x T T T T
                                 5 3 4 5 6
                      {1} => x T
                              5 3
                      {2, 1} => -x T T T
                                  6 3 4 5
                      {2, 3} => -x T T T
                                  6 3 4 6
                      {2, 4, 1} => x T T T T T
                                    6 1 3 4 5 6
                      {2, 4} => -x T T T
                                  6 1 4 6
                      {2, 6} => x T T T T
                                 6 1 3 4 6
                      {2, 10} => -x T T T T
                                   6 3 4 5 6
                      {2} => x T
                              6 4
                      {3, 0} => x T T T
                                 6 3 4 5
                      {3, 2} => x T T T
                                 6 3 4 6
                      {3, 4, 0} => -x T T T T T
                                     6 1 3 4 5 6
                      {3, 4} => -x T T T
                                  6 1 3 6
                      {3, 8} => -x T T T T
                                  6 1 3 4 6
                      {3, 9} => x T T T T
                                 6 3 4 5 6
                      {3} => x T
                              6 3
                      {4, 0} => x T T T
                                 6 1 4 5
                      {4, 1} => x T T T
                                 6 1 3 5
                      {4, 2, 1} => -x T T T T T
                                     6 1 3 4 5 6
                      {4, 2} => x T T T
                                 6 1 4 6
                      {4, 3, 0} => x T T T T T
                                    6 1 3 4 5 6
                      {4, 3} => x T T T
                                 6 1 3 6
                      {4, 5} => x T T T T
                                 6 1 3 4 5
                      {4, 7} => x T T T T
                                 6 1 3 4 6
                      {4, 9} => x T T T T
                                 6 1 4 5 6
                      {4, 10} => x T T T T
                                  6 1 3 5 6
                      {4, 12} => x T T T T T
                                  6 1 3 4 5 6
                      {4} => x T
                              6 1
                      {5, 4} => -x T T T T
                                  6 1 3 4 5
                      {5} => -x T T
                               5 3 4
                      {6, 0} => -x T T T T
                                  6 1 3 4 5
                      {6, 2} => -x T T T T
                                  6 1 3 4 6
                      {6, 9} => -x T T T T T
                                  6 1 3 4 5 6
                      {6} => -x T T
                               6 1 3
                      {7, 4} => -x T T T T
                                  6 1 3 4 6
                      {7} => -x T T
                               6 3 4
                      {8, 1} => x T T T T
                                 6 1 3 4 5
                      {8, 3} => x T T T T
                                 6 1 3 4 6
                      {8, 10} => x T T T T T
                                  6 1 3 4 5 6
                      {8} => -x T T
                               6 1 4
                      {9, 1} => -x T T T T
                                  5 3 4 5 6
                      {9, 3} => -x T T T T
                                  6 3 4 5 6
                      {9, 4} => -x T T T T
                                  6 1 4 5 6
                      {9, 6} => -x T T T T T
                                  6 1 3 4 5 6
                      {9} => - x T T  + x T T
                                6 4 5    5 4 6
                      {10, 0} => x T T T T
                                  5 3 4 5 6
                      {10, 2} => x T T T T
                                  6 3 4 5 6
                      {10, 4} => -x T T T T
                                   6 1 3 5 6
                      {10, 8} => x T T T T T
                                  6 1 3 4 5 6
                      {10} => - x T T  + x T T
                                 6 3 5    5 3 6
                      {11} => x T T T
                               6 1 3 4
                      {12, 4} => -x T T T T T
                                   6 1 3 4 5 6
                      {12} => x T T T  - x T T T
                               6 3 4 5    5 3 4 6

o7 : Sequence

i8 : assert(hasTMO)

Below is an example of a Teter ring (Artinian Gorenstein ring modulo its socle), and the computation in Avramov and Levin's paper shows that H(A) does not have trivial multiplication, hence no trivial Massey operation can exist.

i9 : Q = ZZ/101[x,y,z]

o9 = Q

o9 : PolynomialRing

i10 : I = ideal (x^3,y^3,z^3,x^2*y^2*z^2)

              3   3   3   2 2 2
o10 = ideal (x , y , z , x y z )

o10 : Ideal of Q

i11 : R = Q/I

o11 = R

o11 : QuotientRing

i12 : A = koszulComplexDGA(R)

o12 = {Ring => R                      }
       Underlying algebra => R[T ..T ]
                                1   3
       Differential => {x, y, z}

o12 : DGAlgebra

i13 : isHomologyAlgebraTrivial(A)

o13 = false

i14 : cycleList = getGenerators(A)

        2     2     2       2 2       2 2       2   2         2 2     
o14 = {x T , y T , z T , x*y z T , x*y z T T , x y*z T T , x*y z T T ,
          1     2     3         1         1 2         1 2         1 3 
      -----------------------------------------------------------------------
         2 2         2   2         2 2
      x*y z T T T , x y*z T T T , x y z*T T T }
             1 2 3         1 2 3         1 2 3

o14 : List

i15 : assert(not first findTrivialMasseyOperation(A))

The related function findNaryTrivialMasseyOperation find only the nth order trivial Massey operations.

Ways to use findTrivialMasseyOperation:

findTrivialMasseyOperation(DGAlgebra)

For the programmer

The object findTrivialMasseyOperation is a method function with options.