injectiveCover -- Constructs the injective hull of a d-fold matrix factorization

Usage:

injectiveCover(C)
Inputs:
- C, a ZZ/d graded factorization, A ZZdFactorization object representing a d-fold matrix factorization
Outputs:
- a map of ZZ/d-graded factorizations,

Description

This method constructs the injectice cover of a d-fold matrix factorization. The output is a ZZdFactorizationMap, which is the canonical injection from the original factorization into the injective cover.

i1 : Q = ZZ/101[a,b,c];

i2 : C = linearMF(a^3+b^3,t)

     /   Q[t]   \3     /   Q[t]   \3     /   Q[t]   \3     /   Q[t]   \3
o2 = |----------|  <-- |----------|  <-- |----------|  <-- |----------|
     | 2        |      | 2        |      | 2        |      | 2        |
     \t  + t + 1/      \t  + t + 1/      \t  + t + 1/      \t  + t + 1/
                                                            
     0                 1                 2                 0

o2 : ZZdFactorization

i3 : f = injectiveCover C

         /   Q[t]   \9                                    /   Q[t]   \3
o3 = 0 : |----------|  <--------------------------------- |----------|  : 0
         | 2        |     {0, 2} | 1    0       0     |   | 2        |
         \t  + t + 1/     {0, 2} | 0    1       0     |   \t  + t + 1/
                          {0, 2} | 0    0       1     |
                          {0, 2} | b2   abt+ab  a2    |
                          {0, 2} | a2   -b2t-b2 -ab   |
                          {0, 2} | -abt a2      b2t   |
                          {0, 2} | b    a       0     |
                          {0, 2} | 0    bt      a     |
                          {0, 2} | a    0       -bt-b |

         /   Q[t]   \9                                    /   Q[t]   \3
     1 : |----------|  <--------------------------------- |----------|  : 1
         | 2        |     {0, 2} | b    a       0     |   | 2        |
         \t  + t + 1/     {0, 2} | 0    bt      a     |   \t  + t + 1/
                          {0, 2} | a    0       -bt-b |
                          {0, 2} | 1    0       0     |
                          {0, 2} | 0    1       0     |
                          {0, 2} | 0    0       1     |
                          {0, 2} | b2   abt+ab  a2    |
                          {0, 2} | a2   -b2t-b2 -ab   |
                          {0, 2} | -abt a2      b2t   |

         /   Q[t]   \9                                    /   Q[t]   \3
     2 : |----------|  <--------------------------------- |----------|  : 2
         | 2        |     {0, 2} | b2   abt+ab  a2    |   | 2        |
         \t  + t + 1/     {0, 2} | a2   -b2t-b2 -ab   |   \t  + t + 1/
                          {0, 2} | -abt a2      b2t   |
                          {0, 2} | b    a       0     |
                          {0, 2} | 0    bt      a     |
                          {0, 2} | a    0       -bt-b |
                          {0, 2} | 1    0       0     |
                          {0, 2} | 0    1       0     |
                          {0, 2} | 0    0       1     |

o3 : ZZdFactorizationMap

i4 : isCommutative f

o4 = true

i5 : prune ker f

o5 = 0 <-- 0 <-- 0 <-- 0
                        
     0     1     2     0

o5 : ZZdFactorization

i6 : prune coker f

     /   Q[t]   \6     /   Q[t]   \6     /   Q[t]   \6     /   Q[t]   \6
o6 = |----------|  <-- |----------|  <-- |----------|  <-- |----------|
     | 2        |      | 2        |      | 2        |      | 2        |
     \t  + t + 1/      \t  + t + 1/      \t  + t + 1/      \t  + t + 1/
                                                            
     0                 1                 2                 0

o6 : ZZdFactorization

i7 : oo.dd

         /   Q[t]   \6                                 /   Q[t]   \6
