File size: 6,073 Bytes
4a56cd6
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
/-
Copyright 2026 The Formal Conjectures Authors.
Released under Apache 2.0 license as described in the file LICENSE.
This file has been modified.
-/
import Mathlib.Algebra.Homology.Embedding.Extend
import Mathlib.Algebra.Homology.Additive

/-! # Map Extend -/

namespace OAI.Algebra.Homology.MapExtend.HomologicalComplex

noncomputable section

open _root_.HomologicalComplex

/-!
# Applying an additive functor commutes with extension of a complex

The comparison is the identity in retained degrees and the canonical isomorphism between
zero objects in newly inserted degrees. In particular it fixes the normalization when
regrading a chain complex by `n ↦ -n` before or after a sheaf functor.
-/

open _root_.CategoryTheory Limits

section Single

variable {C : Type*} [Category* C] [Preadditive C] [HasZeroObject C]
  {I J : Type*} {c : ComplexShape I} {c' : ComplexShape J}

/-- Extending a complex supported in one degree is natural in the object placed there. -/
@[reassoc]
lemma extendSingleIso_hom_naturality
    [DecidableEq I] [DecidableEq J] (e : c.Embedding c') {A B : C} (f : A ⟶ B)
    (i : I) (j : J) (h : e.f i = j) :
    extendMap ((single C c i).map f) e ≫ (extendSingleIso e B i j h).hom =
      (extendSingleIso e A i j h).hom ≫ (single C c' j).map f := by
  apply hom_ext
  intro k
  by_cases hk : k = j
  · subst k
    simp only [comp_f, extendMap_f _ e h, extendSingleIso_hom_f, single_map_f_self]
    simp
  · exact (isZero_single_obj_X c' j B k hk).eq_of_tgt _ _

end Single

variable {C D : Type*} [Category* C] [Category* D] [Preadditive C] [Preadditive D]
  [HasZeroObject C] [HasZeroObject D] (F : C ⥤ D) [F.Additive]
  {I J : Type*} {c : ComplexShape I} {c' : ComplexShape J}
  (K : HomologicalComplex C c) (e : c.Embedding c')

/-- Degreewise comparison: identity on retained degrees, canonical zero-object comparison
on inserted degrees. -/
def mapExtendCanonicalXIso (a : Option I) :
    F.obj (extend.X K a) ≅ extend.X ((F.mapHomologicalComplex c).obj K) a :=
  match a with
  | some _ => Iso.refl _
  | none => (F.map_isZero (Limits.isZero_zero C)).isoZero

set_option backward.isDefEq.respectTransparency false in
set_option backward.defeqAttrib.useBackward true in
@[reassoc]
lemma mapExtendCanonicalXIso_hom_d (a b : Option I) :
    (mapExtendCanonicalXIso F K a).hom ≫ extend.d ((F.mapHomologicalComplex c).obj K) a b =
      F.map (extend.d K a b) ≫ (mapExtendCanonicalXIso F K b).hom := by
  cases a <;> cases b <;>
    simp [mapExtendCanonicalXIso, extend.d, Functor.mapHomologicalComplex_obj_d]

/-- The canonical chain-complex comparison between functorial mapping and extension. -/
def mapExtendCanonicalIso :
    (F.mapHomologicalComplex c').obj (K.extend e) ≅
      ((F.mapHomologicalComplex c).obj K).extend e :=
  Hom.isoOfComponents (fun j => mapExtendCanonicalXIso F K (e.r j))
    (fun j k _ => mapExtendCanonicalXIso_hom_d F K (e.r j) (e.r k))

set_option backward.isDefEq.respectTransparency false in
set_option backward.defeqAttrib.useBackward true in
/-- In a degree coming from the original complex, the comparison is the identity through the
canonical extension identifications, including any grading transports. -/
lemma mapExtendCanonicalIso_hom_f {i : I} {j : J} (h : e.f i = j) :
    (mapExtendCanonicalIso F K e).hom.f j =
      F.map (K.extendXIso e h).hom ≫
        (((F.mapHomologicalComplex c).obj K).extendXIso e h).inv := by
  change (mapExtendCanonicalXIso F K (e.r j)).hom =
    F.map (extend.XIso K (e.r_eq_some h)).hom ≫
      (extend.XIso ((F.mapHomologicalComplex c).obj K) (e.r_eq_some h)).inv
  have H (a : Option I) (ha : a = some i) :
      (mapExtendCanonicalXIso F K a).hom = F.map (extend.XIso K ha).hom ≫
        (extend.XIso ((F.mapHomologicalComplex c).obj K) ha).inv := by
    subst a
    simp [mapExtendCanonicalXIso, extend.XIso]
    rfl
  exact H _ _

set_option backward.isDefEq.respectTransparency false in
set_option backward.defeqAttrib.useBackward true in
/-- Naturality of the degreewise comparison in a chain map. -/
lemma mapExtendCanonicalXIso_hom_mapX {L : HomologicalComplex C c} (f : K ⟶ L) (a : Option I) :
    F.map (extend.mapX f a) ≫ (mapExtendCanonicalXIso F L a).hom =
      (mapExtendCanonicalXIso F K a).hom ≫ extend.mapX ((F.mapHomologicalComplex c).map f) a := by
  cases a <;> simp [mapExtendCanonicalXIso, extend.mapX]

/-- Mapping and extension commute on chain maps, with the canonical normalization. -/
@[reassoc]
lemma mapExtendCanonicalIso_naturality {L : HomologicalComplex C c} (f : K ⟶ L) :
    (F.mapHomologicalComplex c').map (extendMap f e) ≫ (mapExtendCanonicalIso F L e).hom =
      (mapExtendCanonicalIso F K e).hom ≫ extendMap ((F.mapHomologicalComplex c).map f) e := by
  ext j
  exact mapExtendCanonicalXIso_hom_mapX F K f (e.r j)

set_option backward.isDefEq.respectTransparency false in
set_option backward.defeqAttrib.useBackward true in
/-- Compatibility with a natural transformation of additive coefficient functors. -/
@[reassoc]
lemma mapExtendCanonicalIso_natTrans {G : C ⥤ D} [G.Additive] (a : F ⟶ G) :
    (a.mapHomologicalComplex c').app (K.extend e) ≫ (mapExtendCanonicalIso G K e).hom =
      (mapExtendCanonicalIso F K e).hom ≫ extendMap ((a.mapHomologicalComplex c).app K) e := by
  ext j
  change a.app (extend.X K (e.r j)) ≫ (mapExtendCanonicalXIso G K (e.r j)).hom =
    (mapExtendCanonicalXIso F K (e.r j)).hom ≫
      extend.mapX ((a.mapHomologicalComplex c).app K) (e.r j)
  cases hr : e.r j with
  | none => exact (F.map_isZero (Limits.isZero_zero C)).eq_of_src _ _
  | some n => simp [mapExtendCanonicalXIso, extend.X, extend.mapX]

/-- The comparison for the identity coefficient functor is the identity. -/
@[simp]
lemma mapExtendCanonicalIso_id : (mapExtendCanonicalIso (𝟭 C) K e).hom = 𝟙 (K.extend e) := by
  ext j
  change (mapExtendCanonicalXIso (𝟭 C) K (e.r j)).hom = 𝟙 (extend.X K (e.r j))
  cases hr : e.r j with
  | none => exact (Limits.isZero_zero C).eq_of_src _ _
  | some n => rfl

end

end OAI.Algebra.Homology.MapExtend.HomologicalComplex