Stafford38/Weyl/QuotientTransport.lean

This project (Stafford38) · 1029fdb382eee06e7b59bcf32801f40931e2079a

1 module
2 public import Stafford38.Quotient.EulerSurjectivity
3 public import Stafford38.Weyl.EulerRemainder
4 public import Stafford38.Weyl.IteratedEquivalence
5 public import Stafford38.Weyl.PaperEulerGrading
6 
7 @[expose] public section
8 
9 /-!
10 # Transport of the canonical right quotient
11 
12 The recursive Ore tower and the presented Weyl algebra are related by an
13 algebra equivalence.  This file transports the *literal* two-generator right
14 ideal and its right quotient across that equivalence.  The final theorem is
15 the presented-Weyl form of the already proved `PairStage` surjectivity.
16 -/
17 
18 namespace Stafford38.WeylQuotientTransport
19 
20 open Stafford38.EulerSurjectivity
21 open Stafford38.OreIteratedPairStage
22 open Stafford38.OrePairStage
23 open Stafford38.WeylEulerRemainder
24 open Stafford38.WeylEulerResidue
25 open Stafford38.WeylIteratedEquivalence
26 open Stafford38.WeylPBWMonicBridge
27 open Stafford38.WeylUniversal
28 
29 noncomputable section
30 
31 universe u
32 
33 variable {k : Type u} [Field k]
34 
35 /-! ## Right-module transport -/
36 
37 instance rightModuleEquiv_invPair {A B : Type*} [Ring A] [Ring B]
38     [Algebra k A] [Algebra k B] (e : A ≃ₐ[k] B) :
39     RingHomInvPair
40       ((AlgEquiv.op e).toRingEquiv : Aᵐᵒᵖ →+* Bᵐᵒᵖ)
41       ((AlgEquiv.op e).toRingEquiv.symm : Bᵐᵒᵖ →+* Aᵐᵒᵖ) :=
42   RingHomInvPair.of_ringEquiv (AlgEquiv.op e).toRingEquiv
43 
44 instance rightModuleEquiv_invPair_symm {A B : Type*} [Ring A] [Ring B]
45     [Algebra k A] [Algebra k B] (e : A ≃ₐ[k] B) :
46     RingHomInvPair
47       ((AlgEquiv.op e).toRingEquiv.symm : Bᵐᵒᵖ →+* Aᵐᵒᵖ)
48       ((AlgEquiv.op e).toRingEquiv : Aᵐᵒᵖ →+* Bᵐᵒᵖ) :=
49   RingHomInvPair.of_ringEquiv (AlgEquiv.op e).toRingEquiv.symm
50 
51 /-- The algebra equivalence, regarded as a semilinear equivalence of regular
52 right modules.  The scalar ring is transported on opposites. -/
53 def rightModuleEquiv {A B : Type*} [Ring A] [Ring B] [Algebra k A]
54     [Algebra k B] (e : A ≃ₐ[k] B) :
55     @LinearEquiv Aᵐᵒᵖ Bᵐᵒᵖ _ _ (AlgEquiv.op e).toRingEquiv
56       (AlgEquiv.op e).toRingEquiv.symm _ _ A B _ _ _ _ :=
57   { e.toAddEquiv with
58     map_smul' := by
59       intro c a
60       change e (a * c.unop) = e a * e c.unop
61       exact map_mul e a c.unop }
62 
63 /-- The inverse regular-right-module equivalence, with the inverse opposite
64 scalar map made explicit for quotient composition. -/
65 def rightModuleEquiv_symm {A B : Type*} [Ring A] [Ring B] [Algebra k A]
66     [Algebra k B] (e : A ≃ₐ[k] B) :
67     @LinearEquiv Bᵐᵒᵖ Aᵐᵒᵖ _ _ (AlgEquiv.op e).toRingEquiv.symm
68       (AlgEquiv.op e).toRingEquiv _ _ B A _ _ _ _ :=
69   { e.symm.toAddEquiv with
70     map_smul' := by
71       intro c b
72       change e.symm (b * c.unop) = e.symm b * e.symm c.unop
73       exact map_mul e.symm b c.unop }
74 
75 /-- Image transport of a literal right ideal along an algebra equivalence. -/
76 def transportedRightIdeal {A B : Type*} [Ring A] [Ring B] [Algebra k A]
77     [Algebra k B] (e : A ≃ₐ[k] B) (I : RightIdeal A) : RightIdeal B :=
78   { carrier := e '' I
79     zero_mem' := by
80       exact ⟨0, I.zero_mem, by simp⟩
81     add_mem' := by
82       rintro y z ⟨y', hy', rfl⟩ ⟨z', hz', rfl⟩
83       refine ⟨y' + z', I.add_mem hy' hz', ?_⟩
84       simp
85     smul_mem' := by
86       rintro b y ⟨a, ha, rfl⟩
87       let c : Aᵐᵒᵖ := (AlgEquiv.op e).symm b
88       refine ⟨c • a, I.smul_mem c ha, ?_⟩
89       have h := (rightModuleEquiv e).map_smulₛₗ c a
90       calc
91         e (c • a) = (AlgEquiv.op e).toRingEquiv c • e a := h
92         _ = b • e a := by
93           rw [show (AlgEquiv.op e).toRingEquiv c = b by
94             exact (AlgEquiv.op e).apply_symm_apply b] }
95 
96 /-! ## The two generators and quotient -/
97 
98 /-- The literal canonical right ideal in the presented Weyl algebra. -/
99 abbrev presentedCanonicalRightIdeal (n N : ℕ) (d : PresentedWeyl k (n + 1)) :
100     RightIdeal (PresentedWeyl k (n + 1)) :=
101   canonicalRightIdeal (presentedCoordinate k n) d N
102 
103 /-- Its literal right quotient. -/
104 abbrev PresentedCanonicalRightQuotient (n N : ℕ)
105     (d : PresentedWeyl k (n + 1)) :=
106   RightQuotient (presentedCanonicalRightIdeal (k := k) n N d)
107 
108 theorem transported_canonicalRightIdeal
109     {A B : Type*} [Ring A] [Ring B] [Algebra k A] [Algebra k B]
110     (e : A ≃ₐ[k] B) (x d : A) (N : ℕ) :
111     transportedRightIdeal e (canonicalRightIdeal x d N) =
112       canonicalRightIdeal (e x) (e d) N := by
113   apply le_antisymm
114   · intro y hy
115     change y ∈ e '' canonicalRightIdeal x d N at hy
116     rcases hy with ⟨z, hz, rfl⟩
117     refine Submodule.span_induction ?_ ?_ ?_ ?_ hz
118     · intro z hz
119       simp only [Set.mem_insert_iff, Set.mem_singleton_iff] at hz
120       rcases hz with hz | hz
121       · subst z
122         exact firstGenerator_mem (e x) (e d) N
123       · subst z
124         simpa [map_mul, map_pow] using
125           (secondGenerator_mem (e x) (e d) N)
126     · simp
127     · intro a b ha hb hha hhb
128       simpa using (canonicalRightIdeal (e x) (e d) N).add_mem hha hhb
129     · intro c a ha hha
130       change (rightModuleEquiv e) (c • a) ∈
131         canonicalRightIdeal (e x) (e d) N
132       rw [(rightModuleEquiv e).map_smulₛₗ c a]
133       exact (canonicalRightIdeal (e x) (e d) N).smul_mem _ hha
134   · intro y hy
135     change y ∈ e '' canonicalRightIdeal x d N
136     refine ⟨e.symm y, ?_, by simp⟩
137     refine Submodule.span_induction ?_ ?_ ?_ ?_ hy
138     · intro z hz
139       simp only [Set.mem_insert_iff, Set.mem_singleton_iff] at hz
140       rcases hz with hz | hz
141       · subst z
142         simpa using (firstGenerator_mem x d N)
143       · subst z
144         simpa [map_mul, map_pow] using (secondGenerator_mem x d N)
145     · simp
146     · intro a b ha hb hha hhb
147       simpa using (canonicalRightIdeal x d N).add_mem hha hhb
148     · intro c a ha hha
149       change (rightModuleEquiv_symm e) (c • a) ∈
150         canonicalRightIdeal x d N
151       rw [(rightModuleEquiv_symm e).map_smulₛₗ c a]
152       exact (canonicalRightIdeal x d N).smul_mem _ hha
153 
154 theorem presented_canonicalRightIdeal_map
155     (n N : ℕ) (d : PresentedWeyl k (n + 1)) :
156     transportedRightIdeal (presentedIteratedEquiv k (n + 1))
157         (presentedCanonicalRightIdeal (k := k) n N d) =
158       canonicalRightIdeal (pairCoordinate (B := IteratedPairStage k n))
159         (presentedToIterated k (n + 1) d) N := by
160   have h := transported_canonicalRightIdeal
161       (e := presentedIteratedEquiv k (n + 1))
162       (x := presentedCoordinate k n) (d := d) (N := N)
163   change transportedRightIdeal (presentedIteratedEquiv k (n + 1))
164       (canonicalRightIdeal (presentedCoordinate k n) d N) = _
165   have hx : presentedIteratedEquiv k (n + 1) (presentedCoordinate k n) =
166       pairCoordinate (B := IteratedPairStage k n) := by
167     change presentedToIterated k (n + 1) (presentedCoordinate k n) =
168       pairCoordinate (B := IteratedPairStage k n)
169     simpa only [stageCoordinate] using (presentedToIterated_coordinate k n)
170   rw [hx] at h
171   exact h
172 
173 /-- The quotient map induced by the transported ideal. -/
174 def transportedRightQuotientMap {A B : Type*} [Ring A] [Ring B]
175     [Algebra k A] [Algebra k B] (e : A ≃ₐ[k] B) (I : RightIdeal A) :
176     @LinearMap Aᵐᵒᵖ Bᵐᵒᵖ _ _ (AlgEquiv.op e).toRingEquiv
177       (RightQuotient I) (RightQuotient (transportedRightIdeal e I)) _ _ _ _ :=
178   Submodule.mapQ I (transportedRightIdeal e I) (rightModuleEquiv e) (by
179     intro a ha
180     exact ⟨a, ha, by rfl⟩)
181 
182 @[simp] theorem transportedRightQuotientMap_qmk
183     {A B : Type*} [Ring A] [Ring B] [Algebra k A] [Algebra k B]
184     (e : A ≃ₐ[k] B) (I : RightIdeal A) (a : A) :
185   transportedRightQuotientMap e I (qmk I a) =
186       qmk (transportedRightIdeal e I) (e a) := by
187   rfl
188 
189 /-- The quotient equivalence induced by the transported ideal. -/
190 def transportedRightQuotientEquiv {A B : Type*} [Ring A] [Ring B]
191     [Algebra k A] [Algebra k B] (e : A ≃ₐ[k] B) (I : RightIdeal A) :
192     @LinearEquiv Aᵐᵒᵖ Bᵐᵒᵖ _ _ (AlgEquiv.op e).toRingEquiv
193       (AlgEquiv.op e).toRingEquiv.symm _ _
194       (RightQuotient I) (RightQuotient (transportedRightIdeal e I)) _ _ _ _ := by
195   apply LinearEquiv.ofLinear (transportedRightQuotientMap e I)
196     (Submodule.mapQ (transportedRightIdeal e I) I
197       (rightModuleEquiv_symm e) (by
198         intro b hb
199         change b ∈ e '' I at hb
200         rcases hb with ⟨a, ha, rfl⟩
201         simpa [rightModuleEquiv_symm] using ha))
202   · apply LinearMap.ext
203     intro q
204     refine Submodule.Quotient.induction_on
205       (transportedRightIdeal e I) q ?_
206     intro b
207     change transportedRightQuotientMap e I
208         (qmk I (e.symm b)) = qmk (transportedRightIdeal e I) b
209     rw [transportedRightQuotientMap_qmk]
210     simp
211   · apply LinearMap.ext
212     intro q
213     refine Submodule.Quotient.induction_on I q ?_
214     intro a
215     simp only [LinearMap.coe_comp, Function.comp_apply]
216     change qmk I (e.symm (e a)) = qmk I a
217     simp
218 
219 @[simp] theorem transportedRightQuotientEquiv_qmk
220     {A B : Type*} [Ring A] [Ring B] [Algebra k A] [Algebra k B]
221     (e : A ≃ₐ[k] B) (I : RightIdeal A) (a : A) :
222     transportedRightQuotientEquiv e I (qmk I a) =
223       qmk (transportedRightIdeal e I) (e a) := rfl
224 
225 theorem transportedRightQuotientEquiv_rightMul
226     {A B : Type*} [Ring A] [Ring B] [Algebra k A] [Algebra k B]
227     (e : A ≃ₐ[k] B) (I : RightIdeal A) (a : A) (q : RightQuotient I) :
228     transportedRightQuotientEquiv e I (rightMul I a q) =
229       rightMul (transportedRightIdeal e I) (e a)
230         (transportedRightQuotientEquiv e I q) := by
231   refine Submodule.Quotient.induction_on I q ?_
232   intro b
233   change transportedRightQuotientEquiv e I
234       (MulOpposite.op a • Submodule.Quotient.mk b) = _
235   rw [LinearEquiv.map_smulₛₗ]
236   rfl
237 
238 /-! ## Presented-Weyl surjectivity -/
239 
240 theorem presentedCanonicalRightQuotient_rightMul_coordinate_surjective
241     [Algebra ℚ k] (n N : ℕ) {d : PresentedWeyl k (n + 1)}
242     (hd : IsPBWMonicAt k (.inr (0 : Fin (n + 1))) N d) :
243     Function.Surjective
244       (rightMul (presentedCanonicalRightIdeal (k := k) n N d)
245         (presentedCoordinate k n)) := by
246   let e := presentedIteratedEquiv k (n + 1)
247   let I := presentedCanonicalRightIdeal (k := k) n N d
248   let f := transportedRightQuotientEquiv e I
249   have hmap : transportedRightIdeal e I =
250       canonicalRightIdeal (pairCoordinate (B := IteratedPairStage k n))
251         (presentedToIterated k (n + 1) d) N := by
252     exact presented_canonicalRightIdeal_map (k := k) n N d
253   have hsurj :=
254     Stafford38.PaperEulerGrading.presentedCanonicalQuotient_rightMul_coordinate_surjective
255       k n N hd
256   have hsurj' : Function.Surjective
257       (rightMul (transportedRightIdeal e I)
258         (e (presentedCoordinate k n))) := by
259     rw [hmap]
260     have hx : e (presentedCoordinate k n) =
261         pairCoordinate (B := IteratedPairStage k n) := by
262       change presentedToIterated k (n + 1) (presentedCoordinate k n) =
263         pairCoordinate (B := IteratedPairStage k n)
264       simpa only [stageCoordinate] using (presentedToIterated_coordinate k n)
265     rw [hx]
266     exact hsurj
267   intro q
268   obtain ⟨r, hr⟩ := hsurj' (f q)
269   refine ⟨f.symm r, ?_⟩
270   apply f.injective
271   rw [transportedRightQuotientEquiv_rightMul]
272   rw [f.apply_symm_apply]
273   exact hr
274 
275 #print axioms transported_canonicalRightIdeal
276 #print axioms presented_canonicalRightIdeal_map
277 #print axioms transportedRightQuotientEquiv
278 #print axioms transportedRightQuotientEquiv_rightMul
279 #print axioms presentedCanonicalRightQuotient_rightMul_coordinate_surjective
280 
281 end
282 end Stafford38.WeylQuotientTransport
283