Macaulay2 » Documentation
Packages » Complexes :: horseshoeResolution(Complex)
next | previous | forward | backward | up | index | toc

horseshoeResolution(Complex) -- make the horseshoe resolution

Synopsis

Description

Given a short exact sequence of modules

$\phantom{WWWW} 0 \leftarrow N \xleftarrow{g} M \xleftarrow{f} L \leftarrow 0, $

the horsehoe lemma produces simultaneous free resolutions of $N$, $M$ and $L$, which form a short exact sequence of complexes. This method returns these two chain complex maps.

We illustrate this method by constructing simultaneous free resolutions of three monomial ideals.

i1 : S = ZZ/101[a,b,c];
 
i2 : I = ideal(a^3, b^3, c^3)

             3   3   3
o2 = ideal (a , b , c )

o2 : Ideal of S
 
i3 : J = I + ideal(a*b*c)

             3   3   3
o3 = ideal (a , b , c , a*b*c)

o3 : Ideal of S
 
i4 : K = I : ideal(a*b*c)

             2   2   2
o4 = ideal (c , b , a )

o4 : Ideal of S
 
i5 : C = complex{
         map(comodule J, comodule I, 1),
         map(comodule I, (comodule K) ** S^{-3}, {{a*b*c}})
         }

o5 = cokernel | a3 b3 c3 abc | <-- cokernel | a3 b3 c3 | <-- cokernel {3} | c2 b2 a2 |
                                                              
     0                             1                         2

o5 : Complex
 
i6 : assert isShortExactSequence C
 
i7 : (beta, alpha) = horseshoeResolution C

           1               2                             2
o7 = (0 : S  <----------- S  : 0                  , 0 : S 
                | 0 1 |                                   
                                                          
           4                             7
      1 : S  <------------------------- S  : 1           7
                {3} | 0 0 0 1 0 0 0 |               1 : S 
                {3} | 0 0 0 0 1 0 0 |                     
                {3} | 0 0 0 0 0 1 0 |                     
                {3} | 0 0 0 0 0 0 1 |                     
                                                          
           6                                 9            
      2 : S  <----------------------------- S  : 2        
                {5} | 0 0 0 1 0 0 0 0 0 |                 
                {5} | 0 0 0 0 1 0 0 0 0 |
                {5} | 0 0 0 0 0 1 0 0 0 |                9
                {6} | 0 0 0 0 0 0 1 0 0 |           2 : S 
                {6} | 0 0 0 0 0 0 0 1 0 |                 
                {6} | 0 0 0 0 0 0 0 0 1 |                 
                                                          
           3                       4                      
      3 : S  <------------------- S  : 3                  
                {7} | 0 1 0 0 |                           
                {7} | 0 0 1 0 |                           
                {7} | 0 0 0 1 |                           
                                                          

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

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

                         3
     <----------------- S  : 2
        {7} | 1 0 0 |
        {7} | 0 1 0 |
        {7} | 0 0 1 |
        {5} | 0 0 0 |
        {5} | 0 0 0 |
        {5} | 0 0 0 |
        {6} | 0 0 0 |
        {6} | 0 0 0 |
        {6} | 0 0 0 |

                     1
     <------------- S  : 3
        {9} | 1 |
        {7} | 0 |
        {7} | 0 |
        {7} | 0 |

o7 : Sequence
 
i8 : assert isShortExactSequence(beta, alpha)
 
i9 : assert(prune HH source alpha == complex C_2)
 
i10 : assert(prune HH target alpha == complex C_1)
 
i11 : assert(prune HH target beta == complex C_0)
 
i12 : assert isFree target alpha

The constructed resolution of the middle term $C_1$ is almost never minimal.

i13 : target alpha

       2      7      9      4
o13 = S  <-- S  <-- S  <-- S
                            
      0      1      2      3

o13 : Complex
 
i14 : freeResolution C_1

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

o14 : Complex
 
i15 : minimize target alpha

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

o15 : Complex

The optional argument LengthLimit allows one to truncate the constructed free resolutions.

i16 : (beta, alpha) = horseshoeResolution(C, LengthLimit => 2)

            1               2                             2
o16 = (0 : S  <----------- S  : 0                  , 0 : S 
                 | 0 1 |                                   
                                                           
            4                             7
       1 : S  <------------------------- S  : 1           7
                 {3} | 0 0 0 1 0 0 0 |               1 : S 
                 {3} | 0 0 0 0 1 0 0 |                     
                 {3} | 0 0 0 0 0 1 0 |                     
                 {3} | 0 0 0 0 0 0 1 |                     
                                                           
            6                                 9            
       2 : S  <----------------------------- S  : 2        
                 {5} | 0 0 0 1 0 0 0 0 0 |                 
                 {5} | 0 0 0 0 1 0 0 0 0 |
                 {5} | 0 0 0 0 0 1 0 0 0 |                9
                 {6} | 0 0 0 0 0 0 1 0 0 |           2 : S 
                 {6} | 0 0 0 0 0 0 0 1 0 |                 
                 {6} | 0 0 0 0 0 0 0 0 1 |                 
                                                           
                                                           
                                                           
                                                           
                                                           
                                                           
                                                           
      -----------------------------------------------------------------------
                      1
      <------------- S  : 0    )
         {3} | 1 |
         {0} | 0 |

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

                          3
      <----------------- S  : 2
         {7} | 1 0 0 |
         {7} | 0 1 0 |
         {7} | 0 0 1 |
         {5} | 0 0 0 |
         {5} | 0 0 0 |
         {5} | 0 0 0 |
         {6} | 0 0 0 |
         {6} | 0 0 0 |
         {6} | 0 0 0 |

o16 : Sequence
 
i17 : assert isShortExactSequence(beta, alpha)
 
i18 : prune HH source alpha

                                           1
o18 = cokernel {3} | c2 b2 a2 | <-- 0 <-- S
                                           
      0                             1     2

o18 : Complex
 
i19 : assert isFree target alpha

See also

Ways to use this method: