Complex Array -- shift a complex or complex map

Synopsis

Operator: SPACE
Usage:

D = C[i]

g = f[i]
Inputs:
- C, a complex, or f, a ComplexMap
- an array, [i], where i is an integer
Outputs:
- D, a complex, or g, a ComplexMap.

Description

The shifted complex $D$ is defined by $D_j = C_{i+j}$ for all $j$ and the sign of the differential is changed if $i$ is odd.

The shifted complex map $g$ is defined by $g_j = f_{i+j}$ for all $j$.

The shift defines a natural automorphism on the category of complexes. Topologists often call the shifted complex $C[1]$ the suspension of $C$.

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

o1 = S

o1 : PolynomialRing

i2 : C = freeResolution coker vars S

      1      4      6      4      1
o2 = S  <-- S  <-- S  <-- S  <-- S
                                  
     0      1      2      3      4

o2 : Complex

i3 : dd^C_3

o3 = {2} | c  d  0  0  |
     {2} | -b 0  d  0  |
     {2} | a  0  0  d  |
     {2} | 0  -b -c 0  |
     {2} | 0  a  0  -c |
     {2} | 0  0  a  b  |

             6      4
o3 : Matrix S  <-- S

i4 : D = C[1]

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

o4 : Complex

i5 : assert isWellDefined D

i6 : assert(dd^D_2 == -dd^C_3)

In order to shift the complex one step, and not change the differential, one can do the following.

i7 : E = complex(C, Base => -1)

      1      4      6      4      1
o7 = S  <-- S  <-- S  <-- S  <-- S
                                  
     -1     0      1      2      3

o7 : Complex

i8 : assert isWellDefined E

i9 : assert(dd^E_2 == dd^C_3)

The shift operator is functorial, as illustrated below.

i10 : C2 = freeResolution (S^1/(a^2, b^2, c^2, d^2))

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

o10 : Complex

i11 : C3 = freeResolution (S^1/(a^2, b^3, c^4, d^5))

       1      4      6      4      1
o11 = S  <-- S  <-- S  <-- S  <-- S
                                   
      0      1      2      3      4

o11 : Complex

i12 : f2 = extend(C, C2, map(C_0, C2_0, 1))

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

           4                       4
      1 : S  <------------------- S  : 1
                {1} | a 0 0 0 |
                {1} | 0 b 0 0 |
                {1} | 0 0 c 0 |
                {1} | 0 0 0 d |

           6                                 6
      2 : S  <----------------------------- S  : 2
                {2} | ab 0  0  0  0  0  |
                {2} | 0  ac 0  0  0  0  |
                {2} | 0  0  bc 0  0  0  |
                {2} | 0  0  0  ad 0  0  |
                {2} | 0  0  0  0  bd 0  |
                {2} | 0  0  0  0  0  cd |

           4                               4
      3 : S  <--------------------------- S  : 3
                {3} | abc 0   0   0   |
                {3} | 0   abd 0   0   |
                {3} | 0   0   acd 0   |
                {3} | 0   0   0   bcd |

           1                    1
      4 : S  <---------------- S  : 4
                {4} | abcd |

o12 : ComplexMap

i13 : f3 = extend(C2, C3, map(C2_0, C3_0, 1))

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

           4                         4
      1 : S  <--------------------- S  : 1
                {2} | 1 0 0  0  |
                {2} | 0 b 0  0  |
                {2} | 0 0 c2 0  |
                {2} | 0 0 0  d3 |

           6                                    6
      2 : S  <-------------------------------- S  : 2
                {4} | b 0  0   0  0   0    |
                {4} | 0 c2 0   0  0   0    |
                {4} | 0 0  bc2 0  0   0    |
                {4} | 0 0  0   d3 0   0    |
                {4} | 0 0  0   0  bd3 0    |
                {4} | 0 0  0   0  0   c2d3 |

           4                                  4
      3 : S  <------------------------------ S  : 3
                {6} | bc2 0   0    0     |
                {6} | 0   bd3 0    0     |
                {6} | 0   0   c2d3 0     |
                {6} | 0   0   0    bc2d3 |

           1                     1
      4 : S  <----------------- S  : 4
                {8} | bc2d3 |

o13 : ComplexMap

i14 : assert((f2*f3)[1] == (f2[1]) * (f3[1]))

i15 : assert(source(f2[1]) == C2[1])

i16 : assert(target(f2[1]) == C[1])

Ways to use this method: