Download data/lean/OAI/AlgebraicGeometry/Seshadri/Projective/SectionMaps.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 15.8 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/AlgebraicGeometry/Seshadri/Projective/SectionMaps.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/AlgebraicGeometry/Seshadri/Projective/SectionMaps.lean
-
curl -L -o SectionMaps.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/AlgebraicGeometry/Seshadri/Projective/SectionMaps.lean
15.8 kB
| import Mathlib | |
| import OAI.AlgebraicGeometry.Seshadri.Projective.PolynomialCharts | |
| import OAI.AlgebraicGeometry.Seshadri.Sheaves.SectionOpens | |
| namespace OAI | |
| section | |
| noncomputable section | |
| noncomputable section | |
| open CategoryTheory | |
| open CategoryTheory.Category CategoryTheory.Functor | |
| universe v u vβ vβ uβ uβ | |
| namespace MaximalSeshadri.Projective | |
| noncomputable section | |
| open AlgebraicGeometry CategoryTheory HomogeneousLocalization | |
| variable {A R Ο : Type u} [CommRing A] [CommRing R] [SetLike Ο A] | |
| [AddSubgroupClass Ο A] {π : β β Ο} [GradedRing π] | |
| (f : A β+* R) | |
| def evalAway (s : A) (hs : IsUnit (f s)) : Away π s β+* R := | |
| (IsLocalization.Away.lift s hs : Localization.Away s β+* R).comp | |
| (algebraMap (Away π s) (Localization.Away s)) | |
| lemma evalAway_val (s : A) (hs : IsUnit (f s)) (x : Away π s) : | |
| evalAway f s hs x = IsLocalization.Away.lift s hs x.val := rfl | |
| lemma evalAway_transition {s t : A} {d : β} (ht : t β π d) | |
| (hs : IsUnit (f s)) (hst : IsUnit (f (s * t))) : | |
| (evalAway f (s * t) hst).comp (awayMap π ht rfl) = evalAway f s hs := by | |
| have hunit : IsUnit (algebraMap A (Localization.Away (s * t)) s) := | |
| IsLocalization.Away.isUnit_of_dvd (s * t) (dvd_mul_right s t) | |
| have H : (IsLocalization.Away.lift (s * t) hst : Localization.Away (s * t) β+* R).comp | |
| (Localization.awayLift (algebraMap A (Localization.Away (s * t))) s hunit) = | |
| (IsLocalization.Away.lift s hs : Localization.Away s β+* R) := by | |
| apply IsLocalization.ringHom_ext (Submonoid.powers s) | |
| ext a | |
| simp | |
| apply RingHom.ext | |
| intro x | |
| simpa only [RingHom.comp_apply, evalAway_val, val_awayMap] using RingHom.congr_fun H x.val | |
| lemma evalAway_natural {T : Type u} [CommRing T] (g : R β+* T) | |
| (s : A) (hs : IsUnit (f s)) : | |
| g.comp (evalAway (π := π) f s hs) = evalAway (g.comp f) s (hs.map g) := by | |
| have H : g.comp (IsLocalization.Away.lift s hs : Localization.Away s β+* R) = | |
| (IsLocalization.Away.lift (g := g.comp f) s (hs.map g) : Localization.Away s β+* T) := by | |
| apply IsLocalization.ringHom_ext (Submonoid.powers s) | |
| ext a | |
| simp | |
| exact congrArg (fun h : Localization.Away s β+* T => | |
| h.comp (algebraMap (Away π s) (Localization.Away s))) H | |
| lemma evalAway_mk_clear {s : A} {d : β} (hs : s β π d) (hu : IsUnit (f s)) | |
| (n : β) (a : A) (ha : a β π (n β’ d)) : | |
| evalAway f s hu (Away.mk π hs n a ha) * f s ^ n = f a := by | |
| rw [evalAway_val, Away.val_mk, Localization.mk_eq_mk'] | |
| have H := IsLocalization.mk'_spec (Localization.Away s) a | |
| (β¨s ^ n, β¨n, rflβ©β© : Submonoid.powers s) | |
| apply_fun (IsLocalization.Away.lift s hu : Localization.Away s β+* R) at H | |
| simpa only [map_mul, IsLocalization.Away.lift_eq, map_pow] using H | |
| lemma evalAway_scale {s : A} {d : β} (hs : s β π d) (hu : IsUnit (f s)) | |
| (g : A β+* R) (hv : IsUnit (g s)) (c : RΛ£) | |
| (hscale : β n a, a β π n β g a = (c : R) ^ n * f a) : | |
| evalAway (π := π) f s hu = evalAway g s hv := by | |
| apply RingHom.ext | |
| intro x | |
| obtain β¨n, a, ha, rflβ© := Away.mk_surjective π hs x | |
| apply (hv.pow n).mul_right_cancel | |
| have Hf := evalAway_mk_clear f hs hu n a ha | |
| have Hg := evalAway_mk_clear g hs hv n a ha | |
| rw [Hg, hscale d s hs, hscale _ a ha, mul_pow, β pow_mul] | |
| rw [smul_eq_mul, Nat.mul_comm n d] | |
| calc | |
| _ = (c : R) ^ (d * n) * (evalAway f s hu (Away.mk π hs n a ha) * f s ^ n) := by ring | |
| _ = _ := by rw [Hf] | |
| def fromUnitCoordinate {s : A} {d : β} (hd : 0 < d) (hs : s β π d) | |
| (hu : IsUnit (f s)) : Spec (CommRingCat.of R) βΆ Proj π := | |
| Spec.map (CommRingCat.ofHom (evalAway f s hu)) β« Proj.awayΞΉ π s hs hd | |
| lemma fromUnitCoordinate_mul {s t : A} {d e : β} (hd : 0 < d) | |
| (hs : s β π d) (ht : t β π e) (hu : IsUnit (f s)) | |
| (hut : IsUnit (f (s * t))) : | |
| fromUnitCoordinate f hd hs hu = | |
| fromUnitCoordinate f (Nat.add_pos_left hd e) (SetLike.mul_mem_graded hs ht) hut := by | |
| unfold fromUnitCoordinate | |
| rw [β Proj.SpecMap_awayMap_awayΞΉ π hs hd ht rfl, β Category.assoc, | |
| β Spec.map_comp, β CommRingCat.ofHom_comp, evalAway_transition f ht hu hut] | |
| @[reassoc] | |
| lemma fromUnitCoordinate_natural {T : Type u} [CommRing T] (g : R β+* T) | |
| {s : A} {d : β} (hd : 0 < d) (hs : s β π d) (hu : IsUnit (f s)) : | |
| Spec.map (CommRingCat.ofHom g) β« fromUnitCoordinate f hd hs hu = | |
| fromUnitCoordinate (g.comp f) hd hs (hu.map g) := by | |
| unfold fromUnitCoordinate | |
| rw [β Category.assoc, β Spec.map_comp, β CommRingCat.ofHom_comp, evalAway_natural] | |
| lemma fromUnitCoordinate_scale {s : A} {d : β} (hd : 0 < d) | |
| (hs : s β π d) (hu : IsUnit (f s)) (g : A β+* R) (hv : IsUnit (g s)) | |
| (c : RΛ£) (hscale : β n a, a β π n β g a = (c : R) ^ n * f a) : | |
| fromUnitCoordinate f hd hs hu = fromUnitCoordinate g hd hs hv := by | |
| unfold fromUnitCoordinate | |
| rw [evalAway_scale f hs hu g hv c hscale] | |
| lemma fromUnitCoordinate_preimage {s t : A} {e : β} (hs : s β π 1) | |
| (hu : IsUnit (f s)) (hsone : f s = 1) (he : 0 < e) (ht : t β π e) : | |
| fromUnitCoordinate f (by decide) hs hu β»ΒΉα΅ Proj.basicOpen π t = | |
| PrimeSpectrum.basicOpen (f t) := by | |
| rw [fromUnitCoordinate, Scheme.Hom.comp_preimage, | |
| Proj.awayΞΉ_preimage_basicOpen π hs (by decide) ht he, SpecMap_preimage_basicOpen] | |
| congr 1 | |
| change evalAway f s hu (Away.isLocalizationElem hs ht) = f t | |
| have H := evalAway_mk_clear f hs hu e (t ^ 1) | |
| (show t ^ 1 β π (e β’ 1) from by simpa using ht) | |
| simpa only [Away.isLocalizationElem, hsone, one_pow, mul_one, pow_one] using H | |
| theorem fromUnitCoordinate_eq {s t : A} {d e : β} (hd : 0 < d) (he : 0 < e) | |
| (hs : s β π d) (ht : t β π e) (hu : IsUnit (f s)) (hv : IsUnit (f t)) : | |
| fromUnitCoordinate f hd hs hu = fromUnitCoordinate f he ht hv := by | |
| have huv : IsUnit (f (s * t)) := by rw [map_mul]; exact hu.mul hv | |
| have hvu : IsUnit (f (t * s)) := by rw [map_mul]; exact hv.mul hu | |
| rw [fromUnitCoordinate_mul f hd hs ht hu huv, | |
| fromUnitCoordinate_mul f he ht hs hv hvu] | |
| congr 1 <;> ac_rfl | |
| open MvPolynomial | |
| end | |
| noncomputable section | |
| open AlgebraicGeometry CategoryTheory CategoryTheory.Limits MvPolynomial TopologicalSpace | |
| variable {K Ο : Type u} [CommRing K] | |
| attribute [local instance] MvPolynomial.gradedAlgebra | |
| lemma coordinates_X_mem (i : Ο) : MvPolynomial.X i β homogeneousSubmodule Ο K 1 := | |
| isHomogeneous_X K i | |
| def coordinatesMap (X : Scheme.{u}) (k : K β+* Ξ(X, β€)) (a : Ο β Ξ(X, β€)) | |
| (i : Ο) (hi : a i = 1) : X βΆ Proj (homogeneousSubmodule Ο K) := | |
| X.toSpecΞ β« fromUnitCoordinate (evalβHom k a) (by decide) | |
| (coordinates_X_mem (K := K) i) (by simpa only [evalβHom_X', hi] using isUnit_one) | |
| lemma coordinates_eval_natural {R T : Type u} [CommRing R] [CommRing T] | |
| (g : R β+* T) (k : K β+* R) (a : Ο β R) : | |
| g.comp (evalβHom k a) = evalβHom (g.comp k) (fun j => g (a j)) := by | |
| apply MvPolynomial.ringHom_ext <;> intro j <;> simp | |
| @[reassoc] | |
| lemma coordinatesMap_natural {X Y : Scheme.{u}} (Ο : Y βΆ X) | |
| (k : K β+* Ξ(X, β€)) (a : Ο β Ξ(X, β€)) (i : Ο) (hi : a i = 1) : | |
| Ο β« coordinatesMap X k a i hi = | |
| coordinatesMap Y (Ο.appTop.hom.comp k) (fun j => Ο.appTop (a j)) i | |
| (by simp only [hi, map_one]) := by | |
| unfold coordinatesMap | |
| rw [β Category.assoc, Scheme.toSpecΞ_naturality, Category.assoc, | |
| ] | |
| congr 1 | |
| change Spec.map (CommRingCat.ofHom Ο.appTop.hom) β« _ = _ | |
| rw [fromUnitCoordinate_natural] | |
| congr 1 | |
| exact coordinates_eval_natural Ο.appTop.hom k a | |
| lemma coordinatesMap_scale (X : Scheme.{u}) (k : K β+* Ξ(X, β€)) | |
| (a b : Ο β Ξ(X, β€)) (i j : Ο) (hi : a i = 1) (hj : b j = 1) | |
| (c : Ξ(X, β€)Λ£) (hscale : β q, b q = (c : Ξ(X, β€)) * a q) : | |
| coordinatesMap X k a i hi = coordinatesMap X k b j hj := by | |
| let f := evalβHom k a | |
| let g := evalβHom k b | |
| have hf : IsUnit (f (MvPolynomial.X (R := K) i)) := by | |
| simpa only [f, evalβHom_X', hi] using (isUnit_one : IsUnit (1 : Ξ(X, β€))) | |
| have hg : IsUnit (g (MvPolynomial.X (R := K) i)) := by | |
| simpa only [g, evalβHom_X', hscale i, hi, mul_one] using c.isUnit | |
| have hg' : IsUnit (g (MvPolynomial.X (R := K) j)) := by | |
| simpa only [g, evalβHom_X', hj] using (isUnit_one : IsUnit (1 : Ξ(X, β€))) | |
| have H : β n p, p β homogeneousSubmodule Ο K n β | |
| g p = (c : Ξ(X, β€)) ^ n * f p := by | |
| intro n p hp | |
| change evalβ k b p = _ | |
| have hb : b = fun q => (c : Ξ(X, β€)) * a q := funext hscale | |
| rw [hb] | |
| exact homogeneous_evalβ_scale hp k a c | |
| unfold coordinatesMap | |
| congr 1 | |
| exact (fromUnitCoordinate_scale (π := homogeneousSubmodule Ο K) (d := 1) f (by decide) (coordinates_X_mem (K := K) i) | |
| hf g hg c H).trans | |
| (fromUnitCoordinate_eq (π := homogeneousSubmodule Ο K) (d := 1) (e := 1) g (by decide) (by decide) | |
| (coordinates_X_mem (K := K) i) (coordinates_X_mem (K := K) j) hg hg') | |
| lemma coordinatesMap_preimage (X : Scheme.{u}) (k : K β+* Ξ(X, β€)) | |
| (a : Ο β Ξ(X, β€)) (i : Ο) (hi : a i = 1) (j : Ο) : | |
| coordinatesMap X k a i hi β»ΒΉα΅ | |
| Proj.basicOpen (homogeneousSubmodule Ο K) (MvPolynomial.X j) = X.basicOpen (a j) := by | |
| rw [coordinatesMap, Scheme.Hom.comp_preimage, | |
| fromUnitCoordinate_preimage _ (coordinates_X_mem (K := K) i) _ | |
| (by simpa only [evalβHom_X'] using hi) (by decide) (coordinates_X_mem (K := K) j), | |
| evalβHom_X', Scheme.toSpecΞ_preimage_basicOpen] | |
| structure CoordinateAtlas (X : Scheme.{u}) where | |
| cover : X.OpenCover | |
| scalars : β i : cover.Iβ, K β+* Ξ(cover.X i, β€) | |
| coordinates : β i : cover.Iβ, Ο β Ξ(cover.X i, β€) | |
| index : cover.Iβ β Ο | |
| normalized : β i, coordinates i (index i) = 1 | |
| scalarOverlap : β i j, | |
| (pullback.fst (cover.f i) (cover.f j)).appTop.hom.comp (scalars i) = | |
| (pullback.snd (cover.f i) (cover.f j)).appTop.hom.comp (scalars j) | |
| coordinateOverlap : β i j, | |
| β c : Ξ(pullback (cover.f i) (cover.f j), β€)Λ£, β q, | |
| (pullback.snd (cover.f i) (cover.f j)).appTop (coordinates j q) = | |
| (c : Ξ(pullback (cover.f i) (cover.f j), β€)) * | |
| (pullback.fst (cover.f i) (cover.f j)).appTop (coordinates i q) | |
| variable {X : Scheme.{u}} (D : CoordinateAtlas (K := K) (Ο := Ο) X) | |
| def CoordinateAtlas.localMap (i : D.cover.Iβ) : | |
| D.cover.X i βΆ Proj (homogeneousSubmodule Ο K) := | |
| coordinatesMap _ (D.scalars i) (D.coordinates i) (D.index i) (D.normalized i) | |
| lemma CoordinateAtlas.compatible (i j : D.cover.Iβ) : | |
| pullback.fst (D.cover.f i) (D.cover.f j) β« D.localMap i = | |
| pullback.snd (D.cover.f i) (D.cover.f j) β« D.localMap j := by | |
| unfold CoordinateAtlas.localMap | |
| rw [coordinatesMap_natural, coordinatesMap_natural] | |
| obtain β¨c, hcβ© := D.coordinateOverlap i j | |
| simpa only [D.scalarOverlap i j] using | |
| coordinatesMap_scale _ | |
| ((pullback.fst (D.cover.f i) (D.cover.f j)).appTop.hom.comp (D.scalars i)) | |
| _ _ (D.index i) (D.index j) | |
| (by simp only [D.normalized, map_one]) | |
| (by simp only [D.normalized, map_one]) c hc | |
| def CoordinateAtlas.morphism : X βΆ Proj (homogeneousSubmodule Ο K) := | |
| D.cover.glueMorphisms D.localMap D.compatible | |
| @[reassoc, simp] | |
| lemma CoordinateAtlas.cover_morphism (i : D.cover.Iβ) : | |
| D.cover.f i β« D.morphism = D.localMap i := | |
| D.cover.ΞΉ_glueMorphisms _ _ i | |
| end | |
| noncomputable section | |
| open AlgebraicGeometry CategoryTheory CategoryTheory.Limits TopologicalSpace | |
| open scoped AlgebraicGeometry | |
| open MaximalSeshadri.Frames | |
| attribute [local instance] MvPolynomial.gradedAlgebra | |
| variable {K Ο : Type u} [CommRing K] {X : Scheme.{u}} | |
| def atlasOfFramedSections {M : X.Modules} (k : K β+* Ξ(X, β€)) | |
| (s : Ο β (O X βΆ M)) (π° : X.OpenCover) | |
| (e : β i, M.restrict (π°.f i) β O (π°.X i)) (index : π°.Iβ β Ο) | |
| (hnorm : β i, coefficient (e i) (restrictSection (π°.f i) (s (index i))) = 1) : | |
| CoordinateAtlas (K := K) (Ο := Ο) X where | |
| cover := π° | |
| scalars i := (π°.f i).appTop.hom.comp k | |
| coordinates i q := coefficient (e i) (restrictSection (π°.f i) (s q)) | |
| index := index | |
| normalized := hnorm | |
| scalarOverlap i j := by | |
| rw [β RingHom.comp_assoc, β RingHom.comp_assoc] | |
| congr 1 | |
| simpa only [Scheme.Hom.comp_appTop, CommRingCat.hom_comp] using | |
| congrArg (fun f : pullback (π°.f i) (π°.f j) βΆ X => f.appTop.hom) | |
| (pullback.condition (f := π°.f i) (g := π°.f j)) | |
| coordinateOverlap i j := by | |
| obtain β¨c, hcβ© := overlap_coefficients (π°.f i) (π°.f j) | |
| (pullback.fst (π°.f i) (π°.f j)) (pullback.snd (π°.f i) (π°.f j)) | |
| (pullback.condition (f := π°.f i) (g := π°.f j)) (e i) (e j) | |
| exact β¨c, fun q => hc (s q)β© | |
| def sectionFrame {M : X.Modules} (s : O X βΆ M) : | |
| M.restrict (SectionOpens.isoOpen s).ΞΉ β O (SectionOpens.isoOpen s).toScheme := by | |
| letI := SectionOpens.isIso_restrict_isoOpen s | |
| exact (asIso ((Scheme.Modules.restrictFunctor (SectionOpens.isoOpen s).ΞΉ).map s)).symm βͺβ« | |
| Scheme.Modules.restrictUnitIso (SectionOpens.isoOpen s).ΞΉ | |
| lemma sectionFrame_normalized {M : X.Modules} (s : O X βΆ M) : | |
| coefficient (sectionFrame s) (restrictSection (SectionOpens.isoOpen s).ΞΉ s) = 1 := by | |
| exact coefficient_frame (sectionFrame s) | |
| def sectionsMorphism {M : X.Modules} (k : K β+* Ξ(X, β€)) | |
| (s : Ο β (O X βΆ M)) (hcover : (β¨ i, SectionOpens.isoOpen (s i)) = β€) : | |
| X βΆ Proj (MvPolynomial.homogeneousSubmodule Ο K) := | |
| (atlasOfFramedSections k s | |
| (X.openCoverOfIsOpenCover (fun i => SectionOpens.isoOpen (s i)) hcover) | |
| (fun i => sectionFrame (s i)) id (fun i => sectionFrame_normalized (s i))).morphism | |
| end | |
| end MaximalSeshadri.Projective | |
| namespace MaximalSeshadri.Projective | |
| noncomputable section | |
| open AlgebraicGeometry CategoryTheory TopologicalSpace | |
| open scoped AlgebraicGeometry | |
| open MaximalSeshadri.Frames | |
| variable {K Ο : Type u} [CommRing K] {X : Scheme.{u}} | |
| attribute [local instance] MvPolynomial.gradedAlgebra | |
| lemma sectionsMorphism_local {M : X.Modules} (k : K β+* Ξ(X, β€)) | |
| (s : Ο β (O X βΆ M)) (hcover : (β¨ i, SectionOpens.isoOpen (s i)) = β€) (i : Ο) : | |
| (SectionOpens.isoOpen (s i)).ΞΉ β« sectionsMorphism k s hcover = | |
| coordinatesMap (SectionOpens.isoOpen (s i)).toScheme | |
| ((SectionOpens.isoOpen (s i)).ΞΉ.appTop.hom.comp k) | |
| (fun j => coefficient (sectionFrame (s i)) | |
| (restrictSection (SectionOpens.isoOpen (s i)).ΞΉ (s j))) i | |
| (sectionFrame_normalized (s i)) := by | |
| exact CoordinateAtlas.cover_morphism | |
| (atlasOfFramedSections k s | |
| (X.openCoverOfIsOpenCover (fun a => SectionOpens.isoOpen (s a)) hcover) | |
| (fun a => sectionFrame (s a)) id (fun a => sectionFrame_normalized (s a))) i | |
| theorem sectionsMorphism_preimage {M : X.Modules} (k : K β+* Ξ(X, β€)) | |
| (s : Ο β (O X βΆ M)) (hcover : (β¨ i, SectionOpens.isoOpen (s i)) = β€) (j : Ο) : | |
| sectionsMorphism k s hcover β»ΒΉα΅ | |
| Proj.basicOpen (MvPolynomial.homogeneousSubmodule Ο K) (MvPolynomial.X j) = | |
| SectionOpens.isoOpen (s j) := by | |
| ext x | |
| have hx : x β β¨ i, SectionOpens.isoOpen (s i) := by rw [hcover]; trivial | |
| obtain β¨i, hiβ© := Opens.mem_iSup.mp hx | |
| let U := SectionOpens.isoOpen (s i) | |
| have H : U.ΞΉ β»ΒΉα΅ (sectionsMorphism k s hcover β»ΒΉα΅ | |
| Proj.basicOpen (MvPolynomial.homogeneousSubmodule Ο K) (MvPolynomial.X j)) = | |
| U.ΞΉ β»ΒΉα΅ SectionOpens.isoOpen (s j) := by | |
| rw [β Scheme.Hom.comp_preimage, sectionsMorphism_local, | |
| coordinatesMap_preimage, preimage_isoOpen (s j) U.ΞΉ (sectionFrame (s i))] | |
| exact Set.ext_iff.mp (congrArg SetLike.coe H) (β¨x, hiβ© : U.toScheme) | |
| end | |
| end MaximalSeshadri.Projective | |
| end | |
| end | |
| end | |
| end OAI | |