Macaulay2 » Documentation
Packages » MatrixFactorizations :: ZZdfactorization(ZZdFactorization)
next | previous | forward | backward | up | index | toc

ZZdfactorization(ZZdFactorization) -- make a ZZ/d-graded factorization with shifted base; used for permuting the modules without adding signs

Description

A ZZ/d-graded factorization is a sequence of objects $C_i$, connected by maps $dd^C_i : C_i \rightarrow C_{i-1}$ such that the composition of any d consecutive maps is equal to a fixed scalar multiple of the identity.

In practice, a ZZdFactorization may be visualized as a sequence of R-module maps:

$$F_0 \leftarrow F_1 \leftarrow \cdots \leftarrow F_{d-1}$$

with the caveat that $d^F_0 : F_0 \to F_{d-1}$, since one should count degree modulo d.

If one wants to shift the differentials of a factorization without having to redefine or add signs, this can be done as follows:

i1 : S = ZZ/101[a..d]

o1 = S

o1 : PolynomialRing
 
i2 : C1 = ZZdfactorization {a,b}

      1      1      1
o2 = S  <-- S  <-- S
                    
     0      1      0

o2 : ZZdFactorization
 
i3 : C1.dd

          1             1
o3 = 1 : S  <--------- S  : 0
               | b |

          1             1
     0 : S  <--------- S  : 1
               | a |

o3 : ZZdFactorizationMap
 
i4 : C1' = ZZdfactorization(C1, Base => 1)

      1      1      1
o4 = S  <-- S  <-- S
                    
     0      1      0

o4 : ZZdFactorization
 
i5 : C1'.dd

          1             1
o5 = 1 : S  <--------- S  : 0
               | a |

          1             1
     0 : S  <--------- S  : 1
               | b |

o5 : ZZdFactorizationMap
 
i6 : C2 = ZZdfactorization {a,b,c}

      1      1      1      1
o6 = S  <-- S  <-- S  <-- S
                           
     0      1      2      0

o6 : ZZdFactorization
 
i7 : C2.dd

          1             1
o7 = 2 : S  <--------- S  : 0
               | c |

          1             1
     0 : S  <--------- S  : 1
               | a |

          1             1
     1 : S  <--------- S  : 2
               | b |

o7 : ZZdFactorizationMap
 
i8 : C2' = ZZdfactorization(C2, Base => 2)

      1      1      1      1
o8 = S  <-- S  <-- S  <-- S
                           
     0      1      2      0

o8 : ZZdFactorization
 
i9 : C2'.dd

          1             1
o9 = 2 : S  <--------- S  : 0
               | a |

          1             1
     0 : S  <--------- S  : 1
               | b |

          1             1
     1 : S  <--------- S  : 2
               | c |

o9 : ZZdFactorizationMap
 
i10 : C3 = ZZdfactorization {a,b,c,d}

       1      1      1      1      1
o10 = S  <-- S  <-- S  <-- S  <-- S
                                   
      0      1      2      3      0

o10 : ZZdFactorization
 
i11 : C3.dd

           1             1
o11 = 3 : S  <--------- S  : 0
                | d |

           1             1
      0 : S  <--------- S  : 1
                | a |

           1             1
      1 : S  <--------- S  : 2
                | b |

           1             1
      2 : S  <--------- S  : 3
                | c |

o11 : ZZdFactorizationMap
 
i12 : C3' = ZZdfactorization(C3, Base => 3)

       1      1      1      1      1
o12 = S  <-- S  <-- S  <-- S  <-- S
                                   
      0      1      2      3      0

o12 : ZZdFactorization
 
i13 : C3'.dd

           1             1
o13 = 3 : S  <--------- S  : 0
                | a |

           1             1
      0 : S  <--------- S  : 1
                | b |

           1             1
      1 : S  <--------- S  : 2
                | c |

           1             1
      2 : S  <--------- S  : 3
                | d |

o13 : ZZdFactorizationMap

Caveat

This constructor minimizes computation and does very little error checking. To verify that a factorization is well constructed, use isWellDefined(ZZdFactorization).

See also

Ways to use this method:

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