| import Mathlib |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| namespace CampanaPeternellSix.RelativeCech |
| section |
| open scoped TensorProduct |
| universe u |
| variable {R : Type u} [CommRing R] (p : Ideal R) [p.IsPrime] |
| lemma clear_residue_denominator (c : p.ResidueField) : |
| ∃ d : R, d ∉ p ∧ ∃ a : R, algebraMap R p.ResidueField d * c = algebraMap R p.ResidueField a := by |
| obtain ⟨x,rfl⟩ := IsLocalRing.residue_surjective (R := Localization.AtPrime p) c |
| obtain ⟨⟨a,d⟩,rfl⟩ := IsLocalization.mk'_surjective p.primeCompl x |
| refine ⟨d,d.property,a,?_⟩ |
| simpa only [IsScalarTower.algebraMap_apply R (Localization.AtPrime p) p.ResidueField, |
| IsLocalRing.ResidueField.algebraMap_eq, map_mul] using |
| congrArg (IsLocalRing.residue (Localization.AtPrime p)) |
| (IsLocalization.mk'_spec' (Localization.AtPrime p) a d) |
|
|
| variable {M N : Type u} [AddCommGroup M] [Module R M] [AddCommGroup N] |
| [Module R N] [Module p.ResidueField N] [IsScalarTower R p.ResidueField N] |
| lemma clear_section_denominator (f : M →ₗ[R] N) (hf : IsBaseChange p.ResidueField f) (x : N) : |
| ∃ d : R, d ∉ p ∧ ∃ a : M, f a = algebraMap R p.ResidueField d • x := by |
| induction x using hf.inductionOn with |
| | tmul m => exact ⟨1, p.primeCompl.one_mem, m, by simp⟩ |
| | add x y hx hy => |
| obtain ⟨d,hd,a,ha⟩ := hx |
| obtain ⟨e,he,b,hb⟩ := hy |
| refine ⟨d*e,p.primeCompl.mul_mem hd he,e • a + d • b,?_⟩ |
| simp only [map_add,map_smul,ha,hb,map_mul,smul_add,mul_smul] |
| rw [← IsScalarTower.algebraMap_smul p.ResidueField e, ← IsScalarTower.algebraMap_smul p.ResidueField d] |
| simp only [smul_comm (algebraMap R p.ResidueField e) (algebraMap R p.ResidueField d)] |
| | smul c x hx => |
| obtain ⟨d,hd,a,ha⟩ := hx |
| obtain ⟨e,he,b,hb⟩ := clear_residue_denominator p c |
| refine ⟨d*e,p.primeCompl.mul_mem hd he,b • a,?_⟩ |
| rw [map_smul,ha,← IsScalarTower.algebraMap_smul p.ResidueField b,← hb,map_mul] |
| simp only [mul_smul,smul_comm (algebraMap R p.ResidueField d)] |
| end |
|
|
| open scoped BigOperators TensorProduct |
| universe u |
| variable {R : Type u} [CommRing R] (p : Ideal R) [p.IsPrime] |
| variable {M N : Type u} [AddCommGroup M] [Module R M] [AddCommGroup N] |
| [Module R N] [Module p.ResidueField N] [IsScalarTower R p.ResidueField N] |
| theorem clear_finite_sections_denominator (f : M →ₗ[R] N) (hf : IsBaseChange p.ResidueField f) |
| (I : Type u) [Finite I] (s : I → N) : |
| ∃ d : R, d ∉ p ∧ ∃ t : I → M, ∀ i, f (t i) = algebraMap R p.ResidueField d • s i := by |
| classical |
| let := Fintype.ofFinite I |
| choose d hd t ht using fun i => clear_section_denominator p f hf (s i) |
| refine ⟨∏ i, d i, ?_, fun i => (∏ j ∈ Finset.univ.erase i, d j) • t i, ?_⟩ |
| · exact p.primeCompl.prod_mem (fun i _ => hd i) |
| · intro i |
| rw [map_smul,ht,← IsScalarTower.algebraMap_smul p.ResidueField] |
| rw [← mul_smul,← map_mul,Finset.prod_erase_mul _ _ (Finset.mem_univ i)] |
| end CampanaPeternellSix.RelativeCech |
|
|
| namespace CampanaPeternellSix.FiberFrame |
| section |
| open CategoryTheory AlgebraicGeometry Opposite |
| universe u |
| variable {X : Scheme.{u}} (E : X.Modules) |
| def sectionsTopEquiv : E.sections ≃ Γ(E,⊤) where |
| toFun s := s.val (op ⊤) |
| invFun x := E.val.sectionsMk (fun U => E.val.map (homOfLE (show U.unop ≤ ⊤ from le_top)).op x) |
| (fun U V f => by |
| erw [← PresheafOfModules.map_comp_apply] |
| rfl) |
| left_inv s := by |
| apply PresheafOfModules.sections_ext |
| intro U |
| exact s.property (homOfLE (show U.unop ≤ ⊤ from le_top)).op |
| right_inv x := by |
| change E.val.map (𝟙 (op ⊤)) x = x |
| simp |
| rfl |
| lemma sectionsTopEquiv_naturality {F : X.Modules} (f : E ⟶ F) (s : E.sections) : |
| sectionsTopEquiv F (SheafOfModules.sectionsMap f s) = f.app ⊤ (sectionsTopEquiv E s) := rfl |
| lemma sectionsTopEquiv_symm_apply (s : Γ(E,⊤)) (U : X.Opens) : |
| ((sectionsTopEquiv E).symm s).val (op U) = E.val.map (homOfLE (show U ≤ ⊤ from le_top)).op s := rfl |
| end |
|
|
| section |
| open CategoryTheory AlgebraicGeometry Opposite |
| open Scheme.Modules TopologicalSpace |
| universe u |
| variable {X Y : Scheme.{u}} (f : X ⟶ Y) {E : Y.Modules} {I : Type u} |
| instance inverseOpens_final : (Opens.map f.base).Final := by |
| let F := Opens.map f.base |
| let : (Functor.fromPUnit.{0} (⊤ : Y.Opens)).Final := |
| Functor.final_fromPUnit_of_isTerminal Limits.isTerminalTop |
| let : (Functor.fromPUnit.{0} (⊤ : X.Opens)).Final := |
| Functor.final_fromPUnit_of_isTerminal Limits.isTerminalTop |
| let : (Functor.fromPUnit.{0} (⊤ : Y.Opens) ⋙ F).Final := |
| Functor.final_of_natIso (F := Functor.fromPUnit.{0} (⊤ : X.Opens)) |
| (Discrete.natIso (fun _ => eqToIso (by simp [F]))) |
| exact Functor.final_of_final_comp (Functor.fromPUnit.{0} (⊤ : Y.Opens)) F |
|
|
| abbrev pullbackFreeIso : (pullback f).obj (SheafOfModules.free (R := Y.ringCatSheaf) I) ≅ |
| SheafOfModules.free I := by |
| letI : (SheafOfModules.pushforward f.toRingCatSheafHom).IsRightAdjoint := |
| (pullbackPushforwardAdjunction f).isRightAdjoint |
| exact SheafOfModules.pullbackObjFreeIso f.toRingCatSheafHom I |
| lemma pullbackFree_sections (α : SheafOfModules.free I ⟶ E) (i : I) : |
| SheafOfModules.pushforwardSections f.toRingCatSheafHom |
| (((pullback f).obj E).freeHomEquiv ((pullbackFreeIso f).inv ≫ (pullback f).map α) i) = |
| SheafOfModules.sectionsMap ((pullbackPushforwardAdjunction f).unit.app E) |
| (E.freeHomEquiv α i) := by |
| let : (SheafOfModules.pushforward f.toRingCatSheafHom).IsRightAdjoint := |
| (pullbackPushforwardAdjunction f).isRightAdjoint |
| let F := pullback f |
| let G := pushforward f |
| let A := pullbackPushforwardAdjunction f |
| let u := SheafOfModules.pullbackObjUnitToUnit f.toRingCatSheafHom |
| let γ := (pullbackFreeIso f).inv ≫ F.map α |
| have h : F.map (SheafOfModules.ιFree i ≫ α) = u ≫ SheafOfModules.ιFree i ≫ γ := by |
| dsimp [γ, u, F, pullbackFreeIso] |
| erw [Functor.map_comp] |
| erw [← SheafOfModules.pullback_map_ιFree_comp_pullbackObjFreeIso_hom_assoc] |
| erw [Iso.hom_inv_id_assoc] |
| rfl |
| have ha := congrArg (A.homEquiv _ _) h |
| have hb : A.homEquiv _ _ u = SheafOfModules.unitToPushforwardObjUnit f.toRingCatSheafHom := |
| SheafOfModules.pullbackPushforwardAdjunction_homEquiv_pullbackObjUnitToUnit _ |
| erw [Adjunction.homEquiv_naturality_right, hb] at ha |
| have hc : A.homEquiv _ _ (F.map (SheafOfModules.ιFree i ≫ α)) = |
| (SheafOfModules.ιFree i ≫ α) ≫ A.unit.app E := by |
| erw [Adjunction.homEquiv_unit] |
| exact (A.unit.naturality _).symm |
| erw [hc] at ha |
| change SheafOfModules.pushforwardSections _ |
| (((pullback f).obj E).unitHomEquiv (SheafOfModules.ιFree i ≫ γ)) = _ |
| erw [SheafOfModules.pushforwardSections_unitHomEquiv] |
| exact (congrArg (((pushforward f).obj ((pullback f).obj E)).unitHomEquiv) ha.symm).trans |
| (SheafOfModules.unitHomEquiv_comp_apply _ _) |
| end |
|
|
| section |
| open CategoryTheory AlgebraicGeometry Opposite |
| open Scheme.Modules |
| universe u |
| variable {X Y : Scheme.{u}} (f : X ⟶ Y) {E : Y.Modules} {I : Type u} |
| lemma pullbackFree_top (α : SheafOfModules.free I ⟶ E) (i : I) : |
| ((pullback f).obj E).presheaf.map |
| (homOfLE (show (⊤ : X.Opens) ≤ f ⁻¹ᵁ ⊤ by simp)).op |
| (((pullbackPushforwardAdjunction f).unit.app E).app ⊤ |
| (sectionsTopEquiv E (E.freeHomEquiv α i))) = |
| sectionsTopEquiv ((pullback f).obj E) |
| (((pullback f).obj E).freeHomEquiv ((pullbackFreeIso f).inv ≫ (pullback f).map α) i) := by |
| let s := ((pullback f).obj E).freeHomEquiv ((pullbackFreeIso f).inv ≫ (pullback f).map α) i |
| let v := (homOfLE (show (⊤ : X.Opens) ≤ f ⁻¹ᵁ ⊤ by simp)).op |
| have h := congrArg (fun t : ((pushforward f).obj ((pullback f).obj E)).sections => |
| ((pullback f).obj E).presheaf.map v (t.val (op ⊤))) (pullbackFree_sections f α i) |
| change ((pullback f).obj E).val.map v (s.val (op (f ⁻¹ᵁ ⊤))) = _ at h |
| exact h.symm.trans (s.property v) |
| end |
|
|
| open CategoryTheory AlgebraicGeometry Opposite |
| universe u |
| variable {X : Scheme.{u}} (E : X.Modules) |
| def scalarEnd (a : Γ(X,⊤)) : E ⟶ E where |
| val.app U := ModuleCat.ofHom |
| { toFun := fun m => @SMul.smul (X.ringCatSheaf.obj.obj U) (E.val.obj U) inferInstance |
| (X.presheaf.map (homOfLE (show U.unop ≤ ⊤ from le_top)).op a) m |
| map_add' := fun m n => by |
| change Γ(E,U.unop) at m n |
| exact smul_add (M := Γ(X,U.unop)) (A := Γ(E,U.unop)) _ m n |
| map_smul' := fun b m => by |
| change Γ(X,U.unop) at b |
| change Γ(E,U.unop) at m |
| change (X.presheaf.map (homOfLE (show U.unop ≤ ⊤ from le_top)).op a) • (b • m) = |
| b • ((X.presheaf.map (homOfLE (show U.unop ≤ ⊤ from le_top)).op a) • m) |
| exact smul_comm _ _ _ } |
| val.naturality {U V} f := by |
| ext m |
| change Γ(E,U.unop) at m |
| change @SMul.smul Γ(X,V.unop) Γ(E,V.unop) inferInstance |
| (X.presheaf.map (homOfLE (show V.unop ≤ ⊤ from le_top)).op a) (E.val.map f m) = |
| E.val.map f (@SMul.smul Γ(X,U.unop) Γ(E,U.unop) inferInstance |
| (X.presheaf.map (homOfLE (show U.unop ≤ ⊤ from le_top)).op a) m) |
| erw [E.val.map_smul] |
| congr 1 |
| exact ConcreteCategory.congr_hom (X.presheaf.map_comp _ _) a |
| lemma scalarEnd_app (a : Γ(X,⊤)) (U : X.Opens) (m : Γ(E,U)) : |
| (scalarEnd E a).app U m = |
| (X.presheaf.map (homOfLE (show U ≤ ⊤ from le_top)).op a) • m := rfl |
| lemma scalarEnd_app_top (a : Γ(X,⊤)) (m : Γ(E,⊤)) : |
| (scalarEnd E a).app ⊤ m = a • m := by |
| change (X.presheaf.map (𝟙 (op ⊤)) a) • m = _ |
| simp |
| lemma scalarEnd_mul (a b : Γ(X,⊤)) : scalarEnd E a ≫ scalarEnd E b = scalarEnd E (a*b) := by |
| apply Scheme.Modules.hom_ext |
| intro U |
| ext m |
| simp only [Scheme.Modules.Hom.comp_app, ConcreteCategory.comp_apply, scalarEnd_app, map_mul] |
| rw [mul_smul,smul_comm] |
| lemma scalarEnd_one : scalarEnd E 1 = 𝟙 E := by |
| apply Scheme.Modules.hom_ext |
| intro U |
| ext m |
| simp [scalarEnd_app] |
| def scalarIso (a : Γ(X,⊤)ˣ) : E ≅ E where |
| hom := scalarEnd E a |
| inv := scalarEnd E ↑a⁻¹ |
| hom_inv_id := by rw [scalarEnd_mul,Units.mul_inv,scalarEnd_one] |
| inv_hom_id := by rw [scalarEnd_mul,Units.inv_mul,scalarEnd_one] |
| end CampanaPeternellSix.FiberFrame |
|
|
| end |
|
|
| end OAI |
|
|
