Stafford38/Geometry/SmoothAffinePointScalarExtension.lean

This project (Stafford38) · 1029fdb382eee06e7b59bcf32801f40931e2079a

1 module
2 public import Mathlib.RingTheory.Smooth.Locus
3 public import Mathlib.RingTheory.Localization.BaseChange
4 public import Mathlib.RingTheory.TensorProduct.MvPolynomial
5 public import Mathlib.RingTheory.TensorProduct.Quotient
6 public import Stafford38.Geometry.SmoothAffineConormal
7 public import Stafford38.Geometry.ScalarExtensionPoints
8 
9 @[expose] public section
10 
11 set_option autoImplicit false
12 
13 /-!
14 # Smooth affine points over the field of an arc
15 
16 A field-valued point of the original affine quotient that avoids a smooth
17 principal open is a genuine Mathlib smooth point.  The argument base-changes
18 the smooth localization to the point's own field, then uses the canonical
19 polynomial-quotient base-change isomorphism.
20 -/
21 
22 namespace Stafford38.Geometry.SmoothAffinePointScalarExtension
23 
24 open Stafford38.Geometry.SmoothAffineConormal
25 open Stafford38.Geometry.ScalarExtensionPoints
26 open TensorProduct
27 
28 noncomputable section
29 
30 variable {k K : Type*} [Field k] [Field K] [Algebra k K] {n : ℕ}
31 
32 private noncomputable def quotientScalarEquiv
33     (I : Ideal (MvPolynomial (Fin n) k)) :
34     (MvPolynomial (Fin n) K ⧸
35       I.map (scalarPolynomialMap (k := k) (K := K) (Fin n))) ≃ₐ[K]
36       K ⊗[k] (MvPolynomial (Fin n) k ⧸ I) := by
37   let P := MvPolynomial (Fin n) k
38   let PK := MvPolynomial (Fin n) K
39   let A := P ⧸ I
40   let IK := I.map (scalarPolynomialMap (k := k) (K := K) (Fin n))
41   let J := I.map (Algebra.TensorProduct.includeRight :
42     P →ₐ[k] K ⊗[k] P)
43   let ePoly : K ⊗[k] P ≃ₐ[K] PK :=
44     MvPolynomial.algebraTensorAlgEquiv k K
45   have hmapAlg :
46       (ePoly.toAlgHom.restrictScalars k).comp
47         (Algebra.TensorProduct.includeRight : P →ₐ[k] K ⊗[k] P) =
48       MvPolynomial.mapAlgHom (Algebra.ofId k K) := by
49     apply MvPolynomial.algHom_ext
50     intro i
51     change ePoly (1 ⊗ₜ[k] (MvPolynomial.X i : P)) =
52       MvPolynomial.map (algebraMap k K) (MvPolynomial.X i)
53     rw [MvPolynomial.algebraTensorAlgEquiv_tmul]
54     simp
55   have hmap : ePoly.toRingHom.comp
56       (Algebra.TensorProduct.includeRight : P →ₐ[k] K ⊗[k] P).toRingHom =
57       scalarPolynomialMap (k := k) (K := K) (Fin n) := by
58     exact congrArg AlgHom.toRingHom hmapAlg
59   have hIJ : IK = J.map ePoly.toRingHom := by
60     change I.map (scalarPolynomialMap (k := k) (K := K) (Fin n)) =
61       (I.map (Algebra.TensorProduct.includeRight : P →ₐ[k] K ⊗[k] P)).map
62         ePoly.toRingHom
63     rw [← hmap]
64     exact (Ideal.map_map
65       (Algebra.TensorProduct.includeRight : P →ₐ[k] K ⊗[k] P).toRingHom
66       ePoly.toRingHom).symm
67 
68   let eQ := Ideal.quotientEquivAlg J IK ePoly hIJ
69   let eB := Algebra.TensorProduct.tensorQuotientEquiv
70     (R := k) (S := K) (T := P) (A := K) I
71   exact (eB.trans eQ).symm
72 
73 
74 private theorem quotientScalarEquiv_mk
75     (I : Ideal (MvPolynomial (Fin n) k)) (f : MvPolynomial (Fin n) k) :
76     quotientScalarEquiv (k := k) (K := K) I
77       (Ideal.Quotient.mk (I.map (scalarPolynomialMap (k := k) (K := K) (Fin n)))
78         (scalarPolynomialMap (k := k) (K := K) (Fin n) f)) =
79       (1 : K) ⊗ₜ[k] Ideal.Quotient.mk I f := by
80   let P := MvPolynomial (Fin n) k
81   let PK := MvPolynomial (Fin n) K
82   let J := I.map (Algebra.TensorProduct.includeRight : P →ₐ[k] K ⊗[k] P)
83   let IK := I.map (scalarPolynomialMap (k := k) (K := K) (Fin n))
84   let ePoly : K ⊗[k] P ≃ₐ[K] PK := MvPolynomial.algebraTensorAlgEquiv k K
85   have hpoly : ePoly.symm (scalarPolynomialMap (k := k) (K := K) (Fin n) f) =
86       Algebra.TensorProduct.includeRight f := by
87     exact MvPolynomial.algebraTensorAlgEquiv_symm_map k K f
88   have hmapAlg :
89       (ePoly.toAlgHom.restrictScalars k).comp
90         (Algebra.TensorProduct.includeRight : P →ₐ[k] K ⊗[k] P) =
91       MvPolynomial.mapAlgHom (Algebra.ofId k K) := by
92     apply MvPolynomial.algHom_ext
93     intro i
94     change ePoly (1 ⊗ₜ[k] (MvPolynomial.X i : P)) =
95       MvPolynomial.map (algebraMap k K) (MvPolynomial.X i)
96     rw [MvPolynomial.algebraTensorAlgEquiv_tmul]
97     simp
98   have hmap : ePoly.toRingHom.comp
99       (Algebra.TensorProduct.includeRight : P →ₐ[k] K ⊗[k] P).toRingHom =
100       scalarPolynomialMap (k := k) (K := K) (Fin n) := by
101     exact congrArg AlgHom.toRingHom hmapAlg
102   have hIJ : IK = J.map ePoly.toRingHom := by
103     change I.map (scalarPolynomialMap (k := k) (K := K) (Fin n)) =
104       (I.map (Algebra.TensorProduct.includeRight : P →ₐ[k] K ⊗[k] P)).map
105         ePoly.toRingHom
106     rw [← hmap]
107     exact (Ideal.map_map
108       (Algebra.TensorProduct.includeRight : P →ₐ[k] K ⊗[k] P).toRingHom
109       ePoly.toRingHom).symm
110   let eQ := Ideal.quotientEquivAlg J IK ePoly hIJ
111   let eB := Algebra.TensorProduct.tensorQuotientEquiv
112     (R := k) (S := K) (T := P) (A := K) I
113   have hQ : eQ.symm (Ideal.Quotient.mk IK
114       (scalarPolynomialMap (k := k) (K := K) (Fin n) f)) =
115       Ideal.Quotient.mk J (Algebra.TensorProduct.includeRight f) := by
116     apply eQ.injective
117     calc
118       eQ (eQ.symm (Ideal.Quotient.mk IK
119           (scalarPolynomialMap (k := k) (K := K) (Fin n) f))) =
120           Ideal.Quotient.mk IK
121             (scalarPolynomialMap (k := k) (K := K) (Fin n) f) :=
122         eQ.apply_symm_apply _
123       _ = eQ (Ideal.Quotient.mk J
124             (Algebra.TensorProduct.includeRight f)) := by
125         change Ideal.Quotient.mk IK
126             (scalarPolynomialMap (k := k) (K := K) (Fin n) f) =
127           Ideal.Quotient.mk IK (ePoly (Algebra.TensorProduct.includeRight f))
128         congr 1
129         calc
130           scalarPolynomialMap (k := k) (K := K) (Fin n) f =
131               ePoly (ePoly.symm
132                 (scalarPolynomialMap (k := k) (K := K) (Fin n) f)) := by
133             exact (ePoly.apply_symm_apply _).symm
134           _ = ePoly (Algebra.TensorProduct.includeRight f) := by
135             rw [← hpoly]
136   calc
137     eB.symm (eQ.symm (Ideal.Quotient.mk IK
138         (scalarPolynomialMap (k := k) (K := K) (Fin n) f))) =
139         eB.symm (Ideal.Quotient.mk J
140           ((1 : K) ⊗ₜ[k] f)) := by rw [hQ]; congr 1
141     _ = (1 : K) ⊗ₜ[k] Ideal.Quotient.mk I f := by
142       exact Algebra.TensorProduct.tensorQuotientEquiv_symm_apply_tmul
143         (R := k) K P K I (1 : K) f
144 
145 /-- A smooth principal open over `k` remains smooth at every `K`-point that
146 avoids its defining equation.  The point is presented by its polynomial
147 coordinates; no smoothness of the point is assumed. -/
148 theorem smoothAffinePoint_of_smooth_away
149     (I : Ideal (MvPolynomial (Fin n) k))
150     (f : MvPolynomial (Fin n) k)
151     (hsmooth : Algebra.Smooth k
152       (Localization.Away (Ideal.Quotient.mk I f)))
153     (y : Fin n → K)
154     (hy : ∀ p ∈ I, MvPolynomial.eval₂ (algebraMap k K) y p = 0)
155     (hf : MvPolynomial.eval₂ (algebraMap k K) y f ≠ 0) :
156     SmoothAffinePoint (k := K)
157       (I.map (scalarPolynomialMap (k := k) (K := K) (Fin n))) y := by
158   let P := MvPolynomial (Fin n) k
159   let PK := MvPolynomial (Fin n) K
160   let A := P ⧸ I
161   let IK := I.map (scalarPolynomialMap (k := k) (K := K) (Fin n))
162   let fA : A := Ideal.Quotient.mk I f
163   let fK : PK ⧸ IK := Ideal.Quotient.mk IK
164     (scalarPolynomialMap (k := k) (K := K) (Fin n) f)
165   have hker : IK ≤ RingHom.ker (MvPolynomial.aeval y).toRingHom := by
166     apply Ideal.map_le_iff_le_comap.mpr
167     intro q hq
168     change MvPolynomial.aeval y (scalarPolynomialMap (k := k) (K := K) (Fin n) q) = 0
169     rw [MvPolynomial.aeval_eq_eval, eval_scalarPolynomialMap]
170     exact hy q hq
171   let e : (PK ⧸ IK) →ₐ[K] K :=
172     Ideal.Quotient.liftₐ IK (MvPolynomial.aeval y) (by
173       intro q hq
174       exact RingHom.mem_ker.mp (hker hq))
175   letI : Algebra.FinitePresentation K (PK ⧸ IK) :=
176     Algebra.FinitePresentation.quotient IK.fg_of_isNoetherianRing
177   have hnonzero : e fK ≠ 0 := by
178     change MvPolynomial.eval y (scalarPolynomialMap (k := k) (K := K) (Fin n) f) ≠ 0
179     simpa [eval_scalarPolynomialMap] using hf
180   have hloc : Algebra.Smooth K (Localization.Away fK) := by
181     letI : Algebra.Smooth k (Localization.Away fA) := hsmooth
182     have hSmoothTensor : Algebra.Smooth K (K ⊗[k] Localization.Away fA) :=
183       Algebra.Smooth.baseChange k (Localization.Away fA) K
184     let eAway := IsLocalization.Away.tensorProductEquivTMulRight
185       (R := k) (S := K) (A := A) fA (Localization.Away fA)
186     let eQuot : (PK ⧸ IK) ≃ₐ[K] K ⊗[k] A :=
187       quotientScalarEquiv (k := k) (K := K) I
188     have hElement : eQuot fK = (1 : K) ⊗ₜ[k] fA := by
189       exact quotientScalarEquiv_mk (k := k) (K := K) I f
190     have hAwayTarget : Algebra.Smooth K
191         (Localization.Away (eQuot fK)) := by
192       rw [hElement]
193       letI : Algebra.Smooth K (K ⊗[k] Localization.Away fA) := hSmoothTensor
194       exact Algebra.Smooth.of_equiv eAway
195     let phi : (PK ⧸ IK) →ₐ[K] Localization.Away (eQuot fK) :=
196       (IsScalarTower.toAlgHom K (K ⊗[k] A)
197         (Localization.Away (eQuot fK))).comp eQuot.toAlgHom
198     letI : Algebra (PK ⧸ IK) (Localization.Away (eQuot fK)) :=
199       phi.toRingHom.toAlgebra
200     letI : IsScalarTower K (PK ⧸ IK) (Localization.Away (eQuot fK)) :=
201       IsScalarTower.of_algebraMap_eq fun x => by
202         change algebraMap K (Localization.Away (eQuot fK)) x =
203           phi (algebraMap K (PK ⧸ IK) x)
204         rw [AlgHom.commutes]
205     let eLoc := IsLocalization.algEquivOfAlgEquiv
206       (A := K) (R := PK ⧸ IK) (M := Submonoid.powers fK)
207       (S := Localization.Away fK) (P := K ⊗[k] A)
208       (T := Submonoid.powers (eQuot fK))
209       (Q := Localization.Away (eQuot fK)) eQuot (by
210         simp [Submonoid.map_powers])
211     letI : Algebra.Smooth K (Localization.Away (eQuot fK)) := hAwayTarget
212     exact Algebra.Smooth.of_equiv eLoc.symm
213   refine ⟨e, ?_, ?_⟩
214   · intro p
215     change (Ideal.Quotient.liftₐ IK (MvPolynomial.aeval y) (by
216       intro q hq
217       exact RingHom.mem_ker.mp (hker hq))) (Ideal.Quotient.mk IK p) =
218       MvPolynomial.aeval y p
219     simp [Ideal.Quotient.liftₐ_apply]
220   · have hopen : (⟨RingHom.ker e.toRingHom, RingHom.ker_isPrime e⟩ :
221         PrimeSpectrum (PK ⧸ IK)) ∈ PrimeSpectrum.basicOpen fK := by
222       rw [PrimeSpectrum.mem_basicOpen]
223       intro hker
224       exact hnonzero (RingHom.mem_ker.mp hker)
225     exact (Algebra.basicOpen_subset_smoothLocus_iff_smooth.mpr hloc) hopen
226 
227 /-- A field-valued point of the original affine quotient which avoids a
228 smooth principal open is itself a genuine Mathlib smooth point over its field
229 of values.  The coordinates in the conclusion are the images of the original
230 affine generators; no projective-chart quotient is identified with the
231 original coordinate ring. -/
232 theorem smoothAffinePoint_of_quotient_point_avoiding_smooth_away
233     {L : Type*} [Field L] [Algebra k L]
234     (I : Ideal (MvPolynomial (Fin n) k))
235     (fbar : MvPolynomial (Fin n) k ⧸ I)
236     (hsmooth : Algebra.Smooth k (Localization.Away fbar))
237     (φ : (MvPolynomial (Fin n) k ⧸ I) →ₐ[k] L)
238     (havoid : φ fbar ≠ 0) :
239     SmoothAffinePoint (k := L)
240       (I.map (scalarPolynomialMap (k := k) (K := L) (Fin n)))
241       (fun i ↦ φ (Ideal.Quotient.mk I (MvPolynomial.X i))) := by
242   obtain ⟨f, hfbar⟩ := Ideal.Quotient.mk_surjective fbar
243   have havoid_f : φ (Ideal.Quotient.mk I f) ≠ 0 := by
244     simpa only [hfbar] using havoid
245   let φP : MvPolynomial (Fin n) k →ₐ[k] L :=
246     φ.comp (Ideal.Quotient.mkₐ k I)
247   have hI : ∀ p ∈ I, φP p = 0 := by
248     intro p hp
249     change φ (Ideal.Quotient.mk I p) = 0
250     have hmk : Ideal.Quotient.mk I p = 0 :=
251       Ideal.Quotient.eq_zero_iff_mem.mpr hp
252     rw [hmk, map_zero]
253   have hf : φP f ≠ 0 := by
254     simpa [φP] using havoid_f
255   have heval : ∀ p : MvPolynomial (Fin n) k,
256       MvPolynomial.eval₂ (algebraMap k L)
257           (fun i ↦ φP (MvPolynomial.X i)) p = φP p := by
258     intro p
259     have hunique := MvPolynomial.aeval_unique φP
260     have hpoint : φP = MvPolynomial.aeval (fun i ↦ φP (MvPolynomial.X i)) := by
261       convert hunique using 1 <;> rfl
262     have heq := congrArg (fun ψ : MvPolynomial (Fin n) k →ₐ[k] L => ψ p)
263       hpoint.symm
264     simpa only [MvPolynomial.aeval_def] using heq
265   have hy : ∀ p ∈ I,
266       MvPolynomial.eval₂ (algebraMap k L)
267         (fun i ↦ φ (Ideal.Quotient.mk I (MvPolynomial.X i))) p = 0 := by
268     intro p hp
269     change MvPolynomial.eval₂ (algebraMap k L)
270       (fun i ↦ φP (MvPolynomial.X i)) p = 0
271     rw [heval, hI p hp]
272   have hfL : MvPolynomial.eval₂ (algebraMap k L)
273       (fun i ↦ φ (Ideal.Quotient.mk I (MvPolynomial.X i))) f ≠ 0 := by
274     change MvPolynomial.eval₂ (algebraMap k L)
275       (fun i ↦ φP (MvPolynomial.X i)) f ≠ 0
276     rw [heval]
277     exact hf
278   have hhsmooth : Algebra.Smooth k
279       (Localization.Away (Ideal.Quotient.mk I f)) := by
280     cases hfbar
281     exact hsmooth
282   exact smoothAffinePoint_of_smooth_away (k := k) (K := L)
283     I f hhsmooth
284     (fun i ↦ φ (Ideal.Quotient.mk I (MvPolynomial.X i)))
285     hy hfL
286 
287 /-- On a prime affine variety over a perfect field, the generic smooth-open
288 producer supplies a principal open that can be used with the point-map
289 criterion above.  This keeps the open in the original affine quotient, so a
290 caller may feed it the map obtained from the actual chart-overlap ratios. -/
291 theorem exists_generic_smooth_open_point_criterion
292     {L : Type*} [Field L] [Algebra k L]
293     (I : Ideal (MvPolynomial (Fin n) k)) [I.IsPrime] [PerfectField k]
294     (φ : (MvPolynomial (Fin n) k ⧸ I) →ₐ[k] L) :
295     ∃ g : (MvPolynomial (Fin n) k ⧸ I), g ≠ 0 ∧
296       Algebra.Smooth k (Localization.Away g) ∧
297       ∀ _ : φ g ≠ 0,
298         SmoothAffinePoint (k := L)
299           (I.map (scalarPolynomialMap (k := k) (K := L) (Fin n)))
300           (fun i ↦ φ (Ideal.Quotient.mk I (MvPolynomial.X i))) := by
301   obtain ⟨g, hg, hsmooth⟩ :=
302     Stafford38.Geometry.exists_nonzero_smooth_away_quotient I
303   exact ⟨g, hg, hsmooth, fun havoid =>
304     smoothAffinePoint_of_quotient_point_avoiding_smooth_away
305       (k := k) I g hsmooth φ havoid⟩
306 
307 
308 end
309 end Stafford38.Geometry.SmoothAffinePointScalarExtension
310