next | previous | forward | backward | up | top | index | toc | Macaulay2 website
DGAlgebras :: findTrivialMasseyOperation

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

Synopsis

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 :

For the programmer

The object findTrivialMasseyOperation is a method function with options.