minimize(Complex) -- a quasi-isomorphic complex whose terms have minimal rank

Synopsis

Function: minimize
Usage:

D = minimize C
Inputs:
- C, a complex, graded, whose terms are all free modules
Outputs:
- D, a complex, graded, whose terms are all free modules of minimal rank
Consequences:
- The projection morphism $g : C \to D$ is available as g = D.cache.minimizingMap.

Description

This method essentially removes all scalar units from the matrices in the differential of $C$.

We illustrate this in a simple example.

i1 : S = ZZ/32003[a,b];

i2 : I = ideal(a^2-b^2, a*b)

             2    2
o2 = ideal (a  - b , a*b)

o2 : Ideal of S

i3 : C = freeResolution(I, Strategy => Nonminimal)

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

o3 : Complex

i4 : betti C

            0 1 2
o4 = total: 1 3 2
         0: 1 . .
         1: . 2 1
         2: . 1 1

o4 : BettiTally

i5 : D = minimize C

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

o5 : Complex

i6 : assert(isWellDefined D and isHomogeneous D)

i7 : betti D

            0 1 2
o7 = total: 1 2 1
         0: 1 . .
         1: . 2 .
         2: . . 1

o7 : BettiTally

i8 : g = D.cache.minimizingMap

          1             1
o8 = 0 : S  <--------- S  : 0
               | 1 |

          2                      3
     1 : S  <------------------ S  : 1
               {2} | 1 0 -b |
               {2} | 0 1 a  |

          1                   2
     2 : S  <--------------- S  : 2
               {4} | 0 1 |

o8 : ComplexMap

i9 : assert isWellDefined g

i10 : assert(isComplexMorphism g and isQuasiIsomorphism g)

i11 : assert(source g == C)

i12 : assert(target g == D)

i13 : assert(coker g == 0)

The minimal complex $D$ is a direct summand of the original complex $C$. The natural inclusion of $D$ into $C$ can be constructed as follows.

i14 : f = liftMapAlongQuasiIsomorphism(id_D, g)

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

           3                   2
      1 : S  <--------------- S  : 1
                {2} | 1 0 |
                {2} | 0 1 |
                {3} | 0 0 |

           2                 1
      2 : S  <------------- S  : 2
                {3} | a |
                {4} | 1 |

o14 : ComplexMap

i15 : g*f == id_D

o15 = true

i16 : assert(source f == D)

i17 : assert(target f == C)

i18 : assert(ker f == 0)

i19 : f*g

           1             1
o19 = 0 : S  <--------- S  : 0
                | 1 |

           3                      3
      1 : S  <------------------ S  : 1
                {2} | 1 0 -b |
                {2} | 0 1 a  |
                {3} | 0 0 0  |

           2                   2
      2 : S  <--------------- S  : 2
                {3} | 0 a |
                {4} | 0 1 |

o19 : ComplexMap

The chain complex $D$ is a direct summand of $C$, giving rise to a split short exact sequence of chain complexes.

i20 : h = prune canonicalMap(C, ker g)

           3                  1
o20 = 1 : S  <-------------- S  : 1
                {2} | -b |
                {2} | a  |
                {3} | -1 |

           2                 1
      2 : S  <------------- S  : 2
                {3} | 1 |
                {4} | 0 |

o20 : ComplexMap

i21 : assert isShortExactSequence(g, h)

Warning: If the input complex is not homogeneous, then the output is probably not what one would expect.

i22 : S = ZZ/32003[a..d]

o22 = S

o22 : PolynomialRing

i23 : J = ideal(a*b*c-b*c, a*d-c, a^3-d^2*c)

                                    3      2
o23 = ideal (a*b*c - b*c, a*d - c, a  - c*d )

o23 : Ideal of S

i24 : CJ = freeResolution J

       1      4      4      1
o24 = S  <-- S  <-- S  <-- S
                            
      0      1      2      3

o24 : Complex

i25 : assert not isHomogeneous CJ

i26 : D = minimize CJ

       1                            3      1
o26 = S  <-- cokernel | 0    | <-- S  <-- S
                      | 0    |             
      0               | -c+d |     2      3
                      | a-1  |
              
             1

o26 : Complex

i27 : isWellDefined D

o27 = true

i28 : prune HH D == prune HH CJ

o28 = true

Ways to use this method: