Download data/lean/OAI/AlgebraicGeometry/Comparison/Betti/Open/PullbackNormalization.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 6.89 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/AlgebraicGeometry/Comparison/Betti/Open/PullbackNormalization.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/AlgebraicGeometry/Comparison/Betti/Open/PullbackNormalization.lean
-
curl -L -o PullbackNormalization.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/AlgebraicGeometry/Comparison/Betti/Open/PullbackNormalization.lean
6.89 kB
| 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 | |