File size: 6,885 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
import OAI.AlgebraicGeometry.Comparison.Betti.Analytification.OpenTrivialization
import OAI.AlgebraicGeometry.Comparison.Betti.AdjunctionComplexUniqueness

/-! # Pullback Normalization -/

namespace OAI.AlgebraicGeometry.Comparison.Betti.Open.PullbackNormalization.RingedModules

noncomputable section

section

/-! Normalization of the actual pullback open frame under its defining
adjunctions. The scalar map is the original unit-to-pushforward map. -/

open _root_.CategoryTheory _root_.CategoryTheory.Limits

variable {C D : Type} [SmallCategory C] [SmallCategory D]
  [HasBinaryProducts C] [HasBinaryProducts D]
  {J : GrothendieckTopology C} {K : GrothendieckTopology D}
  {F : C β₯€ D} [F.IsContinuous J K]
  {S : Sheaf J RingCat.{0}} {R : Sheaf K RingCat.{0}}
  (Ο† : S ⟢ (F.sheafPushforwardContinuous RingCat J K).obj R) (U : C)
  [(Over.post (X := U) F).IsContinuous (J.over U) (K.over (F.obj U))]
  [βˆ€ V, IsIso (prodComparison F U V)]
  [(SheafOfModules.pushforward.{0} Ο†).IsRightAdjoint]
  [(SheafOfModules.pushforward.{0} (OverRingedMorphism.Modules.overStructureMap Ο† U)).IsRightAdjoint]

theorem modulePullbackOverUnitIso_homEquiv (M : SheafOfModules.{0} S)
    (e : M.over U β‰… SheafOfModules.unit (S.over U)) :
    (SheafOfModules.pullbackPushforwardAdjunction Ο†).homEquiv M _
        ((SheafOfModules.overPushforwardOverAdj (R := R) (F.obj U)).homEquiv
          ((SheafOfModules.pullback Ο†).obj M) _ (Analytification.OpenTrivialization.RingedModules.modulePullbackOverUnitIso Ο† U M e).hom) ≫
        (Module.PullbackOver.RingedModules.overPushforwardSquareIso Ο† U).hom.app (SheafOfModules.unit (R.over (F.obj U))) =
      (SheafOfModules.overPushforwardOverAdj (R := S) U).homEquiv M _
        (e.hom ≫ SheafOfModules.unitToPushforwardObjUnit (OverRingedMorphism.Modules.overStructureMap Ο† U)) := by
  have h := AdjunctionComplexUniqueness.leftAdjointUniq_homEquiv
    (((SheafOfModules.pullbackPushforwardAdjunction Ο†).comp
      (SheafOfModules.overPushforwardOverAdj (R := R) (F.obj U))).ofNatIsoRight
        (Module.PullbackOver.RingedModules.overPushforwardSquareIso Ο† U))
    ((SheafOfModules.overPushforwardOverAdj (R := S) U).comp
      (SheafOfModules.pullbackPushforwardAdjunction (OverRingedMorphism.Modules.overStructureMap Ο† U)))
    ((SheafOfModules.pullback (OverRingedMorphism.Modules.overStructureMap Ο† U)).map e.hom ≫
      SheafOfModules.pullbackObjUnitToUnit (OverRingedMorphism.Modules.overStructureMap Ο† U))
  rw [Adjunction.homEquiv_ofNatIsoRight_apply, Adjunction.comp_homEquiv,
    Adjunction.comp_homEquiv] at h
  exact h.trans (congrArg ((SheafOfModules.overPushforwardOverAdj (R := S) U).homEquiv M _)
    (((SheafOfModules.pullbackPushforwardAdjunction (OverRingedMorphism.Modules.overStructureMap Ο† U)).homEquiv_naturality_left
      e.hom (SheafOfModules.pullbackObjUnitToUnit (OverRingedMorphism.Modules.overStructureMap Ο† U))).trans
        (congrArg (fun f => e.hom ≫ f)
          (SheafOfModules.pullbackPushforwardAdjunction_homEquiv_pullbackObjUnitToUnit
            (OverRingedMorphism.Modules.overStructureMap Ο† U)))))

end

section

/-! Section formulas for the original open-slice adjunction and the normalized
pullback square. These expose the actual restriction maps in an open frame. -/

open _root_.CategoryTheory _root_.CategoryTheory.Limits Opposite

section OpenAdjunction

variable {C : Type} [SmallCategory C] [HasBinaryProducts C]
  {J : GrothendieckTopology C} (S : Sheaf J RingCat.{0}) (U : C)

