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