Stafford38/Geometry/EtaleGenericOpenLocalAwayB.lean

This project (Stafford38) · 1029fdb382eee06e7b59bcf32801f40931e2079a

1 module
2 public import Stafford38.Geometry.EtaleGenericOpenTransport
3 public import Mathlib.RingTheory.Localization.LocalizationLocalization
4 public import Mathlib.RingTheory.Localization.AtPrime.Basic
5 public import Mathlib.RingTheory.Localization.Away.Basic
6 
7 @[expose] public section
8 
9 set_option autoImplicit false
10 
11 noncomputable section
12 namespace Stafford38.Geometry.EtaleGenericOpenTransport
13 universe u v
14 
15 abbrev finiteBirationalOpen
16     {Q : Type u} [CommRing Q] {B : Type v} [CommRing B] [Algebra Q B]
17     (M : Ideal B) [M.IsPrime] (f : Q) : Type v :=
18   Localization (M.primeCompl.map
19     (algebraMap B (Localization.Away (algebraMap Q B f))))
20 
21 abbrev pointLocalAwayOpen
22     {Q : Type u} [CommRing Q] {B : Type v} [CommRing B] [Algebra Q B]
23     (M : Ideal B) [M.IsPrime] (f : Q) : Type v :=
24   Localization.Away
25     (algebraMap B (Localization.AtPrime M) (algebraMap Q B f))
26 
27 /-- The genuine B-algebra structure on the generic open is induced by the
28 point map `B → Q_f` transported through `Q_f ≃ B_f`. -/
29 noncomputable def genericOpenBMap
30     {Q : Type u} [CommRing Q] {B : Type v} [CommRing B] [Algebra Q B]
31     (M : Ideal B) [M.IsPrime] (f : Q)
32     (e : Localization.Away f ≃ₐ[Q]
33       Localization.Away (algebraMap Q B f)) : B →+* genericOpenRing M f e :=
34   (algebraMap (Localization.Away f) (genericOpenRing M f e)).comp
35     (genericPointMap f e)
36 
37 noncomputable instance instGenericOpenBAlgebra
38     {Q : Type u} [CommRing Q] {B : Type v} [CommRing B] [Algebra Q B]
39     (M : Ideal B) [M.IsPrime] (f : Q)
40     (e : Localization.Away f ≃ₐ[Q]
41       Localization.Away (algebraMap Q B f)) :
42     Algebra B (genericOpenRing M f e) :=
43   (genericOpenBMap M f e).toAlgebra
44 
45 /-- The generic-open presentation obtained from `Q_f` and the image of `B \ M`
46 identifies with the same open constructed from the actual local ring `B_M`.
47 No condition says `f` avoids `M`; the common open inverts it generically. -/
48 noncomputable def genericOpenEquiv_pointLocalAway_overB
49     {Q : Type u} [CommRing Q] {B : Type v} [CommRing B] [Algebra Q B]
50     (M : Ideal B) [M.IsPrime] (f : Q)
51     (e : Localization.Away f ≃ₐ[Q]
52       Localization.Away (algebraMap Q B f)) :
53     genericOpenRing M f e ≃ₐ[B] pointLocalAwayOpen M f := by
54   let Qf := Localization.Away f
55   let Bf := Localization.Away (algebraMap Q B f)
56   let Cq := genericOpenRing M f e
57   let Cb := finiteBirationalOpen M f
58   let Bm := Localization.AtPrime M
59   let Cl := pointLocalAwayOpen M f
60   let Nq : Submonoid Qf := genericOpenDenominators M f e
61   let Nb : Submonoid Bf := M.primeCompl.map (algebraMap B Bf)
62   let Sq := IsLocalization.localizationLocalizationSubmodule
63     (Submonoid.powers f) Nq
64   let Sb := IsLocalization.localizationLocalizationSubmodule
65     (Submonoid.powers (algebraMap Q B f)) Nb
66   let Sl := IsLocalization.localizationLocalizationSubmodule
67     M.primeCompl (Submonoid.powers (algebraMap B Bm (algebraMap Q B f)))
68   have hcomp : (e : Qf →* Bf).comp (genericPointMap f e) = (algebraMap B Bf : B →* Bf) := by
69     ext b
70     change e (e.symm (algebraMap B Bf b)) = algebraMap B Bf b
71     exact e.apply_symm_apply _
72   have hmap : Submonoid.map (e : Qf ≃* Bf) Nq = Nb := by
73     change Submonoid.map (e : Qf →* Bf)
74       (Submonoid.map (genericPointMap f e) M.primeCompl) =
75       Submonoid.map (algebraMap B Bf : B →* Bf) M.primeCompl
76     calc
77       _ = Submonoid.map ((e : Qf →* Bf).comp (genericPointMap f e)) M.primeCompl :=
78         Submonoid.map_map _ _ _
79       _ = _ := by rw [hcomp]
80   let eQB : Cq ≃ₐ[Q] Cb :=
81     IsLocalization.algEquivOfAlgEquiv (A := Q) (R := Qf) (M := Nq) Cq
82       (P := Bf) (T := Nb) Cb e hmap
83   let bToCb : B →+* Cb :=
84     (algebraMap Bf Cb).comp (algebraMap B Bf)
85   let bToCl : B →+* Cl :=
86     (algebraMap Bm Cl).comp (algebraMap B Bm)
87   let bToCq : B →+* Cq := genericOpenBMap M f e
88   let eBL : Cb ≃ₐ[B] Cl := by
89     letI : IsLocalization Sb Cb :=
90       IsLocalization.localization_localization_isLocalization
91         (Submonoid.powers (algebraMap Q B f)) Nb Cb
92     letI : IsLocalization Sl Cl :=
93       IsLocalization.localization_localization_isLocalization
94         M.primeCompl
95         (Submonoid.powers (algebraMap B Bm (algebraMap Q B f))) Cl
96     let fB : B := algebraMap Q B f
97     let fM : Bm := algebraMap B Bm fB
98     have hunitF : IsUnit (bToCl fB) := by
99       change IsUnit (algebraMap Bm (Localization.Away fM) fM)
100       exact IsLocalization.Away.algebraMap_isUnit fM
101     let bFToCl : Bf →+* Cl :=
102       IsLocalization.Away.lift (algebraMap Q B f) hunitF
103     have hbFComp : bFToCl.comp (algebraMap B Bf) = bToCl := by
104       exact IsLocalization.Away.lift_comp (algebraMap Q B f) hunitF
105     have hbFComp_apply (b : B) :
106         bFToCl (algebraMap B Bf b) = bToCl b := by
107       have hh := congrArg (fun g : B →+* Cl => g b) hbFComp
108       simpa only [RingHom.comp_apply] using hh
109     have hunitSb : ∀ s : Sb, IsUnit (bToCl s.1) := by
110       intro s
111       rcases IsLocalization.mem_localizationLocalizationSubmodule.mp s.2 with
112         ⟨y, z, hyz⟩
113       have hrepr : bToCl s.1 = bFToCl y.1 * bFToCl (algebraMap B Bf z.1) := by
114         calc
115           bToCl s.1 = bFToCl (algebraMap B Bf s.1) :=
116             (hbFComp_apply s.1).symm
117           _ = bFToCl (y.1 * algebraMap B Bf z.1) := by rw [hyz]
118           _ = bFToCl y.1 * bFToCl (algebraMap B Bf z.1) := map_mul _ _ _
119       rw [hrepr]
120       rcases y.2 with ⟨b, hb, hyEq⟩
121       have hy : IsUnit (bFToCl y.1) := by
122         rw [← hyEq]
123         have hu : IsUnit (algebraMap Bm Cl (algebraMap B Bm b)) := by
124           exact IsUnit.map (algebraMap Bm Cl) (IsLocalization.map_units Bm ⟨b, hb⟩)
125         rw [hbFComp_apply b]
126         simpa [bToCl] using hu
127       have hz : IsUnit (bFToCl (algebraMap B Bf z.1)) := by
128         rcases (Submonoid.mem_powers_iff _ _).mp z.2 with ⟨n, hn⟩
129         have hpow : bFToCl (algebraMap B Bf z.1) = bToCl fB ^ n := by
130           rw [← hn]
131           calc
132             bFToCl (algebraMap B Bf (fB ^ n)) =
133                 bFToCl (algebraMap B Bf fB ^ n) := by simp only [map_pow]
134             _ = bFToCl (algebraMap B Bf fB) ^ n := by rw [map_pow]
135             _ = bToCl fB ^ n := by rw [hbFComp_apply fB]
136         rw [hpow]
137         exact IsUnit.pow _ hunitF
138       exact hy.mul hz
139     let bMToCb : Bm →+* Cb := IsLocalization.lift
140       (M := M.primeCompl) (g := bToCb) (fun x => by
141         have hden : (algebraMap B Bf x.1) ∈ Nb := ⟨x.1, x.2, rfl⟩
142         exact IsLocalization.map_units Cb ⟨algebraMap B Bf x.1, hden⟩)
143     have hbMComp : bMToCb.comp (algebraMap B Bm) = bToCb := by
144       exact IsLocalization.lift_comp (M := M.primeCompl)
145         (g := bToCb) (fun x => by
146           have hden : (algebraMap B Bf x.1) ∈ Nb := ⟨x.1, x.2, rfl⟩
147           exact IsLocalization.map_units Cb ⟨algebraMap B Bf x.1, hden⟩)
148     have hbMComp_apply (b : B) :
149         bMToCb (algebraMap B Bm b) = bToCb b := by
150       have hh := congrArg (fun g : B →+* Cb => g b) hbMComp
151       simpa only [RingHom.comp_apply] using hh
152     have hf : IsUnit (bMToCb fM) := by
153       have heq : bMToCb fM = algebraMap Bf Cb (algebraMap B Bf fB) := by
154         calc
155           bMToCb fM = bToCb fB := hbMComp_apply fB
156           _ = algebraMap Bf Cb (algebraMap B Bf fB) := rfl
157       rw [heq]
158       have hfB : IsUnit (algebraMap B Bf fB) := by
159         simpa [fB] using IsLocalization.Away.algebraMap_isUnit (algebraMap Q B f)
160       exact IsUnit.map (algebraMap Bf Cb) hfB
161     have hunitSl : ∀ s : Sl, IsUnit (bToCb s.1) := by
162       intro s
163       rcases IsLocalization.mem_localizationLocalizationSubmodule.mp s.2 with
164         ⟨y, z, hyz⟩
165       have hrepr : bToCb s.1 = bMToCb y.1 * bMToCb (algebraMap B Bm z.1) := by
166         calc
167           bToCb s.1 = bMToCb (algebraMap B Bm s.1) :=
168             (hbMComp_apply s.1).symm
169           _ = bMToCb (y.1 * algebraMap B Bm z.1) := by rw [hyz]
170           _ = bMToCb y.1 * bMToCb (algebraMap B Bm z.1) := map_mul _ _ _
171       rw [hrepr]
172       rcases y.2 with ⟨n, hn⟩
173       have hy : IsUnit (bMToCb y.1) := by
174         rw [← hn, map_pow]
175         exact IsUnit.pow _ hf
176       have hz : IsUnit (bMToCb (algebraMap B Bm z.1)) := by
177         rw [hbMComp_apply z.1]
178         have hden : algebraMap B Bf z.1 ∈ Nb := ⟨z.1, z.2, rfl⟩
179         have hu : IsUnit (algebraMap Bf Cb (algebraMap B Bf z.1)) :=
180           IsLocalization.map_units Cb ⟨algebraMap B Bf z.1, hden⟩
181         simpa [bToCb] using hu
182       exact hy.mul hz
183     let toCl : Cb →+* Cl := IsLocalization.lift hunitSb
184     let toCb : Cl →+* Cb := IsLocalization.lift hunitSl
185     have htoCl : toCl.comp bToCb = bToCl := IsLocalization.lift_comp hunitSb
186     have htoCb : toCb.comp bToCl = bToCb := IsLocalization.lift_comp hunitSl
187     have hbCb : bToCb = algebraMap B Cb :=
188       IsScalarTower.algebraMap_eq B Bf Cb |>.symm
189     have hbCl : bToCl = algebraMap B Cl :=
190       IsScalarTower.algebraMap_eq B Bm Cl |>.symm
191     have hleft : toCb.comp toCl = RingHom.id Cb := by
192       apply IsLocalization.ringHom_ext Sb
193       calc
194         (toCb.comp toCl).comp (algebraMap B Cb) =
195             toCb.comp (toCl.comp (algebraMap B Cb)) := RingHom.comp_assoc _ _ _
196         _ = toCb.comp (toCl.comp bToCb) := by rw [← hbCb]
197         _ = toCb.comp bToCl := by rw [htoCl]
198         _ = bToCb := by rw [htoCb]
199         _ = (RingHom.id Cb).comp (algebraMap B Cb) := by
200           simp [RingHom.id_comp, hbCb]
201     have hright : toCl.comp toCb = RingHom.id Cl := by
202       apply IsLocalization.ringHom_ext Sl
203       calc
204         (toCl.comp toCb).comp (algebraMap B Cl) =
205             toCl.comp (toCb.comp (algebraMap B Cl)) := RingHom.comp_assoc _ _ _
206         _ = toCl.comp (toCb.comp bToCl) := by rw [← hbCl]
207         _ = toCl.comp bToCb := by rw [htoCb]
208         _ = bToCl := by rw [htoCl]
209         _ = (RingHom.id Cl).comp (algebraMap B Cl) := by
210           simp [RingHom.id_comp, hbCl]
211     let er : Cb ≃+* Cl := RingEquiv.ofRingHom toCl toCb hright hleft
212     exact AlgEquiv.ofRingEquiv (f := er) (fun b => by
213       change toCl (algebraMap B Cb b) = algebraMap B Cl b
214       rw [← hbCb, ← hbCl]
215       exact congrArg (fun g : B →+* Cl => g b) htoCl)
216   let eBLQ : Cb ≃ₐ[Q] Cl := eBL.restrictScalars Q
217   let eQB_B : Cq ≃ₐ[B] Cb := AlgEquiv.ofRingEquiv
218     (f := eQB.toRingEquiv) (by
219       intro b
220       have hlocal (x : Qf) :
221           eQB (algebraMap Qf Cq x) = algebraMap Bf Cb (e x) := by
222         simpa [eQB] using
223           (IsLocalization.algEquivOfAlgEquiv_eq
224             (S := Cq) (Q := Cb) (h := e) (H := hmap) x)
225       calc
226         eQB (bToCq b) =
227             eQB (algebraMap Qf Cq (genericPointMap f e b)) := rfl
228         _ = algebraMap Bf Cb (e (genericPointMap f e b)) := hlocal _
229         _ = algebraMap Bf Cb (algebraMap B Bf b) := by
230           change algebraMap Bf Cb
231             (e (e.symm (algebraMap B Bf b))) = _
232           rw [e.apply_symm_apply]
233         _ = bToCb b := rfl)
234   exact eQB_B.trans eBL
235 
236 /-- If the actual local chart `B_M` is formally étale over a parameter ring `R`,
237 then so is the equivalent generic-open presentation. The denominator may lie
238 in `M`; it is inverted only after passing to the generic open. -/
239 theorem formallyEtale_genericOpenRing_of_pointLocal
240     {R : Type*} [CommRing R]
241     {Q : Type u} [CommRing Q] {B : Type v} [CommRing B] [Algebra Q B]
242     [Algebra R B]
243     (M : Ideal B) [M.IsPrime] (f : Q)
244     (e : Localization.Away f ≃ₐ[Q]
245       Localization.Away (algebraMap Q B f))
246     [Algebra.FormallyEtale R (Localization.AtPrime M)] :
247     letI : Algebra R (genericOpenRing M f e) :=
248       ((algebraMap B (genericOpenRing M f e)).comp (algebraMap R B)).toAlgebra
249     Algebra.FormallyEtale R (genericOpenRing M f e) := by
250   letI : Algebra.FormallyEtale (Localization.AtPrime M)
251       (pointLocalAwayOpen M f) :=
252     Algebra.FormallyEtale.of_isLocalization
253       (Submonoid.powers (algebraMap B (Localization.AtPrime M)
254         (algebraMap Q B f)))
255   letI : Algebra.FormallyEtale R (pointLocalAwayOpen M f) :=
256     Algebra.FormallyEtale.comp R (Localization.AtPrime M) (pointLocalAwayOpen M f)
257   letI : Algebra R (genericOpenRing M f e) :=
258     ((algebraMap B (genericOpenRing M f e)).comp (algebraMap R B)).toAlgebra
259   letI : IsScalarTower R B (genericOpenRing M f e) :=
260     IsScalarTower.of_algebraMap_eq (fun _ => rfl)
261   let eB : genericOpenRing M f e ≃ₐ[B] pointLocalAwayOpen M f :=
262     genericOpenEquiv_pointLocalAway_overB M f e
263   exact Algebra.FormallyEtale.of_equiv (eB.restrictScalars R).symm
264 
265 end Stafford38.Geometry.EtaleGenericOpenTransport
266 end
267