Fold -- Convert any complex or complex map into a ZZ/d-graded factorization (or map) for a fixed integer d

Usage:

Fold(C,d)

Fold(phi,d)
Inputs:
- C, a complex, or a map of complexes
- d, an integer, an integer specifying the period of the resulting factorization or factorization map
Outputs:
- a ZZ/d graded factorization,

Description

Any complex can be viewed as a ZZ/d-graded factorization of 0 by grouping all terms in homological degrees that are the same, modulo the period.

i1 : Q = QQ[x_1..x_3];

i2 : K = koszulComplex vars Q

      1      3      3      1
o2 = Q  <-- Q  <-- Q  <-- Q
                           
     0      1      2      3

o2 : Complex

i3 : fK = Fold(K, 2)  --this groups the odd/even degrees together

      4      4      4
o3 = Q  <-- Q  <-- Q
                    
     0      1      0

o3 : ZZdFactorization

i4 : fK.dd

          4                                4
o4 = 1 : Q  <---------------------------- Q  : 0
               {1} | 0 -x_2 -x_3 0    |
               {1} | 0 x_1  0    -x_3 |
               {1} | 0 0    x_1  x_2  |
               {3} | 0 0    0    0    |

          4                                4
     0 : Q  <---------------------------- Q  : 1
               {0} | x_1 x_2 x_3 0    |
               {2} | 0   0   0   x_3  |
               {2} | 0   0   0   -x_2 |
               {2} | 0   0   0   x_1  |

o4 : ZZdFactorizationMap

i5 : isZZdComplex fK

o5 = true

i6 : f3K = Fold(K,3)

      2      3      3      2
o6 = Q  <-- Q  <-- Q  <-- Q
                           
     0      1      2      0

o6 : ZZdFactorization

i7 : f3K.dd

          3                      2
o7 = 2 : Q  <------------------ Q  : 0
               {2} | 0 x_3  |
               {2} | 0 -x_2 |
               {2} | 0 x_1  |

          2                           3
     0 : Q  <----------------------- Q  : 1
               {0} | x_1 x_2 x_3 |
               {3} | 0   0   0   |

          3                              3
     1 : Q  <-------------------------- Q  : 2
               {1} | -x_2 -x_3 0    |
               {1} | x_1  0    -x_3 |
               {1} | 0    x_1  x_2  |

o7 : ZZdFactorizationMap

i8 : f3K.dd^2

o8 = 0

o8 : ZZdFactorizationMap

i9 : isZZdComplex(f3K)

o9 = true

When the specified period is longer than the actual complex, the output will just be the complex but viewed with additional zero positions.

i10 : K' = koszulComplex {x_1,x_2}

       1      2      1
o10 = Q  <-- Q  <-- Q
                     
      0      1      2

o10 : Complex

i11 : Fold(K',4)

       1      2      1            1
o11 = Q  <-- Q  <-- Q  <-- 0 <-- Q
                                  
      0      1      2      3     0

o11 : ZZdFactorization

i12 : Fold(K',5)

       1      2      1                  1
o12 = Q  <-- Q  <-- Q  <-- 0 <-- 0 <-- Q
                                        
      0      1      2      3     4     0

o12 : ZZdFactorization

The Fold function is also functorial and can be applied to complex maps.

i13 : Fold(id_K, 2)

           4                       4
o13 = 0 : Q  <------------------- Q  : 0
                {0} | 1 0 0 0 |
                {2} | 0 1 0 0 |
                {2} | 0 0 1 0 |
                {2} | 0 0 0 1 |

           4                       4
      1 : Q  <------------------- Q  : 1
                {1} | 1 0 0 0 |
                {1} | 0 1 0 0 |
                {1} | 0 0 1 0 |
                {3} | 0 0 0 1 |

o13 : ZZdFactorizationMap

i14 : oo == id_(Fold(K,2))

o14 = true

i15 : f = randomComplexMap(K, K', Cycle => true)

           1               1
o15 = 0 : Q  <----------- Q  : 0
                | 9/2 |

           3                       2
      1 : Q  <------------------- Q  : 1
                {1} | 9/2 0   |
                {1} | 0   9/2 |
                {1} | 0   0   |

           3                   1
      2 : Q  <--------------- Q  : 2
                {2} | 9/2 |
                {2} | 0   |
                {2} | 0   |

o15 : ComplexMap

i16 : ff = Fold(f,2)

           4                       2
o16 = 0 : Q  <------------------- Q  : 0
                {0} | 9/2 0   |
                {2} | 0   9/2 |
                {2} | 0   0   |
                {2} | 0   0   |

           4                       2
      1 : Q  <------------------- Q  : 1
                {1} | 9/2 0   |
                {1} | 0   9/2 |
                {1} | 0   0   |
                {3} | 0   0   |

o16 : ZZdFactorizationMap

i17 : isCommutative Fold(f, 2)

o17 = true

i18 : isCommutative Fold(f, 3)

o18 = true

Ways to use Fold:

Fold(Complex,ZZ)
Fold(ComplexMap,ZZ)

For the programmer

The object Fold is a method function.

The source of this document is in MatrixFactorizations/MatrixFactorizationsDOC.m2:5174:0.

Fold -- Convert any complex or complex map into a ZZ/d-graded factorization (or map) for a fixed integer d

Description

See also

Ways to use Fold:

For the programmer