File size: 13,976 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 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 | import OAI.AlgebraicGeometry.AbelianModuli.ReferenceFamily.Regular.CechGenerator
import OAI.AlgebraicGeometry.AbelianModuli.ReferenceFamily.Cech.PairCoordinates
/-! # Local -/
namespace OAI.AlgebraicGeometry.AbelianModuli.ReferenceFamily.Cech.Local
noncomputable section
section
/-! Degree-zero Cech coordinates restrict to their literal regular
functions on any open contained in the chosen frame domain. -/
open _root_.CategoryTheory _root_.AlgebraicGeometry
variable {X : Scheme.{0}} {I : Type} (U : I β X.Opens)
theorem cechZeroIndex_eq (a : Fin 1 β I) : a = PairCoordinates.cechSingletonIndex (a 0) := by
funext k
have hk : k = 0 := Subsingleton.elim _ _
subst k
rfl
def cechZeroValueOn (W : X.Opens) (a : Ξ(TermModules.cechTermModule X U 0, W)) (j : I)
(V : X.Opens) (hVW : V β€ W) (hVj : V β€ U j) : Ξ(X, V) :=
X.presheaf.map (homOfLE (le_inf hVW (hVj.trans (PairCoordinates.cechIntersection_singleton U j).ge))).op
(ExtensionCoordinates.cechCoefficient U 0 W a (PairCoordinates.cechSingletonIndex j))
theorem cechZeroRestrictedCoefficient_congr (W : X.Opens) (s : Ξ(TermModules.cechTermModule X U 0, W))
{a b : Fin 1 β I} (hab : a = b) (V : X.Opens)
(ha : V β€ W β ExtensionCoordinates.cechIntersection U 0 a) (hb : V β€ W β ExtensionCoordinates.cechIntersection U 0 b) :
X.presheaf.map (homOfLE ha).op (ExtensionCoordinates.cechCoefficient U 0 W s a) =
X.presheaf.map (homOfLE hb).op (ExtensionCoordinates.cechCoefficient U 0 W s b) := by
cases hab
rfl
theorem cechZeroValueOn_restrict (W : X.Opens) (a : Ξ(TermModules.cechTermModule X U 0, W)) (j : I)
{V Z : X.Opens} (hZV : Z β€ V) (hVW : V β€ W) (hVj : V β€ U j) :
X.presheaf.map (homOfLE hZV).op (cechZeroValueOn U W a j V hVW hVj) =
cechZeroValueOn U W a j Z (hZV.trans hVW) (hZV.trans hVj) :=
ConcreteCategory.congr_hom (X.presheaf.map_comp _ _).symm _
theorem cechZeroValueOn_same (W : X.Opens) (a : Ξ(TermModules.cechTermModule X U 0, W)) (j : I) :
cechZeroValueOn U W a j (W β ExtensionCoordinates.cechIntersection U 0 (PairCoordinates.cechSingletonIndex j)) inf_le_left
(inf_le_right.trans (PairCoordinates.cechIntersection_singleton U j).le) =
ExtensionCoordinates.cechCoefficient U 0 W a (PairCoordinates.cechSingletonIndex j) := by
change X.presheaf.map (π (.op (W β ExtensionCoordinates.cechIntersection U 0 (PairCoordinates.cechSingletonIndex j)))) _ = _
exact ConcreteCategory.congr_hom (X.presheaf.map_id _) _
theorem cechZeroValueOn_coefficient (W : X.Opens) (s : Ξ(TermModules.cechTermModule X U 0, W)) (a : Fin 1 β I) :
cechZeroValueOn U W s (a 0) (W β ExtensionCoordinates.cechIntersection U 0 a) inf_le_left
(inf_le_right.trans (Regular.CechGenerator.cechIntersection_le_component U 0 a 0)) = ExtensionCoordinates.cechCoefficient U 0 W s a := by
have h := cechZeroRestrictedCoefficient_congr U W s (cechZeroIndex_eq a)
(W β ExtensionCoordinates.cechIntersection U 0 a) le_rfl
(le_inf inf_le_left ((inf_le_right.trans (Regular.CechGenerator.cechIntersection_le_component U 0 a 0)).trans
(PairCoordinates.cechIntersection_singleton U (a 0)).ge))
exact h.symm.trans (ConcreteCategory.congr_hom (X.presheaf.map_id _) _)
theorem cechZeroValueOn_smul (W : X.Opens) (s : Ξ(X, W)) (a : Ξ(TermModules.cechTermModule X U 0, W))
(j : I) (V : X.Opens) (hVW : V β€ W) (hVj : V β€ U j) :
cechZeroValueOn U W (s β’ a) j V hVW hVj =
X.presheaf.map (homOfLE hVW).op s * cechZeroValueOn U W a j V hVW hVj := by
unfold cechZeroValueOn
rw [ExtensionCoordinates.cechCoefficient_smul, map_mul]
congr 1
exact ConcreteCategory.congr_hom (X.presheaf.map_comp _ _).symm s
theorem cechZeroValueOn_generator (r : Regular.TransitionCocycle.RegularTransitionCoefficients U) (j : I)
(W : X.Opens) (hW : W β€ U j) (i : I) (V : X.Opens) (hVW : V β€ W) (hVi : V β€ U i) :
cechZeroValueOn U W (Regular.CechGenerator.regularCechGenerator U r j W hW) i V hVW hVi =
(Regular.TransitionCocycle.regularTransitionOn U r j i V (hVW.trans hW) hVi).val := by
unfold cechZeroValueOn
rw [Regular.CechGenerator.regularCechGenerator_coefficient, Regular.CechGenerator.regularTransitionOn_restrict_val]
rfl
theorem cechZeroValueOn_generator_self (r : Regular.TransitionCocycle.RegularTransitionCoefficients U)
(hr : Regular.TransitionCocycle.RegularTransitionCocycle U r) (j : I) (W : X.Opens) (hW : W β€ U j) :
cechZeroValueOn U W (Regular.CechGenerator.regularCechGenerator U r j W hW) j W le_rfl hW = 1 := by
rw [cechZeroValueOn_generator]
exact congrArg Units.val (Regular.TransitionCocycle.regularTransition_self_on U r hr j W hW)
end
section
/-! Compatible original Cech coordinates satisfy the literal
pairwise transition equation on every smaller algebraic overlap. -/
open _root_.CategoryTheory _root_.AlgebraicGeometry
variable {X : Scheme.{0}} {I : Type} (U : I β X.Opens) (r : Regular.TransitionCocycle.RegularTransitionCoefficients U)
theorem cechCompatible_pair_values (W : X.Opens) (a : Ξ(TermModules.cechTermModule X U 0, W))
(ha : LineSections.CechLineCompatible U (Regular.CechGenerator.regularCechCoefficients U r) W a)
(i j : I) (V : X.Opens) (hVW : V β€ W) (hVi : V β€ U i) (hVj : V β€ U j) :
cechZeroValueOn U W a j V hVW hVj =
(Regular.TransitionCocycle.regularTransitionOn U r i j V hVi hVj).val * cechZeroValueOn U W a i V hVW hVi := by
let b := PairCoordinates.cechPairIndex i j
have hV : V β€ W β ExtensionCoordinates.cechIntersection U 1 b :=
le_inf hVW ((le_inf hVi hVj).trans (PairCoordinates.cechIntersection_pair U i j).ge)
have h := congrArg (X.presheaf.map (homOfLE hV).op) (ha b)
have hface (k : Fin 2) :
X.presheaf.map (homOfLE hV).op
(X.presheaf.map (homOfLE (inf_le_inf_left W (ExtensionCoordinates.cechIntersection_le_face U 0 k b))).op
(ExtensionCoordinates.cechCoefficient U 0 W a (ExtensionCoordinates.cechFaceIndex 0 k b))) =
X.presheaf.map (homOfLE (hV.trans (inf_le_inf_left W (ExtensionCoordinates.cechIntersection_le_face U 0 k b)))).op
(ExtensionCoordinates.cechCoefficient U 0 W a (ExtensionCoordinates.cechFaceIndex 0 k b)) :=
ConcreteCategory.congr_hom (X.presheaf.map_comp _ _).symm _
have hr : X.presheaf.map (homOfLE hV).op
(X.presheaf.map (homOfLE (show W β ExtensionCoordinates.cechIntersection U 1 b β€ ExtensionCoordinates.cechIntersection U 1 b
from inf_le_right)).op (Regular.CechGenerator.regularCechCoefficients U r b)) =
(Regular.TransitionCocycle.regularTransitionOn U r i j V hVi hVj).val := by
have hp := ConcreteCategory.congr_hom (X.presheaf.map_comp
(homOfLE (show W β ExtensionCoordinates.cechIntersection U 1 b β€ ExtensionCoordinates.cechIntersection U 1 b from inf_le_right)).op
(homOfLE hV).op).symm (Regular.CechGenerator.regularCechCoefficients U r b)
exact hp.trans (Regular.CechGenerator.regularCechCoefficients_restrict U r b (hV.trans inf_le_right))
rw [map_mul, hface 0, hface 1, hr] at h
have h0 : X.presheaf.map
(homOfLE (hV.trans (inf_le_inf_left W (ExtensionCoordinates.cechIntersection_le_face U 0 0 b)))).op
(ExtensionCoordinates.cechCoefficient U 0 W a (ExtensionCoordinates.cechFaceIndex 0 0 b)) = cechZeroValueOn U W a j V hVW hVj :=
cechZeroRestrictedCoefficient_congr U W a (PairCoordinates.cechPairIndex_face_zero i j) V _ _
have h1 : X.presheaf.map
(homOfLE (hV.trans (inf_le_inf_left W (ExtensionCoordinates.cechIntersection_le_face U 0 1 b)))).op
(ExtensionCoordinates.cechCoefficient U 0 W a (ExtensionCoordinates.cechFaceIndex 0 1 b)) = cechZeroValueOn U W a i V hVW hVi :=
cechZeroRestrictedCoefficient_congr U W a (PairCoordinates.cechPairIndex_face_one i j) V _ _
exact h0.symm.trans (h.trans (congrArg ((Regular.TransitionCocycle.regularTransitionOn U r i j V hVi hVj).val * Β·) h1))
end
section
/-! Every compatible local coordinate tuple is uniquely determined
by its chosen coordinate and the constructed cocycle generator. -/
open _root_.CategoryTheory _root_.AlgebraicGeometry
open _root_.TopCat.Sheaf
variable {X : Scheme.{0}} {I : Type} (U : I β X.Opens) (r : Regular.TransitionCocycle.RegularTransitionCoefficients U)
theorem cechCompatible_eq_generator (W : X.Opens) (a : Ξ(TermModules.cechTermModule X U 0, W))
(ha : LineSections.CechLineCompatible U (Regular.CechGenerator.regularCechCoefficients U r) W a) (j : I) (hW : W β€ U j) :
a = cechZeroValueOn U W a j W le_rfl hW β’ Regular.CechGenerator.regularCechGenerator U r j W hW := by
apply (SheafCohomology.Cech.Terms.TopCat.Sheaf.cechTermSectionsAddEquiv (TermModules.structureAbelianSheaf X) U 0 W).injective
funext b
change ExtensionCoordinates.cechCoefficient U 0 W _ b = ExtensionCoordinates.cechCoefficient U 0 W _ b
rw [ExtensionCoordinates.cechCoefficient_smul, Regular.CechGenerator.regularCechGenerator_coefficient]
have hb := cechZeroValueOn_coefficient U W a b
have hp := cechCompatible_pair_values U r W a ha j (b 0) (W β ExtensionCoordinates.cechIntersection U 0 b)
inf_le_left (inf_le_left.trans hW) (inf_le_right.trans (Regular.CechGenerator.cechIntersection_le_component U 0 b 0))
have hj := cechZeroValueOn_restrict U W a j
(show W β ExtensionCoordinates.cechIntersection U 0 b β€ W from inf_le_left) le_rfl hW
exact hb.symm.trans (hp.trans ((congrArg
((Regular.TransitionCocycle.regularTransitionOn U r j (b 0) (W β ExtensionCoordinates.cechIntersection U 0 b) (inf_le_left.trans hW)
(inf_le_right.trans (Regular.CechGenerator.cechIntersection_le_component U 0 b 0))).val * Β·) hj.symm).trans (mul_comm _ _)))
theorem cechGenerator_smul_coordinate (hr : Regular.TransitionCocycle.RegularTransitionCocycle U r)
(j : I) (W : X.Opens) (hW : W β€ U j) (s : Ξ(X, W)) :
cechZeroValueOn U W (s β’ Regular.CechGenerator.regularCechGenerator U r j W hW) j W le_rfl hW = s := by
rw [cechZeroValueOn_smul, cechZeroValueOn_generator_self U r hr, mul_one]
exact ConcreteCategory.congr_hom (X.presheaf.map_id _) s
theorem cechGenerator_smul_injective (hr : Regular.TransitionCocycle.RegularTransitionCocycle U r)
(j : I) (W : X.Opens) (hW : W β€ U j) :
Function.Injective (fun s : Ξ(X, W) => s β’ Regular.CechGenerator.regularCechGenerator U r j W hW) := by
intro s t h
have hv := congrArg (fun a => cechZeroValueOn U W a j W le_rfl hW) h
rw [cechGenerator_smul_coordinate U r hr, cechGenerator_smul_coordinate U r hr] at hv
exact hv
end
/-! The constructed cocycle generator is a basis of the sections
of the actual kernel sheaf on every smaller frame open. -/
open _root_.CategoryTheory _root_.AlgebraicGeometry
variable {X : Scheme.{0}} {I : Type} (U : I β X.Opens) (r : Regular.TransitionCocycle.RegularTransitionCoefficients U)
(hr : Regular.TransitionCocycle.RegularTransitionCocycle U r)
def regularCechLineLocalGenerator (j : I) (W : X.Opens) (hW : W β€ U j) :
Ξ(LineModule.cechLineModule U (Regular.CechGenerator.regularCechCoefficients U r), W) :=
(LineModule.cechLineModule U (Regular.CechGenerator.regularCechCoefficients U r)).presheaf.map (homOfLE hW).op
(Regular.CechGenerator.regularCechLineGenerator U r hr j)
theorem regularCechLineLocalGenerator_inclusion (j : I) (W : X.Opens) (hW : W β€ U j) :
(LineModule.cechLineModuleInclusion U (Regular.CechGenerator.regularCechCoefficients U r)).app W
(regularCechLineLocalGenerator U r hr j W hW) = Regular.CechGenerator.regularCechGenerator U r j W hW := by
have h := ConcreteCategory.congr_hom
((LineModule.cechLineModuleInclusion U (Regular.CechGenerator.regularCechCoefficients U r)).mapPresheaf.naturality (homOfLE hW).op)
(Regular.CechGenerator.regularCechLineGenerator U r hr j)
exact h.trans ((congrArg ((TermModules.cechTermModule X U 0).presheaf.map (homOfLE hW).op)
(Regular.CechGenerator.regularCechLineGenerator_inclusion U r hr j)).trans (Regular.CechGenerator.regularCechGenerator_restrict U r j hW le_rfl))
theorem regularCechLineLocalGenerator_smul_inclusion (j : I) (W : X.Opens) (hW : W β€ U j) (s : Ξ(X, W)) :
(LineModule.cechLineModuleInclusion U (Regular.CechGenerator.regularCechCoefficients U r)).app W
(s β’ regularCechLineLocalGenerator U r hr j W hW) = s β’ Regular.CechGenerator.regularCechGenerator U r j W hW := by
have h := (ModuleKernelSections.moduleSectionLinearMap (LineModule.cechLineModuleInclusion U (Regular.CechGenerator.regularCechCoefficients U r)) W).map_smul
s (regularCechLineLocalGenerator U r hr j W hW)
exact h.trans (congrArg (s β’ Β·) (regularCechLineLocalGenerator_inclusion U r hr j W hW))
theorem regularCechLineLocalGenerator_bijective (j : I) (W : X.Opens) (hW : W β€ U j) :
Function.Bijective (fun s : Ξ(X, W) => s β’ regularCechLineLocalGenerator U r hr j W hW) := by
constructor
Β· intro s t h
apply cechGenerator_smul_injective U r hr j W hW
exact (regularCechLineLocalGenerator_smul_inclusion U r hr j W hW s).symm.trans
((congrArg ((LineModule.cechLineModuleInclusion U (Regular.CechGenerator.regularCechCoefficients U r)).app W) h).trans
(regularCechLineLocalGenerator_smul_inclusion U r hr j W hW t))
Β· intro m
let a := (LineModule.cechLineModuleInclusion U (Regular.CechGenerator.regularCechCoefficients U r)).app W m
have ha : LineSections.CechLineCompatible U (Regular.CechGenerator.regularCechCoefficients U r) W a :=
fun i => LineModule.cechLineModule_section_relation U (Regular.CechGenerator.regularCechCoefficients U r) W m i
let s := cechZeroValueOn U W a j W le_rfl hW
refine β¨s, ?_β©
apply LineSections.cechLineModule_sections_injective U (Regular.CechGenerator.regularCechCoefficients U r) W
exact (regularCechLineLocalGenerator_smul_inclusion U r hr j W hW s).trans
(cechCompatible_eq_generator U r W a ha j hW).symm
end
end OAI.AlgebraicGeometry.AbelianModuli.ReferenceFamily.Cech.Local
|