Stafford38/Weyl/TranspositionFiltration.lean

This project (Stafford38) · 1029fdb382eee06e7b59bcf32801f40931e2079a

1 module
2 public import Stafford38.MathlibCompat.MvPolynomialCoeff
3 public import Stafford38.Weyl.Transposition
4 public import Stafford38.Weyl.GradedAlgebra
5 public import Stafford38.Weyl.SymbolCompatibility
6 
7 @[expose] public section
8 
9 /-!
10 # Filtration and symbol transport under Weyl transposition
11 
12 The Weyl transposition reverses products, fixes coordinates, and negates
13 momenta.  This file proves directly from the checked PBW filtration that it
14 preserves both differential order and Bernstein degree.  No filtered
15 `D`-module or characteristic-variety theorem is used here.
16 -/
17 
18 namespace Stafford38.WeylTranspositionFiltration
19 
20 open MulOpposite
21 open Stafford
22 open Stafford38.Characteristic
23 open Stafford38.CharacteristicLinearAction
24 open Stafford38.WeylAssociatedGraded
25 open Stafford38.WeylFiltration
26 open Stafford38.WeylIteratedEquivalence
27 open Stafford38.WeylLeadingSymbol
28 open Stafford38.WeylPBW
29 open Stafford38.WeylTransposition
30 
31 noncomputable section
32 
33 set_option maxHeartbeats 1000000
34 
35 universe u
36 
37 variable (k : Type u) [Field k]
38 
39 @[simp] theorem transpose_zero (n : Nat) :
40     transpose k n 0 = 0 := by
41   simp [transpose]
42 
43 @[simp] theorem transpose_add (n : Nat) (a b : PresentedWeyl k n) :
44     transpose k n (a + b) = transpose k n a + transpose k n b := by
45   simp [transpose]
46 
47 @[simp] theorem transpose_smul (n : Nat) (c : k) (a : PresentedWeyl k n) :
48     transpose k n (c • a) = c • transpose k n a := by
49   simp [transpose]
50 
51 @[simp] theorem transpose_pow (n : Nat) (a : PresentedWeyl k n) (r : Nat) :
52     transpose k n (a ^ r) = transpose k n a ^ r := by
53   induction r with
54   | zero => simp [transpose]
55   | succ r ih =>
56       rw [pow_succ, transpose_mul, ih]
57       calc
58         transpose k n a * transpose k n a ^ r =
59             transpose k n a ^ r * transpose k n a :=
60           ((Commute.refl (transpose k n a)).pow_right r).eq
61         _ = transpose k n a ^ (r + 1) := (pow_succ _ _).symm
62 
63 theorem transpose_previousWeylEmbedding (n : Nat) (a : PresentedWeyl k n) :
64     transpose k (n + 1) (previousWeylEmbedding k n a) =
65       previousWeylEmbedding k n (transpose k n a) := by
66   let lhs : PresentedWeyl k n →ₐ[k] (PresentedWeyl k (n + 1))ᵐᵒᵖ :=
67     (transpositionHom k (n + 1)).comp (previousWeylEmbedding k n)
68   let rhs : PresentedWeyl k n →ₐ[k] (PresentedWeyl k (n + 1))ᵐᵒᵖ :=
69     (AlgHom.op (previousWeylEmbedding k n)).comp (transpositionHom k n)
70   have h : lhs = rhs := by
71     apply Stafford38.WeylUniversal.freeWeyl_algHom_ext
72     intro i
73     dsimp [lhs, rhs]
74     cases i with
75     | inl i =>
76         rw [previousWeylEmbedding_generator,
77           show freeWeylGenerator (Matrix.J (Fin n) k) (.inl i) =
78             coordinate k n i from rfl,
79           transpositionHom_coordinate]
80         change transpositionHom k (n + 1) (oldGenerator k n (.inl i)) =
81           op (previousWeylEmbedding k n (coordinate k n i))
82         rw [show oldGenerator k n (.inl i) = coordinate k (n + 1) i.succ from rfl,
83           transpositionHom_coordinate]
84         have hp := previousWeylEmbedding_generator k n (.inl i)
85         change previousWeylEmbedding k n (coordinate k n i) =
86           coordinate k (n + 1) i.succ at hp
87         exact congrArg op hp.symm
88     | inr i =>
89         rw [previousWeylEmbedding_generator,
90           show freeWeylGenerator (Matrix.J (Fin n) k) (.inr i) =
91             momentum k n i from rfl,
92           transpositionHom_momentum]
93         change transpositionHom k (n + 1) (oldGenerator k n (.inr i)) =
94           op (previousWeylEmbedding k n (-momentum k n i))
95         rw [show oldGenerator k n (.inr i) = momentum k (n + 1) i.succ from rfl,
96           transpositionHom_momentum, map_neg]
97         have hp := previousWeylEmbedding_generator k n (.inr i)
98         change previousWeylEmbedding k n (momentum k n i) =
99           momentum k (n + 1) i.succ at hp
100         exact congrArg op (congrArg Neg.neg hp.symm)
101   have ha := DFunLike.congr_fun h a
102   exact congrArg MulOpposite.unop ha
103 
104 theorem coordinate_mem_bernsteinPiece {n : Nat} (i : Fin n) :
105     coordinate k n i ∈ bernsteinPiece k n 1 := by
106   rw [bernsteinPiece, mem_presentedWeightPiece, coordinate,
107     presentedNormalFormLinearEquiv_generator]
108   intro m hm
109   simp only [MvPolynomial.coeff_X', ne_eq, ite_eq_right_iff] at hm
110   by_contra hweight
111   exact hm (by
112     intro h
113     subst m
114     simp [monomialWeight, bernsteinWeight] at hweight)
115 
116 theorem momentum_mem_bernsteinPiece {n : Nat} (i : Fin n) :
117     momentum k n i ∈ bernsteinPiece k n 1 := by
118   rw [bernsteinPiece, mem_presentedWeightPiece, momentum,
119     presentedNormalFormLinearEquiv_generator]
120   intro m hm
121   simp only [MvPolynomial.coeff_X', ne_eq, ite_eq_right_iff] at hm
122   by_contra hweight
123   exact hm (by
124     intro h
125     subst m
126     simp [monomialWeight, bernsteinWeight] at hweight)
127 
128 theorem coordinate_mem_orderPiece {n : Nat} (i : Fin n) :
129     coordinate k n i ∈ orderPiece k n 0 := by
130   rw [orderPiece, mem_presentedWeightPiece, coordinate,
131     presentedNormalFormLinearEquiv_generator]
132   intro m hm
133   simp only [MvPolynomial.coeff_X', ne_eq, ite_eq_right_iff] at hm
134   by_contra hweight
135   exact hm (by
136     intro h
137     subst m
138     simp [monomialWeight, orderWeight, fibreWeight] at hweight)
139 
140 theorem momentum_mem_orderPiece {n : Nat} (i : Fin n) :
141     momentum k n i ∈ orderPiece k n 1 := by
142   rw [orderPiece, mem_presentedWeightPiece, momentum,
143     presentedNormalFormLinearEquiv_generator]
144   intro m hm
145   simp only [MvPolynomial.coeff_X', ne_eq, ite_eq_right_iff] at hm
146   by_contra hweight
147   exact hm (by
148     intro h
149     subst m
150     simp [monomialWeight, orderWeight, fibreWeight] at hweight)
151 
152 private theorem one_mem_weightPiece {n : Nat} (w : PhaseVar n → Nat) :
153     (1 : PresentedWeyl k n) ∈ presentedWeightPiece k w 0 := by
154   rw [mem_presentedWeightPiece, presentedNormalFormLinearEquiv_one]
155   intro m hm
156   simp only [MvPolynomial.coeff_one, ne_eq, ite_eq_right_iff] at hm
157   by_contra hweight
158   exact hm (by
159     intro h
160     subst m
161     simp [monomialWeight] at hweight)
162 
163 theorem coordinate_pow_mem_bernsteinPiece {n : Nat} (i : Fin n) (r : Nat) :
164     coordinate k n i ^ r ∈ bernsteinPiece k n r := by
165   induction r with
166   | zero => simpa [bernsteinPiece] using one_mem_weightPiece k (@bernsteinWeight n)
167   | succ r ih =>
168       simpa [pow_succ] using mul_mem_bernsteinPiece k ih
169         (coordinate_mem_bernsteinPiece k i)
170 
171 theorem momentum_pow_mem_bernsteinPiece {n : Nat} (i : Fin n) (r : Nat) :
172     (-momentum k n i) ^ r ∈ bernsteinPiece k n r := by
173   have hm : -momentum k n i ∈ bernsteinPiece k n 1 :=
174     (bernsteinPiece k n 1).neg_mem (momentum_mem_bernsteinPiece k i)
175   induction r with
176   | zero => simpa [bernsteinPiece] using one_mem_weightPiece k (@bernsteinWeight n)
177   | succ r ih => simpa [pow_succ] using mul_mem_bernsteinPiece k ih hm
178 
179 theorem coordinate_pow_mem_orderPiece {n : Nat} (i : Fin n) (r : Nat) :
180     coordinate k n i ^ r ∈ orderPiece k n 0 := by
181   induction r with
182   | zero => simpa [orderPiece] using one_mem_weightPiece k (@orderWeight n)
183   | succ r ih =>
184       simpa [pow_succ] using mul_mem_orderPiece k ih
185         (coordinate_mem_orderPiece k i)
186 
187 theorem momentum_pow_mem_orderPiece {n : Nat} (i : Fin n) (r : Nat) :
188     (-momentum k n i) ^ r ∈ orderPiece k n r := by
189   have hm : -momentum k n i ∈ orderPiece k n 1 :=
190     (orderPiece k n 1).neg_mem (momentum_mem_orderPiece k i)
191   induction r with
192   | zero => simpa [orderPiece] using one_mem_weightPiece k (@orderWeight n)
193   | succ r ih => simpa [pow_succ] using mul_mem_orderPiece k ih hm
194 
195 theorem previousWeylEmbedding_mem_bernsteinPiece {n N : Nat}
196     {a : PresentedWeyl k n} (ha : a ∈ bernsteinPiece k n N) :
197     previousWeylEmbedding k n a ∈ bernsteinPiece k (n + 1) N := by
198   simpa [presentedCoefficientOrdered] using
199     presentedCoefficientOrdered_mem_bernsteinPiece k n N 0 0 a ha
200 
201 theorem previousWeylEmbedding_mem_orderPiece {n N : Nat}
202     {a : PresentedWeyl k n} (ha : a ∈ orderPiece k n N) :
203     previousWeylEmbedding k n a ∈ orderPiece k (n + 1) N := by
204   simpa [presentedCoefficientOrdered] using
205     presentedCoefficientOrdered_mem_orderPiece k n N 0 0 a ha
206 
207 theorem transpose_orderedMonomial_mem_bernsteinPiece :
208     ∀ (n : Nat) (a p : Fin n → Nat),
209       transpose k n (presentedOrderedMonomial k n a p) ∈
210         bernsteinPiece k n
211           (monomialWeight (@bernsteinWeight n) (phaseExponent a p)) := by
212   intro n
213   induction n with
214   | zero =>
215       intro a p
216       have he : phaseExponent a p = 0 := by
217         ext i
218         exact Sum.elim Fin.elim0 Fin.elim0 i
219       rw [he]
220       simpa [presentedOrderedMonomial, monomialWeight, bernsteinPiece,
221         transpose] using one_mem_weightPiece k (@bernsteinWeight 0)
222   | succ n ih =>
223       intro a p
224       let oldA : Fin n → Nat := fun i => a i.succ
225       let oldP : Fin n → Nat := fun i => p i.succ
226       have hold := previousWeylEmbedding_mem_bernsteinPiece k
227         (ih oldA oldP)
228       have hx := coordinate_pow_mem_bernsteinPiece k
229         (0 : Fin (n + 1)) (a 0)
230       have hp := momentum_pow_mem_bernsteinPiece k
231         (0 : Fin (n + 1)) (p 0)
232       have hmul := mul_mem_bernsteinPiece k
233         (mul_mem_bernsteinPiece k hp hx) hold
234       rw [presentedOrderedMonomial, transpose_mul, transpose_mul,
235         transpose_pow, transpose_pow,
236         show presentedMomentum k n = momentum k (n + 1) 0 from rfl,
237         show presentedCoordinate k n = coordinate k (n + 1) 0 from rfl,
238         transpose_momentum, transpose_coordinate,
239         transpose_previousWeylEmbedding]
240       rw [monomialWeight_phaseExponent_succ_bernstein]
241       simpa [oldA, oldP, mul_assoc, add_assoc, add_comm, add_left_comm] using hmul
242 
243 theorem transpose_orderedMonomial_mem_orderPiece :
244     ∀ (n : Nat) (a p : Fin n → Nat),
245       transpose k n (presentedOrderedMonomial k n a p) ∈
246         orderPiece k n
247           (monomialWeight (@orderWeight n) (phaseExponent a p)) := by
248   intro n
249   induction n with
250   | zero =>
251       intro a p
252       have he : phaseExponent a p = 0 := by
253         ext i
254         exact Sum.elim Fin.elim0 Fin.elim0 i
255       rw [he]
256       simpa [presentedOrderedMonomial, monomialWeight, orderPiece,
257         transpose] using one_mem_weightPiece k (@orderWeight 0)
258   | succ n ih =>
259       intro a p
260       let oldA : Fin n → Nat := fun i => a i.succ
261       let oldP : Fin n → Nat := fun i => p i.succ
262       have hold := previousWeylEmbedding_mem_orderPiece k (ih oldA oldP)
263       have hx := coordinate_pow_mem_orderPiece k
264         (0 : Fin (n + 1)) (a 0)
265       have hp := momentum_pow_mem_orderPiece k
266         (0 : Fin (n + 1)) (p 0)
267       have hmul := mul_mem_orderPiece k (mul_mem_orderPiece k hp hx) hold
268       rw [presentedOrderedMonomial, transpose_mul, transpose_mul,
269         transpose_pow, transpose_pow,
270         show presentedMomentum k n = momentum k (n + 1) 0 from rfl,
271         show presentedCoordinate k n = coordinate k (n + 1) 0 from rfl,
272         transpose_momentum, transpose_coordinate,
273         transpose_previousWeylEmbedding]
274       rw [monomialWeight_phaseExponent_succ_order]
275       simpa [oldA, oldP, mul_assoc, add_assoc, add_comm, add_left_comm] using hmul
276 
277 theorem transpose_mem_bernsteinPiece {n N : Nat} {a : PresentedWeyl k n}
278     (ha : a ∈ bernsteinPiece k n N) :
279     transpose k n a ∈ bernsteinPiece k n N := by
280   rw [bernsteinPiece, presentedWeightPiece_eq_span] at ha
281   change transpose k n a ∈ presentedWeightPiece k bernsteinWeight N
282   induction ha using Submodule.span_induction with
283   | mem b hb =>
284       obtain ⟨m, hm, rfl⟩ := hb
285       rw [presentedPBWBasis_apply]
286       have hmono := transpose_orderedMonomial_mem_bernsteinPiece k n
287         (fun i => m (.inl i)) (fun i => m (.inr i))
288       exact presentedWeightPiece_mono k bernsteinWeight hm
289         (by simpa [bernsteinPiece, phaseExponent_split] using hmono)
290   | zero =>
291       rw [transpose_zero]
292       exact (presentedWeightPiece k bernsteinWeight N).zero_mem
293   | add x y hx hy ihx ihy =>
294       rw [transpose_add]
295       exact (presentedWeightPiece k bernsteinWeight N).add_mem ihx ihy
296   | smul c x hx ih =>
297       rw [transpose_smul]
298       exact (presentedWeightPiece k bernsteinWeight N).smul_mem c ih
299 
300 theorem transpose_mem_orderPiece {n N : Nat} {a : PresentedWeyl k n}
301     (ha : a ∈ orderPiece k n N) :
302     transpose k n a ∈ orderPiece k n N := by
303   rw [orderPiece, presentedWeightPiece_eq_span] at ha
304   change transpose k n a ∈ presentedWeightPiece k orderWeight N
305   induction ha using Submodule.span_induction with
306   | mem b hb =>
307       obtain ⟨m, hm, rfl⟩ := hb
308       rw [presentedPBWBasis_apply]
309       have hmono := transpose_orderedMonomial_mem_orderPiece k n
310         (fun i => m (.inl i)) (fun i => m (.inr i))
311       exact presentedWeightPiece_mono k orderWeight hm
312         (by simpa [orderPiece, phaseExponent_split] using hmono)
313   | zero =>
314       rw [transpose_zero]
315       exact (presentedWeightPiece k orderWeight N).zero_mem
316   | add x y hx hy ihx ihy =>
317       rw [transpose_add]
318       exact (presentedWeightPiece k orderWeight N).add_mem ihx ihy
319   | smul c x hx ih =>
320       rw [transpose_smul]
321       exact (presentedWeightPiece k orderWeight N).smul_mem c ih
322 
323 theorem transpose_mem_bernsteinPiece_iff {n N : Nat} (a : PresentedWeyl k n) :
324     transpose k n a ∈ bernsteinPiece k n N ↔ a ∈ bernsteinPiece k n N := by
325   constructor
326   · intro h
327     simpa using transpose_mem_bernsteinPiece k h
328   · exact transpose_mem_bernsteinPiece k
329 
330 theorem transpose_mem_orderPiece_iff {n N : Nat} (a : PresentedWeyl k n) :
331     transpose k n a ∈ orderPiece k n N ↔ a ∈ orderPiece k n N := by
332   constructor
333   · intro h
334     simpa using transpose_mem_orderPiece k h
335   · exact transpose_mem_orderPiece k
336 
337 /-- The expected phase-space sign substitution: coordinates are fixed and
338 momentum variables are negated. -/
339 def symbolTransposition {n : Nat} : SymbolRing k n →ₐ[k] SymbolRing k n :=
340   MvPolynomial.aeval (Sum.elim
341     (fun i : Fin n => MvPolynomial.X (.inl i))
342     (fun i : Fin n => -MvPolynomial.X (.inr i)))
343 
344 @[simp] theorem symbolTransposition_coordinate {n : Nat} (i : Fin n) :
345     symbolTransposition k (MvPolynomial.X (.inl i)) = MvPolynomial.X (.inl i) := by
346   simp [symbolTransposition]
347 
348 @[simp] theorem symbolTransposition_momentum {n : Nat} (i : Fin n) :
349     symbolTransposition k (MvPolynomial.X (.inr i)) = -MvPolynomial.X (.inr i) := by
350   simp [symbolTransposition]
351 
352 private theorem principal_coordinate_bernstein {n : Nat} (i : Fin n) :
353     presentedPrincipalComponent k (@bernsteinWeight n) 1 (coordinate k n i) =
354       MvPolynomial.X (.inl i) := by
355   rw [presentedPrincipalComponent, LinearMap.comp_apply,
356     LinearEquiv.coe_toLinearMap, coordinate,
357     presentedNormalFormLinearEquiv_generator]
358   have hx : MvPolynomial.X (.inl i : PhaseVar n) =
359       MvPolynomial.monomial
360         (Finsupp.single (.inl i : PhaseVar n) 1) (1 : k) := by
361     simpa using (MvPolynomial.X_pow_eq_monomial
362       (R := k) (n := (.inl i : PhaseVar n)) (e := 1))
363   rw [hx]
364   rw [weightedHomogeneousComponent_monomial]
365   simp [monomialWeight, bernsteinWeight]
366 
367 private theorem principal_momentum_bernstein {n : Nat} (i : Fin n) :
368     presentedPrincipalComponent k (@bernsteinWeight n) 1 (momentum k n i) =
369       MvPolynomial.X (.inr i) := by
370   rw [presentedPrincipalComponent, LinearMap.comp_apply,
371     LinearEquiv.coe_toLinearMap, momentum,
372     presentedNormalFormLinearEquiv_generator]
373   have hx : MvPolynomial.X (.inr i : PhaseVar n) =
374       MvPolynomial.monomial
375         (Finsupp.single (.inr i : PhaseVar n) 1) (1 : k) := by
376     simpa using (MvPolynomial.X_pow_eq_monomial
377       (R := k) (n := (.inr i : PhaseVar n)) (e := 1))
378   rw [hx]
379   rw [weightedHomogeneousComponent_monomial]
380   simp [monomialWeight, bernsteinWeight]
381 
382 private theorem principal_negMomentum_pow_bernstein {n : Nat}
383     (i : Fin n) (r : Nat) :
384     presentedPrincipalComponent k (@bernsteinWeight n) r
385         ((-momentum k n i) ^ r) = (-MvPolynomial.X (.inr i)) ^ r := by
386   have hm : -momentum k n i ∈ bernsteinPiece k n 1 :=
387     (bernsteinPiece k n 1).neg_mem (momentum_mem_bernsteinPiece k i)
388   rw [Stafford38.WeylSymbolCompatibility.pow_principal_bernstein k hm,
389     map_neg, principal_momentum_bernstein]
390 
391 private theorem principal_coordinate_pow_bernstein {n : Nat}
392     (i : Fin n) (r : Nat) :
393     presentedPrincipalComponent k (@bernsteinWeight n) r
394         (coordinate k n i ^ r) = MvPolynomial.X (.inl i) ^ r := by
395   rw [Stafford38.WeylSymbolCompatibility.pow_principal_bernstein k
396       (coordinate_mem_bernsteinPiece k i),
397     principal_coordinate_bernstein]
398 
399 private theorem principal_previous_bernstein {n N : Nat}
400     (a : PresentedWeyl k n) :
401     presentedPrincipalComponent k (@bernsteinWeight (n + 1)) N
402         (previousWeylEmbedding k n a) =
403       MvPolynomial.rename oldIndex
404         (presentedPrincipalComponent k (@bernsteinWeight n) N a) := by
405   simpa [presentedCoefficientOrdered, extendPhaseExponent] using
406     presentedPrincipalComponent_coefficientOrdered_bernstein k n N 0 0 a
407 
408 theorem symbolTransposition_rename_oldIndex {n : Nat} (f : SymbolRing k n) :
409     symbolTransposition k (MvPolynomial.rename oldIndex f) =
410       MvPolynomial.rename oldIndex (symbolTransposition k f) := by
411   let lhs : SymbolRing k n →ₐ[k] SymbolRing k (n + 1) :=
412     (symbolTransposition k).comp (MvPolynomial.rename oldIndex)
413   let rhs : SymbolRing k n →ₐ[k] SymbolRing k (n + 1) :=
414     (MvPolynomial.rename oldIndex).comp (symbolTransposition k)
415   have h : lhs = rhs := by
416     apply MvPolynomial.algHom_ext
417     intro i
418     cases i with
419     | inl i => simp [lhs, rhs, oldIndex]
420     | inr i => simp [lhs, rhs, oldIndex]
421   exact DFunLike.congr_fun h f
422 
423 theorem principal_transpose_orderedMonomial_bernstein :
424     ∀ (n : Nat) (a p : Fin n → Nat),
425       presentedPrincipalComponent k (@bernsteinWeight n)
426           (monomialWeight (@bernsteinWeight n) (phaseExponent a p))
427           (transpose k n (presentedOrderedMonomial k n a p)) =
428         symbolTransposition k
429           (MvPolynomial.monomial (phaseExponent a p) (1 : k)) := by
430   intro n
431   induction n with
432   | zero =>
433       intro a p
434       have he : phaseExponent a p = 0 := by
435         ext i
436         exact Sum.elim Fin.elim0 Fin.elim0 i
437       rw [he]
438       simp [presentedOrderedMonomial, transpose, monomialWeight,
439         presentedPrincipalComponent, presentedNormalFormLinearEquiv_one,
440         weightedHomogeneousComponent_monomial, symbolTransposition]
441   | succ n ih =>
442       intro a p
443       let oldA : Fin n → Nat := fun i => a i.succ
444       let oldP : Fin n → Nat := fun i => p i.succ
445       let oldD := monomialWeight (@bernsteinWeight n) (phaseExponent oldA oldP)
446       have hold := previousWeylEmbedding_mem_bernsteinPiece k
447         (transpose_orderedMonomial_mem_bernsteinPiece k n oldA oldP)
448       have hx := coordinate_pow_mem_bernsteinPiece k
449         (0 : Fin (n + 1)) (a 0)
450       have hp := momentum_pow_mem_bernsteinPiece k
451         (0 : Fin (n + 1)) (p 0)
452       have hxo := mul_mem_bernsteinPiece k hx hold
453       rw [presentedOrderedMonomial, transpose_mul, transpose_mul,
454         transpose_pow, transpose_pow,
455         show presentedMomentum k n = momentum k (n + 1) 0 from rfl,
456         show presentedCoordinate k n = coordinate k (n + 1) 0 from rfl,
457         transpose_momentum, transpose_coordinate,
458         transpose_previousWeylEmbedding,
459         monomialWeight_phaseExponent_succ_bernstein]
460       change presentedPrincipalComponent k (@bernsteinWeight (n + 1))
461           (oldD + a 0 + p 0)
462           ((-momentum k (n + 1) 0) ^ p 0 *
463             (coordinate k (n + 1) 0 ^ a 0 *
464               previousWeylEmbedding k n
465                 (transpose k n (presentedOrderedMonomial k n oldA oldP)))) = _
466       rw [show oldD + a 0 + p 0 = p 0 + (a 0 + oldD) by omega,
467         presentedPrincipalComponent_mul_bernstein k hp hxo,
468         presentedPrincipalComponent_mul_bernstein k hx hold,
469         principal_negMomentum_pow_bernstein,
470         principal_coordinate_pow_bernstein,
471         principal_previous_bernstein, ih oldA oldP]
472       rw [Stafford38.WeylSymbolCompatibility.phaseMonomial_succ_decompose]
473       simp only [map_mul, map_pow, symbolTransposition_coordinate,
474         symbolTransposition_momentum, symbolTransposition_rename_oldIndex]
475       ring
476 
477 theorem principal_transpose_bernstein {n N : Nat} {a : PresentedWeyl k n}
478     (ha : a ∈ bernsteinPiece k n N) :
479     presentedPrincipalComponent k (@bernsteinWeight n) N (transpose k n a) =
480       symbolTransposition k
481         (presentedPrincipalComponent k (@bernsteinWeight n) N a) := by
482   rw [bernsteinPiece, presentedWeightPiece_eq_span] at ha
483   induction ha using Submodule.span_induction with
484   | mem b hb =>
485       obtain ⟨m, hm, rfl⟩ := hb
486       let d := monomialWeight (@bernsteinWeight n) m
487       by_cases hd : d = N
488       · subst N
489         rw [presentedPBWBasis_apply]
490         have ht := principal_transpose_orderedMonomial_bernstein k n
491           (fun i => m (.inl i)) (fun i => m (.inr i))
492         have ht' :
493             presentedPrincipalComponent k (@bernsteinWeight n) d
494                 (transpose k n
495                   (presentedOrderedMonomial k n
496                     (fun i => m (.inl i)) (fun i => m (.inr i)))) =
497               symbolTransposition k (MvPolynomial.monomial m (1 : k)) := by
498           simpa [phaseExponent_split] using ht
499         have ho :
500             presentedPrincipalComponent k (@bernsteinWeight n) d
501                 (presentedOrderedMonomial k n
502                   (fun i => m (.inl i)) (fun i => m (.inr i))) =
503               MvPolynomial.monomial m (1 : k) := by
504           rw [← presentedPBWBasis_apply,
505             presentedPrincipalComponent_basis, if_pos rfl]
506         rw [ht', ho]
507       · have hdlt : d < N := lt_of_le_of_ne hm hd
508         have ht := transpose_orderedMonomial_mem_bernsteinPiece k n
509           (fun i => m (.inl i)) (fun i => m (.inr i))
510         rw [presentedPBWBasis_apply]
511         have ht' : transpose k n
512               (presentedOrderedMonomial k n
513                 (fun i => m (.inl i)) (fun i => m (.inr i))) ∈
514             bernsteinPiece k n d := by
515           simpa [phaseExponent_split] using ht
516         have ho :
517             presentedPrincipalComponent k (@bernsteinWeight n) N
518                 (presentedOrderedMonomial k n
519                   (fun i => m (.inl i)) (fun i => m (.inr i))) = 0 := by
520           rw [← presentedPBWBasis_apply,
521             presentedPrincipalComponent_basis, if_neg hd]
522         rw [presentedPrincipalComponent_eq_zero_of_mem_of_lt k
523             bernsteinWeight _ ht' hdlt, ho, map_zero]
524   | zero => simp
525   | add x y hx hy ihx ihy => simp only [transpose_add, map_add, ihx, ihy]
526   | smul c x hx ih => simp only [transpose_smul, map_smul, ih]
527 
528 private theorem principal_coordinate_order {n : Nat} (i : Fin n) :
529     presentedPrincipalComponent k (@orderWeight n) 0 (coordinate k n i) =
530       MvPolynomial.X (.inl i) := by
531   rw [presentedPrincipalComponent, LinearMap.comp_apply,
532     LinearEquiv.coe_toLinearMap, coordinate,
533     presentedNormalFormLinearEquiv_generator]
534   have hx : MvPolynomial.X (.inl i : PhaseVar n) =
535       MvPolynomial.monomial
536         (Finsupp.single (.inl i : PhaseVar n) 1) (1 : k) := by
537     simpa using (MvPolynomial.X_pow_eq_monomial
538       (R := k) (n := (.inl i : PhaseVar n)) (e := 1))
539   rw [hx, weightedHomogeneousComponent_monomial]
540   simp [monomialWeight, orderWeight, fibreWeight]
541 
542 private theorem principal_momentum_order {n : Nat} (i : Fin n) :
543     presentedPrincipalComponent k (@orderWeight n) 1 (momentum k n i) =
544       MvPolynomial.X (.inr i) := by
545   rw [presentedPrincipalComponent, LinearMap.comp_apply,
546     LinearEquiv.coe_toLinearMap, momentum,
547     presentedNormalFormLinearEquiv_generator]
548   have hx : MvPolynomial.X (.inr i : PhaseVar n) =
549       MvPolynomial.monomial
550         (Finsupp.single (.inr i : PhaseVar n) 1) (1 : k) := by
551     simpa using (MvPolynomial.X_pow_eq_monomial
552       (R := k) (n := (.inr i : PhaseVar n)) (e := 1))
553   rw [hx, weightedHomogeneousComponent_monomial]
554   simp [monomialWeight, orderWeight, fibreWeight]
555 
556 private theorem principal_one_order {n : Nat} :
557     presentedPrincipalComponent k (@orderWeight n) 0
558         (1 : PresentedWeyl k n) = 1 := by
559   rw [presentedPrincipalComponent, LinearMap.comp_apply,
560     LinearEquiv.coe_toLinearMap, presentedNormalFormLinearEquiv_one]
561   rw [show (1 : SymbolRing k n) = MvPolynomial.monomial 0 (1 : k) by simp,
562     weightedHomogeneousComponent_monomial]
563   simp [monomialWeight]
564 
565 private theorem principal_coordinate_pow_order {n : Nat}
566     (i : Fin n) (r : Nat) :
567     presentedPrincipalComponent k (@orderWeight n) 0
568         (coordinate k n i ^ r) = MvPolynomial.X (.inl i) ^ r := by
569   induction r with
570   | zero => simpa using principal_one_order k (n := n)
571   | succ r ih =>
572       rw [pow_succ, pow_succ]
573       rw [presentedPrincipalComponent_mul_order k
574         (coordinate_pow_mem_orderPiece k i r) (coordinate_mem_orderPiece k i),
575         ih, principal_coordinate_order]
576 
577 private theorem principal_negMomentum_pow_order {n : Nat}
578     (i : Fin n) (r : Nat) :
579     presentedPrincipalComponent k (@orderWeight n) r
580         ((-momentum k n i) ^ r) = (-MvPolynomial.X (.inr i)) ^ r := by
581   induction r with
582   | zero => simpa using principal_one_order k (n := n)
583   | succ r ih =>
584       have hm : -momentum k n i ∈ orderPiece k n 1 :=
585         (orderPiece k n 1).neg_mem (momentum_mem_orderPiece k i)
586       rw [pow_succ, pow_succ]
587       rw [presentedPrincipalComponent_mul_order k
588         (momentum_pow_mem_orderPiece k i r) hm,
589         ih,
590         map_neg, principal_momentum_order]
591 
592 private theorem principal_previous_order {n N : Nat}
593     (a : PresentedWeyl k n) :
594     presentedPrincipalComponent k (@orderWeight (n + 1)) N
595         (previousWeylEmbedding k n a) =
596       MvPolynomial.rename oldIndex
597         (presentedPrincipalComponent k (@orderWeight n) N a) := by
598   simpa [presentedCoefficientOrdered, extendPhaseExponent] using
599     presentedPrincipalComponent_coefficientOrdered_order k n N 0 0 a
600 
601 theorem principal_transpose_orderedMonomial_order :
602     ∀ (n : Nat) (a p : Fin n → Nat),
603       presentedPrincipalComponent k (@orderWeight n)
604           (monomialWeight (@orderWeight n) (phaseExponent a p))
605           (transpose k n (presentedOrderedMonomial k n a p)) =
606         symbolTransposition k
607           (MvPolynomial.monomial (phaseExponent a p) (1 : k)) := by
608   intro n
609   induction n with
610   | zero =>
611       intro a p
612       have he : phaseExponent a p = 0 := by
613         ext i
614         exact Sum.elim Fin.elim0 Fin.elim0 i
615       rw [he]
616       simp [presentedOrderedMonomial, transpose, monomialWeight,
617         presentedPrincipalComponent, presentedNormalFormLinearEquiv_one,
618         weightedHomogeneousComponent_monomial, symbolTransposition]
619   | succ n ih =>
620       intro a p
621       let oldA : Fin n → Nat := fun i => a i.succ
622       let oldP : Fin n → Nat := fun i => p i.succ
623       let oldD := monomialWeight (@orderWeight n) (phaseExponent oldA oldP)
624       have hold := previousWeylEmbedding_mem_orderPiece k
625         (transpose_orderedMonomial_mem_orderPiece k n oldA oldP)
626       have hx := coordinate_pow_mem_orderPiece k
627         (0 : Fin (n + 1)) (a 0)
628       have hp := momentum_pow_mem_orderPiece k
629         (0 : Fin (n + 1)) (p 0)
630       have hxo := mul_mem_orderPiece k hx hold
631       rw [presentedOrderedMonomial, transpose_mul, transpose_mul,
632         transpose_pow, transpose_pow,
633         show presentedMomentum k n = momentum k (n + 1) 0 from rfl,
634         show presentedCoordinate k n = coordinate k (n + 1) 0 from rfl,
635         transpose_momentum, transpose_coordinate,
636         transpose_previousWeylEmbedding,
637         monomialWeight_phaseExponent_succ_order]
638       change presentedPrincipalComponent k (@orderWeight (n + 1))
639           (oldD + p 0)
640           ((-momentum k (n + 1) 0) ^ p 0 *
641             (coordinate k (n + 1) 0 ^ a 0 *
642               previousWeylEmbedding k n
643                 (transpose k n (presentedOrderedMonomial k n oldA oldP)))) = _
644       rw [show oldD + p 0 = p 0 + (0 + oldD) by omega,
645         presentedPrincipalComponent_mul_order k hp hxo,
646         presentedPrincipalComponent_mul_order k hx hold,
647         principal_negMomentum_pow_order,
648         principal_coordinate_pow_order,
649         principal_previous_order, ih oldA oldP]
650       rw [Stafford38.WeylSymbolCompatibility.phaseMonomial_succ_decompose]
651       simp only [map_mul, map_pow, symbolTransposition_coordinate,
652         symbolTransposition_momentum, symbolTransposition_rename_oldIndex]
653       ring
654 
655 theorem principal_transpose_order {n N : Nat} {a : PresentedWeyl k n}
656     (ha : a ∈ orderPiece k n N) :
657     presentedPrincipalComponent k (@orderWeight n) N (transpose k n a) =
658       symbolTransposition k
659         (presentedPrincipalComponent k (@orderWeight n) N a) := by
660   rw [orderPiece, presentedWeightPiece_eq_span] at ha
661   induction ha using Submodule.span_induction with
662   | mem b hb =>
663       obtain ⟨m, hm, rfl⟩ := hb
664       let d := monomialWeight (@orderWeight n) m
665       by_cases hd : d = N
666       · subst N
667         rw [presentedPBWBasis_apply]
668         have ht := principal_transpose_orderedMonomial_order k n
669           (fun i => m (.inl i)) (fun i => m (.inr i))
670         have ht' :
671             presentedPrincipalComponent k (@orderWeight n) d
672                 (transpose k n
673                   (presentedOrderedMonomial k n
674                     (fun i => m (.inl i)) (fun i => m (.inr i)))) =
675               symbolTransposition k (MvPolynomial.monomial m (1 : k)) := by
676           simpa [phaseExponent_split] using ht
677         have ho :
678             presentedPrincipalComponent k (@orderWeight n) d
679                 (presentedOrderedMonomial k n
680                   (fun i => m (.inl i)) (fun i => m (.inr i))) =
681               MvPolynomial.monomial m (1 : k) := by
682           rw [← presentedPBWBasis_apply,
683             presentedPrincipalComponent_basis, if_pos rfl]
684         rw [ht', ho]
685       · have hdlt : d < N := lt_of_le_of_ne hm hd
686         have ht := transpose_orderedMonomial_mem_orderPiece k n
687           (fun i => m (.inl i)) (fun i => m (.inr i))
688         rw [presentedPBWBasis_apply]
689         have ht' : transpose k n
690               (presentedOrderedMonomial k n
691                 (fun i => m (.inl i)) (fun i => m (.inr i))) ∈
692             orderPiece k n d := by
693           simpa [phaseExponent_split] using ht
694         have ho :
695             presentedPrincipalComponent k (@orderWeight n) N
696                 (presentedOrderedMonomial k n
697                   (fun i => m (.inl i)) (fun i => m (.inr i))) = 0 := by
698           rw [← presentedPBWBasis_apply,
699             presentedPrincipalComponent_basis, if_neg hd]
700         rw [presentedPrincipalComponent_eq_zero_of_mem_of_lt k
701             orderWeight _ ht' hdlt, ho, map_zero]
702   | zero => simp
703   | add x y hx hy ihx ihy => simp only [transpose_add, map_add, ihx, ihy]
704   | smul c x hx ih => simp only [transpose_smul, map_smul, ih]
705 
706 theorem symbolTransposition_comp_self {n : Nat} :
707     (symbolTransposition k).comp (symbolTransposition k) =
708       AlgHom.id k (SymbolRing k n) := by
709   apply MvPolynomial.algHom_ext
710   intro i
711   cases i with
712   | inl i => simp
713   | inr i => simp
714 
715 def symbolTranspositionEquiv {n : Nat} :
716     SymbolRing k n ≃ₐ[k] SymbolRing k n :=
717   AlgEquiv.ofAlgHom (symbolTransposition k) (symbolTransposition k)
718     (symbolTransposition_comp_self k) (symbolTransposition_comp_self k)
719 
720 /-- The associated-graded automorphism corresponding to Weyl transposition.
721 It is conjugate to momentum-sign substitution under the checked symbol
722 equivalence. -/
723 def associatedGradedTransposition {n : Nat} (w : PhaseVar n → Nat) :
724     PresentedAssociatedGraded k w ≃ₐ[k] PresentedAssociatedGraded k w :=
725   (presentedAssociatedGradedAlgEquiv k w).trans
726     ((symbolTranspositionEquiv k).trans
727       (presentedAssociatedGradedAlgEquiv k w).symm)
728 
729 theorem associatedGradedTransposition_mk_bernstein {n N : Nat}
730     (a : bernsteinPiece k n N) :
731     associatedGradedTransposition k bernsteinWeight
732         (presentedAssociatedGradedMk k bernsteinWeight a) =
733       presentedAssociatedGradedMk k bernsteinWeight
734         ⟨transpose k n a, transpose_mem_bernsteinPiece k a.property⟩ := by
735   change presentedWeightPiece k bernsteinWeight N at a
736   apply (presentedAssociatedGradedAlgEquiv k bernsteinWeight).injective
737   simp [associatedGradedTransposition, symbolTranspositionEquiv,
738     principal_transpose_bernstein k a.property]
739 
740 theorem associatedGradedTransposition_mk_order {n N : Nat}
741     (a : orderPiece k n N) :
742     associatedGradedTransposition k orderWeight
743         (presentedAssociatedGradedMk k orderWeight a) =
744       presentedAssociatedGradedMk k orderWeight
745         ⟨transpose k n a, transpose_mem_orderPiece k a.property⟩ := by
746   change presentedWeightPiece k orderWeight N at a
747   apply (presentedAssociatedGradedAlgEquiv k orderWeight).injective
748   simp [associatedGradedTransposition, symbolTranspositionEquiv,
749     principal_transpose_order k a.property]
750 
751 theorem principal_transpose_coordinate {n : Nat} (i : Fin n) :
752     presentedPrincipalComponent k (@bernsteinWeight n) 1
753         (transpose k n (coordinate k n i)) =
754       symbolTransposition k
755         (presentedPrincipalComponent k (@bernsteinWeight n) 1
756           (coordinate k n i)) := by
757   rw [transpose_coordinate]
758   rw [principal_coordinate_bernstein, symbolTransposition_coordinate]
759 
760 theorem principal_transpose_momentum {n : Nat} (i : Fin n) :
761     presentedPrincipalComponent k (@bernsteinWeight n) 1
762         (transpose k n (momentum k n i)) =
763       symbolTransposition k
764         (presentedPrincipalComponent k (@bernsteinWeight n) 1
765           (momentum k n i)) := by
766   rw [transpose_momentum]
767   rw [map_neg, principal_momentum_bernstein, symbolTransposition_momentum]
768 
769 #print axioms transpose_mem_bernsteinPiece_iff
770 #print axioms transpose_mem_orderPiece_iff
771 #print axioms symbolTransposition
772 #print axioms principal_transpose_bernstein
773 #print axioms principal_transpose_order
774 #print axioms symbolTranspositionEquiv
775 #print axioms associatedGradedTransposition_mk_bernstein
776 #print axioms associatedGradedTransposition_mk_order
777 #print axioms principal_transpose_coordinate
778 #print axioms principal_transpose_momentum
779 
780 end
781 end Stafford38.WeylTranspositionFiltration
782