File size: 7,540 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 | 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
|