math / data /lean /OAI /AlgebraicGeometry /HilbertScheme /Presentations /Homogeneous /LocalizationFlat.lean
Download data/lean/OAI/AlgebraicGeometry/HilbertScheme/Presentations/Homogeneous/LocalizationFlat.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 7.54 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/AlgebraicGeometry/HilbertScheme/Presentations/Homogeneous/LocalizationFlat.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/AlgebraicGeometry/HilbertScheme/Presentations/Homogeneous/LocalizationFlat.lean
-
curl -L -o LocalizationFlat.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/AlgebraicGeometry/HilbertScheme/Presentations/Homogeneous/LocalizationFlat.lean
7.54 kB
| import Mathlib.RingTheory.GradedAlgebra.HomogeneousLocalization | |
| import Mathlib.RingTheory.Flat.EquationalCriterion | |
| /-! # Localization Flat -/ | |
| namespace OAI.AlgebraicGeometry.HilbertScheme.Presentations.Homogeneous.LocalizationFlat.GradedHilbert | |
| noncomputable section | |
| /-! | |
| Flatness of a homogeneous affine chart follows from flatness of the | |
| sufficiently high graded pieces. Finite relations admit a common | |
| denominator, and become relations in one high graded piece after one | |
| further multiplication by the chart coordinate. | |
| -/ | |
| open _root_.HomogeneousLocalization | |
| universe u v | |
| variable {R : Type u} [CommRing R] {A : Type v} [CommRing A] [Algebra R A] | |
| variable (π : β β Submodule R A) [GradedAlgebra π] | |
| instance homogeneousLocalizationModule (P : Submonoid A) : | |
| Module R (HomogeneousLocalization π P) := | |
| Function.Injective.module R β¨β¨HomogeneousLocalization.val, HomogeneousLocalization.val_zeroβ©, | |
| HomogeneousLocalization.val_addβ© (HomogeneousLocalization.val_injective P) | |
| (HomogeneousLocalization.val_smul P) | |
| instance homogeneousLocalizationBaseAlgebra (P : Submonoid A) : | |
| Algebra R (HomogeneousLocalization π P) := | |
| Algebra.ofModule | |
| (fun r x y => HomogeneousLocalization.val_injective P (by | |
| simp only [HomogeneousLocalization.val_mul, HomogeneousLocalization.val_smul, smul_mul_assoc])) | |
| (fun r x y => HomogeneousLocalization.val_injective P (by | |
| simp only [HomogeneousLocalization.val_mul, HomogeneousLocalization.val_smul, mul_smul_comm])) | |
| theorem homogeneousLocalization_algebraMap (P : Submonoid A) : | |
| algebraMap R (HomogeneousLocalization π P) = | |
| (HomogeneousLocalization.fromZeroRingHom π P).comp (algebraMap R (π 0)) := by | |
| apply RingHom.ext | |
| intro r | |
| apply HomogeneousLocalization.val_injective | |
| rw [Algebra.algebraMap_eq_smul_one, HomogeneousLocalization.val_smul, | |
| HomogeneousLocalization.val_one] | |
| change r β’ (1 : Localization P) = Localization.mk ((algebraMap R (π 0) r).val) 1 | |
| rw [Localization.mk_eq_mk', IsLocalization.mk'_one] | |
| rw [Algebra.algebraMap_eq_smul_one (R := R) (A := π 0)] | |
| change r β’ (1 : Localization P) = algebraMap A (Localization P) (r β’ 1) | |
| simp only [Algebra.smul_def, mul_one] | |
| exact IsScalarTower.algebraMap_apply R A (Localization P) r | |
| variable {π} {s : A} (hs : s β π 1) | |
| def degreeFraction (d : β) (f : π d) : HomogeneousLocalization.Away π s := | |
| HomogeneousLocalization.Away.mk π hs d f.val (by simpa only [smul_eq_mul, mul_one] using f.property) | |
| theorem val_degreeFraction (d : β) (f : π d) : | |
| (degreeFraction hs d f).val = algebraMap A (Localization.Away s) f.val * | |
| IsLocalization.Away.invSelf s ^ d := by | |
| erw [degreeFraction, HomogeneousLocalization.Away.val_mk, | |
| Localization.mk_eq_mk', IsLocalization.mk'_eq_iff_eq_mul] | |
| rw [map_pow, mul_assoc, β mul_pow, mul_comm (IsLocalization.Away.invSelf s), | |
| IsLocalization.Away.mul_invSelf, one_pow, mul_one] | |
| def degreeFractionLinear (d : β) : π d ββ[R] HomogeneousLocalization.Away π s where | |
| toFun := degreeFraction hs d | |
| map_add' f g := by | |
| apply HomogeneousLocalization.val_injective | |
| rw [HomogeneousLocalization.val_add, val_degreeFraction, val_degreeFraction, val_degreeFraction] | |
| simp only [Submodule.coe_add, map_add, add_mul] | |
| map_smul' r f := by | |
| apply HomogeneousLocalization.val_injective | |
| rw [HomogeneousLocalization.val_smul, val_degreeFraction, val_degreeFraction] | |
| simp only [Submodule.coe_smul, Algebra.algebraMap_eq_smul_one, smul_mul_assoc, | |
| IsScalarTower.smul_assoc] | |
| rfl | |
| def degreeTransition (d e : β) (hde : d β€ e) : π d ββ[R] π e where | |
| toFun f := β¨s ^ (e - d) * f.val, by | |
| have h := SetLike.mul_mem_graded (SetLike.pow_mem_graded (e - d) hs) f.property | |
| simpa only [smul_eq_mul, mul_one, Nat.sub_add_cancel hde] using hβ© | |
| map_add' f g := Subtype.ext (mul_add _ _ _) | |
| map_smul' r f := Subtype.ext (mul_smul_comm _ _ _) | |
| theorem degreeFraction_transition (d e : β) (hde : d β€ e) (f : π d) : | |
| degreeFractionLinear hs e (degreeTransition hs d e hde f) = degreeFractionLinear hs d f := by | |
| apply HomogeneousLocalization.val_injective | |
| change (degreeFraction hs e _).val = (degreeFraction hs d f).val | |
| erw [degreeFraction, degreeFraction, HomogeneousLocalization.Away.val_mk, | |
| HomogeneousLocalization.Away.val_mk] | |
| rw [Localization.mk_eq_mk_iff, Localization.r_iff_exists] | |
| refine β¨1, ?_β© | |
| change 1 * (s ^ d * (s ^ (e - d) * f.val)) = 1 * (s ^ e * f.val) | |
| rw [one_mul, one_mul, β mul_assoc, β pow_add, Nat.add_sub_of_le hde] | |
| theorem degreeFraction_eq_zero_iff (d : β) (f : π d) : | |
| degreeFractionLinear hs d f = 0 β β k : β, s ^ k * f.val = 0 := by | |
| change degreeFraction hs d f = 0 β _ | |
| erw [degreeFraction, HomogeneousLocalization.ext_iff_val, | |
| HomogeneousLocalization.val_zero, HomogeneousLocalization.Away.val_mk, | |
| Localization.mk_eq_mk', IsLocalization.mk'_eq_zero_iff] | |
| constructor | |
| Β· rintro β¨t, htβ© | |
| obtain β¨k, hkβ© := t.property | |
| rw [β hk] at ht | |
| exact β¨k, htβ© | |
| Β· rintro β¨k, hkβ© | |
| exact β¨β¨s ^ k, β¨k, rflβ©β©, hkβ© | |
| theorem degreeFraction_common_denominator {ΞΉ : Type*} [Fintype ΞΉ] | |
| (x : ΞΉ β HomogeneousLocalization.Away π s) (N : β) : | |
| β d β₯ N, β f : ΞΉ β π d, β i, degreeFractionLinear hs d (f i) = x i := by | |
| classical | |
| have hx (i : ΞΉ) : β d : β, β f : π d, degreeFractionLinear hs d f = x i := by | |
| obtain β¨d, f, hf, hfxβ© := HomogeneousLocalization.Away.mk_surjective π hs (x i) | |
| have hf' : f β π d := by simpa only [smul_eq_mul, mul_one] using hf | |
| exact β¨d, β¨f, hf'β©, hfxβ© | |
| choose b f hf using hx | |
| let d := max N (Finset.univ.sup b) | |
| have hb (i : ΞΉ) : b i β€ d := | |
| (Finset.le_sup (f := b) (Finset.mem_univ i)).trans (le_max_right _ _) | |
| refine β¨d, le_max_left _ _, fun i => degreeTransition hs (b i) d (hb i) (f i), fun i => ?_β© | |
| exact (degreeFraction_transition hs (b i) d (hb i) (f i)).trans (hf i) | |
| include hs in | |
| /-- A chart of a graded algebra is flat over the coefficient ring if its | |
| sufficiently high homogeneous pieces are flat. -/ | |
| theorem homogeneousLocalization_flat_of_eventually_flat | |
| (N : β) (hflat : β d β₯ N, Module.Flat R (π d)) : | |
| Module.Flat R (HomogeneousLocalization.Away π s) := by | |
| classical | |
| apply Module.Flat.of_forall_isTrivialRelation | |
| intro l a x hx | |
| obtain β¨d, hd, f, hfβ© := degreeFraction_common_denominator hs x N | |
| have hsum : degreeFractionLinear hs d (β i, a i β’ f i) = 0 := by | |
| simpa only [map_sum, map_smul, hf] using hx | |
| obtain β¨k, hkβ© := (degreeFraction_eq_zero_iff hs d _).mp hsum | |
| let t := degreeTransition hs d (d + k) (Nat.le_add_right _ _) | |
| have ht : β i, a i β’ t (f i) = 0 := by | |
| simp_rw [β map_smul] | |
| rw [β map_sum] | |
| apply Subtype.ext | |
| change s ^ (d + k - d) * (β i, a i β’ f i).val = 0 | |
| simpa only [Nat.add_sub_cancel_left] using hk | |
| have : Module.Flat R (π (d + k)) := hflat _ (hd.trans (Nat.le_add_right _ _)) | |
| obtain β¨m, b, y, hxy, hbβ© := Module.Flat.isTrivialRelation_of_sum_smul_eq_zero ht | |
| refine β¨m, b, fun j => degreeFractionLinear hs (d + k) (y j), fun i => ?_, hbβ© | |
| have h := congrArg (degreeFractionLinear hs (d + k)) (hxy i) | |
| rw [map_sum] at h | |
| simp only [map_smul] at h | |
| exact ((degreeFraction_transition hs d (d + k) (Nat.le_add_right _ _) (f i)).trans (hf i)).symm.trans h | |
| end | |
| end OAI.AlgebraicGeometry.HilbertScheme.Presentations.Homogeneous.LocalizationFlat.GradedHilbert | |