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

ZZdfactorization -- make a ZZ/d-graded factorization

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.

Often, a factorization is most easily described by giving a list of consecutive maps which form the differentials. If the list consists entirely of ring elements, the constructor will recognize that the user intends to use scalar multiplication as the maps in the factorization.

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 : C2 = ZZdfactorization {a,b,c}

      1      1      1      1
o3 = S  <-- S  <-- S  <-- S
                           
     0      1      2      0

o3 : ZZdFactorization
 
i4 : C3 = ZZdfactorization {a,b,c,d}

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

o4 : ZZdFactorization
 
i5 : period C1

o5 = 2
 
i6 : period C2

o6 = 3
 
i7 : period C3

o7 = 4
 
i8 : isdFactorization C1

o8 = (true, a*b)

o8 : Sequence
 
i9 : isdFactorization C2

o9 = (true, a*b*c)

o9 : Sequence
 
i10 : isdFactorization C3

o10 = (true, a*b*c*d)

o10 : Sequence

To start a factorization at a base different from zero, use the optional argument Base.

i11 : D1 = ZZdfactorization({a,b}, Base => 1)

       1      1      1
o11 = S  <-- S  <-- S
                     
      0      1      0

o11 : ZZdFactorization
 
i12 : isWellDefined D1

o12 = true
 
i13 : isdFactorization D1

o13 = (true, a*b)

o13 : Sequence

Notice that this changes the homological degrees of the maps, but is not the same as the shift of the factorization (which will rescale the maps by roots of unity in general).

i14 : dd^C1

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

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

o14 : ZZdFactorizationMap
 
i15 : dd^(D1[-1])

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

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

o15 : ZZdFactorizationMap

Having constructed this factorization, we can access individual terms and maps.

i16 : C1_2

       1
o16 = S

o16 : S-module, free
 
i17 : C1^(-1)

       1
o17 = S

o17 : S-module, free
 
i18 : C1^(-1) == C1_1

o18 = true
 
i19 : C1_7

       1
o19 = S

o19 : S-module, free
 
i20 : dd^C1

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

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

o20 : ZZdFactorizationMap
 
i21 : dd^C1_2

o21 = | b |

              1      1
o21 : Matrix S  <-- S
 
i22 : period C1

o22 = 2

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 ZZdfactorization:

For the programmer

The object ZZdfactorization is a method function with options.

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