o7 = 2 : |----------|  <------------------------------ |----------|  : 0
         | 2        |     | 0 0 0 -b2 -abt-ab -a2  |   | 2        |
         \t  + t + 1/     | 0 0 0 -a2 b2t+b2  ab   |   \t  + t + 1/
                          | 0 0 0 abt -a2     -b2t |
                          | 1 0 0 -b  -a      0    |
                          | 0 1 0 0   -bt     -a   |
                          | 0 0 1 -a  0       bt+b |

         /   Q[t]   \6                                 /   Q[t]   \6
     0 : |----------|  <------------------------------ |----------|  : 1
         | 2        |     | -b2 -abt-ab -a2  0 0 0 |   | 2        |
         \t  + t + 1/     | -a2 b2t+b2  ab   0 0 0 |   \t  + t + 1/
                          | abt -a2     -b2t 0 0 0 |
                          | -b  -a      0    1 0 0 |
                          | 0   -bt     -a   0 1 0 |
                          | -a  0       bt+b 0 0 1 |

         /   Q[t]   \6                                 /   Q[t]   \6
     1 : |----------|  <------------------------------ |----------|  : 2
         | 2        |     | 1 0 0 -b  -a      0    |   | 2        |
         \t  + t + 1/     | 0 1 0 0   -bt     -a   |   \t  + t + 1/
                          | 0 0 1 -a  0       bt+b |
                          | 0 0 0 -b2 -abt-ab -a2  |
                          | 0 0 0 -a2 b2t+b2  ab   |
                          | 0 0 0 abt -a2     -b2t |

o7 : ZZdFactorizationMap

i8 : D = koszulMF(a^3+b^3+c^3)

      4      4      4
o8 = Q  <-- Q  <-- Q
                    
     0      1      0

o8 : ZZdFactorization

i9 : D.dd

          4                        4
o9 = 1 : Q  <-------------------- Q  : 0
               | c2 0  b  a   |
               | 0  c2 a2 -b2 |
               | b2 a  -c 0   |
               | a2 -b 0  -c  |

          4                         4
     0 : Q  <--------------------- Q  : 1
               | c  0  b   a   |
               | 0  c  a2  -b2 |
               | b2 a  -c2 0   |
               | a2 -b 0   -c2 |

o9 : ZZdFactorizationMap

i10 : g = injectiveCover D

           8                        4
o10 = 0 : Q  <-------------------- Q  : 0
                | 1  0  0  0   |
                | 0  1  0  0   |
                | 0  0  1  0   |
                | 0  0  0  1   |
                | c2 0  b  a   |
                | 0  c2 a2 -b2 |
                | b2 a  -c 0   |
                | a2 -b 0  -c  |

           8                         4
      1 : Q  <--------------------- Q  : 1
                | c  0  b   a   |
                | 0  c  a2  -b2 |
                | b2 a  -c2 0   |
                | a2 -b 0   -c2 |
                | 1  0  0   0   |
                | 0  1  0   0   |
                | 0  0  1   0   |
                | 0  0  0   1   |

o10 : ZZdFactorizationMap

i11 : isCommutative g

o11 = true

i12 : F = prune coker g

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

o12 : ZZdFactorization

i13 : oo.dd

           4                         4
o13 = 1 : Q  <--------------------- Q  : 0
                | -c  0  -b  -a |
                | 0   -c -a2 b2 |
                | -b2 -a c2  0  |
                | -a2 b  0   c2 |

           4                          4
      0 : Q  <---------------------- Q  : 1
                | -c2 0   -b  -a |
                | 0   -c2 -a2 b2 |
                | -b2 -a  c   0  |
                | -a2 b   0   c  |

o13 : ZZdFactorizationMap

i14 : F == D[1]

o14 = true

In this case, using the cokernel into the injective cover gives a factorization that is directly equal to the shift of a 2-periodic factorization. In general the cokernel of this inclusion natural defines a suspension functor on the category of d-fold factorizations.

Ways to use injectiveCover:

injectiveCover(ZZdFactorization)

For the programmer

The object injectiveCover is a method function.

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