theorem overModuleHomEquiv_apply (M : SheafOfModules.{0} S)
    (N : SheafOfModules.{0} (S.over U)) (g : M.over U ⟢ N)
    (V : Cα΅’α΅–) (m : M.val.obj V) :
    (((SheafOfModules.overPushforwardOverAdj (R := S) U).homEquiv M N g).val.app V) m =
      g.val.app (op ((Over.star U).obj V.unop)) (M.val.map prod.snd.op m) := by
  erw [Adjunction.homEquiv_apply]
  change g.val.app (op ((Over.star U).obj V.unop))
    (M.val.map ((Over.forgetAdjStar U).counit.app V.unop).op m) = _
  rw [Over.forgetAdjStar_counit_app]
  rfl

end OpenAdjunction

variable {C D : Type} [SmallCategory C] [SmallCategory D]
  [HasBinaryProducts C] [HasBinaryProducts D]
  {J : GrothendieckTopology C} {K : GrothendieckTopology D}
  {F : C β₯€ D} [F.IsContinuous J K]
  {S : Sheaf J RingCat.{0}} {R : Sheaf K RingCat.{0}}
  (Ο† : S ⟢ (F.sheafPushforwardContinuous RingCat J K).obj R) (U : C)
  [(Over.post (X := U) F).IsContinuous (J.over U) (K.over (F.obj U))]
  [βˆ€ V, IsIso (prodComparison F U V)]

theorem overPushforwardSquareIso_apply (N : SheafOfModules.{0} (R.over (F.obj U)))
    (V : Cα΅’α΅–)
    (a : ((SheafOfModules.pushforward.{0} Ο†).obj
      ((SheafOfModules.pushforward (SheafOfModules.pushforwardOver (R := R) (F.obj U))).obj N)).val.obj V) :
    ((Module.PullbackOver.RingedModules.overPushforwardSquareIso Ο† U).hom.app N).val.app V a =
      N.val.map ((OverProduct.RingedModules.overStarPostIso F U).hom.app V.unop).op a := rfl

end

/-! Restricting the product used by the over-site along its diagonal recovers
the original frame coordinate. -/

open _root_.CategoryTheory _root_.CategoryTheory.Limits Opposite

variable {C D : Type} [SmallCategory C] [SmallCategory D]
  [HasBinaryProducts C] [HasBinaryProducts D]

theorem prodComparison_map_diagonal (F : C β₯€ D) (U : C) :
    F.map (prod.lift (πŸ™ U) (πŸ™ U)) ≫ prodComparison F U U =
      prod.lift (πŸ™ (F.obj U)) (πŸ™ (F.obj U)) := by
  apply prod.hom_ext
  Β· rw [Category.assoc, prodComparison_fst, ← F.map_comp, prod.lift_fst, F.map_id, prod.lift_fst]
  Β· rw [Category.assoc, prodComparison_snd, ← F.map_comp, prod.lift_snd, F.map_id, prod.lift_snd]

variable {J : GrothendieckTopology C} (S : Sheaf J RingCat.{0}) (U : C)

theorem moduleSection_diagonal (M : SheafOfModules.{0} S) (m : M.val.obj (op U)) :
    M.val.map (prod.lift (πŸ™ U) (πŸ™ U)).op
      (M.val.map (prod.snd : U ⨯ U ⟢ U).op m) = m := by
  rw [← PresheafOfModules.map_comp_apply, ← op_comp, prod.lift_snd, op_id, M.val.map_id]
  rfl

theorem openFrame_diagonal (M : SheafOfModules.{0} S)
    (e : M.over U β‰… SheafOfModules.unit (S.over U)) (m : M.val.obj (op U)) :
    S.obj.map (prod.lift (πŸ™ U) (πŸ™ U)).op
        (e.hom.val.app (op ((Over.star U).obj U)) (M.val.map (prod.snd : U ⨯ U ⟢ U).op m)) =
      e.hom.val.app (op (Over.mk (πŸ™ U))) m := by
  let f : Over.mk (πŸ™ U) ⟢ (Over.star U).obj U :=
    Over.homMk (prod.lift (πŸ™ U) (πŸ™ U)) (by
      change prod.lift (πŸ™ U) (πŸ™ U) ≫ (prod.lift prod.fst (πŸ™ (U β¨― U)) ≫ prod.fst) = πŸ™ U
      rw [prod.lift_fst, prod.lift_fst])
  have h := PresheafOfModules.naturality_apply e.hom.val f.op
    (M.val.map (prod.snd : U ⨯ U ⟢ U).op m)
  exact h.symm.trans (congrArg (fun a => e.hom.val.app (op (Over.mk (πŸ™ U))) a)
    (moduleSection_diagonal S U M m))

end

end OAI.AlgebraicGeometry.Comparison.Betti.Open.PullbackNormalization.RingedModules