Stafford38/Weyl/LeadingSymbol.lean

This project (Stafford38) · 1029fdb382eee06e7b59bcf32801f40931e2079a

1 module
2 public import Stafford38.MathlibCompat.MvPolynomialCoeff
3 public import Stafford38.Weyl.Filtration
4 public import Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous
5 
6 @[expose] public section
7 
8 /-!
9 # Principal components and leading-symbol multiplication
10 
11 Weighted homogeneous projection of the checked PBW normal form defines the
12 degree-`N` principal component of a filtered Weyl element. Exact one-pair
13 normal ordering proves that, for both the Bernstein and differential-order
14 filtrations, the principal component of a product is the product of the
15 principal components. No associated graded identification is assumed here.
16 -/
17 
18 namespace Stafford38.WeylLeadingSymbol
19 
20 open Stafford38.Characteristic
21 open Stafford38.WeylIteratedEquivalence
22 open Stafford38.WeylPBW
23 open Stafford38.WeylFiltration
24 
25 noncomputable section
26 
27 universe u
28 
29 variable (k : Type u) [Field k]
30 
31 theorem finsupp_weight_eq_monomialWeight {n : ℕ}
32     (w : PhaseVar n → ℕ) (m : PhaseVar n →₀ ℕ) :
33     Finsupp.weight w m = monomialWeight w m := by
34   rfl
35 
36 /-- The homogeneous component at the declared filtration bound `N`. It is zero
37 when the element has strictly smaller actual weighted degree. -/
38 def presentedPrincipalComponent {n : ℕ} (w : PhaseVar n → ℕ) (N : ℕ) :
39     PresentedWeyl k n →ₗ[k] SymbolRing k n :=
40   (MvPolynomial.weightedHomogeneousComponent w N).comp
41     (presentedNormalFormLinearEquiv k n).toLinearMap
42 
43 theorem coeff_presentedPrincipalComponent {n : ℕ}
44     (w : PhaseVar n → ℕ) (N : ℕ) (z : PresentedWeyl k n)
45     (m : PhaseVar n →₀ ℕ) :
46     AddMonoidAlgebra.coeff (presentedPrincipalComponent k w N z) m =
47       if monomialWeight w m = N then
48         AddMonoidAlgebra.coeff (presentedNormalFormLinearEquiv k n z) m
49       else 0 := by
50   rw [presentedPrincipalComponent, LinearMap.comp_apply]
51   rw [MvPolynomial.coeff_weightedHomogeneousComponent,
52     finsupp_weight_eq_monomialWeight]
53   rfl
54 
55 theorem presentedPrincipalComponent_eq_zero_of_mem_of_lt {n L T : ℕ}
56     (w : PhaseVar n → ℕ) (z : PresentedWeyl k n)
57     (hz : z ∈ presentedWeightPiece k w L) (hLT : L < T) :
58     presentedPrincipalComponent k w T z = 0 := by
59   ext m
60   change AddMonoidAlgebra.coeff (presentedPrincipalComponent k w T z) m = 0
61   rw [coeff_presentedPrincipalComponent]
62   by_cases hm : monomialWeight w m = T
63   · rw [if_pos hm]
64     have hcoeff :
65         MvPolynomial.coeff m (presentedNormalFormLinearEquiv k n z) = 0 := by
66       by_contra hne
67       have hle := (mem_presentedWeightPiece k w L z).mp hz m hne
68       omega
69     change AddMonoidAlgebra.coeff (presentedNormalFormLinearEquiv k n z) m = 0 at hcoeff
70     rw [hcoeff]
71   · rw [if_neg hm]
72 
73 theorem presentedPrincipalComponent_basis {n : ℕ}
74     (w : PhaseVar n → ℕ) (N : ℕ) (m : PhaseVar n →₀ ℕ) :
75     presentedPrincipalComponent k w N (presentedPBWBasis k n m) =
76       if monomialWeight w m = N then MvPolynomial.monomial m 1 else 0 := by
77   classical
78   ext q
79   change AddMonoidAlgebra.coeff
80     (presentedPrincipalComponent k w N (presentedPBWBasis k n m)) q = _
81   rw [coeff_presentedPrincipalComponent,
82     presentedNormalFormLinearEquiv_basis]
83   by_cases hm : monomialWeight w m = N
84   · rw [if_pos hm, MvPolynomial.coeff_monomial]
85     by_cases hmq : m = q
86     · subst q
87       simp [hm]
88     · simp [hmq, Ne.symm hmq]
89   · rw [if_neg hm, MvPolynomial.coeff_zero]
90     by_cases hqm : q = m
91     · subst q
92       simp [hm]
93     · simp [hqm, Ne.symm hqm]
94 
95 theorem weightedHomogeneousComponent_monomial {n N : ℕ}
96     (w : PhaseVar n → ℕ) (m : PhaseVar n →₀ ℕ) (c : k) :
97     MvPolynomial.weightedHomogeneousComponent w N
98         (MvPolynomial.monomial m c) =
99       if monomialWeight w m = N then MvPolynomial.monomial m c else 0 := by
100   classical
101   ext q
102   rw [MvPolynomial.coeff_weightedHomogeneousComponent,
103     finsupp_weight_eq_monomialWeight]
104   by_cases hm : monomialWeight w m = N
105   · rw [if_pos hm, MvPolynomial.coeff_monomial]
106     by_cases hmq : m = q
107     · subst q
108       simp [hm]
109     · simp [hmq, Ne.symm hmq]
110   · rw [if_neg hm, MvPolynomial.coeff_zero]
111     by_cases hqm : q = m
112     · subst q
113       simp [hm]
114     · simp [hqm, Ne.symm hqm]
115 
116 theorem weightedHomogeneousComponent_rename
117     {n r T : ℕ} (wOld : PhaseVar n → ℕ) (wNew : PhaseVar r → ℕ)
118     (e : PhaseVar n → PhaseVar r)
119     (hweight : ∀ m : PhaseVar n →₀ ℕ,
120       monomialWeight wNew (m.mapDomain e) = monomialWeight wOld m)
121     (f : SymbolRing k n) :
122   MvPolynomial.weightedHomogeneousComponent wNew T
123         (MvPolynomial.rename e f) =
124       MvPolynomial.rename e
125         (MvPolynomial.weightedHomogeneousComponent wOld T f) := by
126   classical
127   induction f using MvPolynomial.induction_on' with
128   | monomial m c =>
129     rw [MvPolynomial.rename_monomial,
130       weightedHomogeneousComponent_monomial,
131       weightedHomogeneousComponent_monomial, hweight]
132     by_cases h : monomialWeight wOld m = T
133     · simp [h, MvPolynomial.rename_monomial]
134     · simp [h]
135   | add p q hp hq =>
136     simp [map_add, hp, hq]
137 
138 theorem weightedHomogeneousComponent_monomial_mul {n T : ℕ}
139     (w : PhaseVar n → ℕ) (s : PhaseVar n →₀ ℕ)
140     (f : SymbolRing k n) :
141     MvPolynomial.weightedHomogeneousComponent w
142         (T + monomialWeight w s) (MvPolynomial.monomial s 1 * f) =
143       MvPolynomial.monomial s 1 *
144         MvPolynomial.weightedHomogeneousComponent w T f := by
145   classical
146   ext q
147   rw [MvPolynomial.coeff_weightedHomogeneousComponent,
148     MvPolynomial.coeff_monomial_mul',
149     MvPolynomial.coeff_monomial_mul']
150   by_cases hsq : s ≤ q
151   · rw [if_pos hsq, if_pos hsq, one_mul, one_mul,
152       MvPolynomial.coeff_weightedHomogeneousComponent]
153     have hsplit : s + (q - s) = q := by
154       rw [add_comm]
155       exact tsub_add_cancel_of_le hsq
156     have hweight :
157         monomialWeight w q =
158           monomialWeight w s + monomialWeight w (q - s) := by
159       rw [← hsplit]
160       simp [monomialWeight, Finsupp.sum_add_index, add_mul]
161     rw [finsupp_weight_eq_monomialWeight,
162       finsupp_weight_eq_monomialWeight]
163     rw [hweight]
164     by_cases hrest : monomialWeight w (q - s) = T
165     · simp [hrest, Nat.add_comm]
166     · have hne :
167           monomialWeight w s + monomialWeight w (q - s) ≠
168             T + monomialWeight w s := by
169         omega
170       simp [hrest, hne]
171   · rw [if_neg hsq, if_neg hsq]
172     simp
173 
174 theorem monomialWeight_mapDomain_oldIndex_bernstein (n : ℕ)
175     (m : PhaseVar n →₀ ℕ) :
176     monomialWeight (@bernsteinWeight (n + 1)) (m.mapDomain oldIndex) =
177       monomialWeight (@bernsteinWeight n) m := by
178   have h := monomialWeight_extend_bernstein n 0 0 m
179   simpa [extendPhaseExponent] using h.symm
180 
181 theorem monomialWeight_mapDomain_oldIndex_order (n : ℕ)
182     (m : PhaseVar n →₀ ℕ) :
183     monomialWeight (@orderWeight (n + 1)) (m.mapDomain oldIndex) =
184       monomialWeight (@orderWeight n) m := by
185   have h := monomialWeight_extend_order n 0 0 m
186   simpa [extendPhaseExponent] using h.symm
187 
188 theorem presentedNormalFormLinearEquiv_previous_ordered_monomial
189     (n a p : ℕ) (z : PresentedWeyl k n) :
190     presentedNormalFormLinearEquiv k (n + 1)
191         (presentedCoefficientOrdered k n a p z) =
192       MvPolynomial.monomial (extendPhaseExponent n a p 0) 1 *
193         MvPolynomial.rename oldIndex
194           (presentedNormalFormLinearEquiv k n z) := by
195   rw [presentedNormalFormLinearEquiv_previous_ordered,
196     MvPolynomial.X_pow_eq_monomial,
197     MvPolynomial.X_pow_eq_monomial,
198     MvPolynomial.monomial_mul]
199   simp [extendPhaseExponent]
200 
201 theorem monomialWeight_extend_zero_bernstein (n a p : ℕ) :
202     monomialWeight (@bernsteinWeight (n + 1))
203         (extendPhaseExponent n a p 0) = a + p := by
204   rw [← monomialWeight_extend_bernstein]
205   simp [monomialWeight]
206 
207 theorem monomialWeight_extend_zero_order (n a p : ℕ) :
208     monomialWeight (@orderWeight (n + 1))
209         (extendPhaseExponent n a p 0) = p := by
210   rw [← monomialWeight_extend_order]
211   simp [monomialWeight]
212 
213 theorem presentedPrincipalComponent_coefficientOrdered_bernstein
214     (n N a p : ℕ) (z : PresentedWeyl k n) :
215     presentedPrincipalComponent k (@bernsteinWeight (n + 1)) (N + a + p)
216         (presentedCoefficientOrdered k n a p z) =
217       MvPolynomial.monomial (extendPhaseExponent n a p 0) 1 *
218         MvPolynomial.rename oldIndex
219           (presentedPrincipalComponent k (@bernsteinWeight n) N z) := by
220   rw [presentedPrincipalComponent, LinearMap.comp_apply,
221     show N + a + p = N + monomialWeight (@bernsteinWeight (n + 1))
222         (extendPhaseExponent n a p 0) by
223       rw [monomialWeight_extend_zero_bernstein]
224       omega]
225   change MvPolynomial.weightedHomogeneousComponent
226       (@bernsteinWeight (n + 1))
227       (N + monomialWeight (@bernsteinWeight (n + 1))
228         (extendPhaseExponent n a p 0))
229       (presentedNormalFormLinearEquiv k (n + 1)
230         (presentedCoefficientOrdered k n a p z)) = _
231   rw [presentedNormalFormLinearEquiv_previous_ordered_monomial]
232   rw [weightedHomogeneousComponent_monomial_mul,
233     weightedHomogeneousComponent_rename
234       k (@bernsteinWeight n) (@bernsteinWeight (n + 1)) oldIndex
235       (monomialWeight_mapDomain_oldIndex_bernstein n)]
236   rfl
237 
238 theorem presentedPrincipalComponent_coefficientOrdered_order
239     (n N a p : ℕ) (z : PresentedWeyl k n) :
240     presentedPrincipalComponent k (@orderWeight (n + 1)) (N + p)
241         (presentedCoefficientOrdered k n a p z) =
242       MvPolynomial.monomial (extendPhaseExponent n a p 0) 1 *
243         MvPolynomial.rename oldIndex
244           (presentedPrincipalComponent k (@orderWeight n) N z) := by
245   rw [presentedPrincipalComponent, LinearMap.comp_apply,
246     show N + p = N + monomialWeight (@orderWeight (n + 1))
247         (extendPhaseExponent n a p 0) by
248       rw [monomialWeight_extend_zero_order]]
249   change MvPolynomial.weightedHomogeneousComponent
250       (@orderWeight (n + 1))
251       (N + monomialWeight (@orderWeight (n + 1))
252         (extendPhaseExponent n a p 0))
253       (presentedNormalFormLinearEquiv k (n + 1)
254         (presentedCoefficientOrdered k n a p z)) = _
255   rw [presentedNormalFormLinearEquiv_previous_ordered_monomial]
256   rw [weightedHomogeneousComponent_monomial_mul,
257     weightedHomogeneousComponent_rename
258       k (@orderWeight n) (@orderWeight (n + 1)) oldIndex
259       (monomialWeight_mapDomain_oldIndex_order n)]
260   rfl
261 
262 theorem phaseMonomial_succ_product (n : ℕ)
263     (a p c q : Fin (n + 1) → ℕ) :
264     MvPolynomial.monomial (phaseExponent a p) (1 : k) *
265         MvPolynomial.monomial (phaseExponent c q) 1 =
266       MvPolynomial.monomial
267           (extendPhaseExponent n (a 0 + c 0) (p 0 + q 0) 0) 1 *
268         MvPolynomial.rename oldIndex
269           (MvPolynomial.monomial
270               (phaseExponent (fun i => a i.succ) (fun i => p i.succ)) 1 *
271             MvPolynomial.monomial
272               (phaseExponent (fun i => c i.succ) (fun i => q i.succ)) 1) := by
273   have hexp :
274       phaseExponent a p + phaseExponent c q =
275         extendPhaseExponent n (a 0 + c 0) (p 0 + q 0) 0 +
276           (phaseExponent (fun i => a i.succ) (fun i => p i.succ) +
277             phaseExponent (fun i => c i.succ) (fun i => q i.succ)).mapDomain
278               oldIndex := by
279     rw [phaseExponent_succ_eq_extend, phaseExponent_succ_eq_extend]
280     simp [extendPhaseExponent, map_add, add_assoc, add_comm, add_left_comm]
281     rw [Finsupp.mapDomain_add]
282   rw [MvPolynomial.monomial_mul, MvPolynomial.monomial_mul,
283     MvPolynomial.rename_monomial, MvPolynomial.monomial_mul]
284   simp only [one_mul]
285   rw [hexp]
286 
287 theorem presentedOrderedMonomial_mul_principal_bernstein :
288     ∀ (n : ℕ) (a p c q : Fin n → ℕ),
289       presentedPrincipalComponent k (@bernsteinWeight n)
290           (monomialWeight (@bernsteinWeight n) (phaseExponent a p) +
291             monomialWeight (@bernsteinWeight n) (phaseExponent c q))
292           (presentedOrderedMonomial k n a p *
293             presentedOrderedMonomial k n c q) =
294         MvPolynomial.monomial (phaseExponent a p) 1 *
295           MvPolynomial.monomial (phaseExponent c q) 1 := by
296   intro n
297   induction n with
298   | zero =>
299       intro a p c q
300       have hap : phaseExponent a p = 0 := by
301         ext i
302         exact Sum.elim Fin.elim0 Fin.elim0 i
303       have hcq : phaseExponent c q = 0 := by
304         ext i
305         exact Sum.elim Fin.elim0 Fin.elim0 i
306       rw [hap, hcq]
307       simp [presentedOrderedMonomial, monomialWeight,
308         presentedPrincipalComponent, presentedNormalFormLinearEquiv_one,
309         weightedHomogeneousComponent_monomial]
310   | succ n ih =>
311       intro a p c q
312       let L :=
313         monomialWeight (@bernsteinWeight n)
314             (phaseExponent (fun i => a i.succ) (fun i => p i.succ)) +
315           monomialWeight (@bernsteinWeight n)
316             (phaseExponent (fun i => c i.succ) (fun i => q i.succ))
317       have htarget :
318           monomialWeight (@bernsteinWeight (n + 1)) (phaseExponent a p) +
319               monomialWeight (@bernsteinWeight (n + 1)) (phaseExponent c q) =
320             L + (a 0 + c 0) + (p 0 + q 0) := by
321         rw [monomialWeight_phaseExponent_succ_bernstein,
322           monomialWeight_phaseExponent_succ_bernstein]
323         simp only [L]
324         omega
325       rw [htarget]
326       change
327         presentedPrincipalComponent k (@bernsteinWeight (n + 1))
328             (L + (a 0 + c 0) + (p 0 + q 0))
329             (presentedCoefficientOrdered k n (a 0) (p 0)
330                 (presentedOrderedMonomial k n
331                   (fun i => a i.succ) (fun i => p i.succ)) *
332               presentedCoefficientOrdered k n (c 0) (q 0)
333                 (presentedOrderedMonomial k n
334                   (fun i => c i.succ) (fun i => q i.succ))) = _
335       rw [presentedCoefficientOrdered_mul]
336       simp only [map_sum]
337       rw [Finset.sum_eq_single 0]
338       · simp only [Nat.zero_le, if_true, Nat.choose_zero_right,
339           Nat.descFactorial_zero, mul_one, one_nsmul, Nat.sub_zero]
340         rw [presentedPrincipalComponent_coefficientOrdered_bernstein]
341         have hih := ih
342           (fun i => a i.succ) (fun i => p i.succ)
343           (fun i => c i.succ) (fun i => q i.succ)
344         change presentedPrincipalComponent k (@bernsteinWeight n) L
345             (presentedOrderedMonomial k n
346                 (fun i => a i.succ) (fun i => p i.succ) *
347               presentedOrderedMonomial k n
348                 (fun i => c i.succ) (fun i => q i.succ)) = _ at hih
349         rw [hih]
350         exact (phaseMonomial_succ_product k n a p c q).symm
351       · intro i hi hi0
352         have hib : i ≤ p 0 := by
353           have := Finset.mem_range.mp hi
354           omega
355         by_cases hic : i ≤ c 0
356         · simp only [if_pos hic]
357           have hold :
358               presentedOrderedMonomial k n
359                     (fun j => a j.succ) (fun j => p j.succ) *
360                   presentedOrderedMonomial k n
361                     (fun j => c j.succ) (fun j => q j.succ) ∈
362                 bernsteinPiece k n L := by
363             simpa [L] using
364               presentedOrderedMonomial_mul_mem_bernsteinPiece k n
365                 (fun j => a j.succ) (fun j => p j.succ)
366                 (fun j => c j.succ) (fun j => q j.succ)
367           have hterm := presentedCoefficientOrdered_mem_bernsteinPiece k n L
368             (a 0 + c 0 - i) (p 0 + q 0 - i)
369             (presentedOrderedMonomial k n
370                 (fun j => a j.succ) (fun j => p j.succ) *
371               presentedOrderedMonomial k n
372                 (fun j => c j.succ) (fun j => q j.succ)) hold
373           have hlt :
374               L + (a 0 + c 0 - i) + (p 0 + q 0 - i) <
375                 L + (a 0 + c 0) + (p 0 + q 0) := by
376             omega
377           have hz := presentedPrincipalComponent_eq_zero_of_mem_of_lt k
378             (@bernsteinWeight (n + 1)) _ hterm hlt
379           rw [map_nsmul, hz, nsmul_zero]
380         · simp [hic]
381       · simp
382 
383 theorem presentedOrderedMonomial_mul_principal_order :
384     ∀ (n : ℕ) (a p c q : Fin n → ℕ),
385       presentedPrincipalComponent k (@orderWeight n)
386           (monomialWeight (@orderWeight n) (phaseExponent a p) +
387             monomialWeight (@orderWeight n) (phaseExponent c q))
388           (presentedOrderedMonomial k n a p *
389             presentedOrderedMonomial k n c q) =
390         MvPolynomial.monomial (phaseExponent a p) 1 *
391           MvPolynomial.monomial (phaseExponent c q) 1 := by
392   intro n
393   induction n with
394   | zero =>
395       intro a p c q
396       have hap : phaseExponent a p = 0 := by
397         ext i
398         exact Sum.elim Fin.elim0 Fin.elim0 i
399       have hcq : phaseExponent c q = 0 := by
400         ext i
401         exact Sum.elim Fin.elim0 Fin.elim0 i
402       rw [hap, hcq]
403       simp [presentedOrderedMonomial, monomialWeight,
404         presentedPrincipalComponent, presentedNormalFormLinearEquiv_one,
405         weightedHomogeneousComponent_monomial]
406   | succ n ih =>
407       intro a p c q
408       let L :=
409         monomialWeight (@orderWeight n)
410             (phaseExponent (fun i => a i.succ) (fun i => p i.succ)) +
411           monomialWeight (@orderWeight n)
412             (phaseExponent (fun i => c i.succ) (fun i => q i.succ))
413       have htarget :
414           monomialWeight (@orderWeight (n + 1)) (phaseExponent a p) +
415               monomialWeight (@orderWeight (n + 1)) (phaseExponent c q) =
416             L + (p 0 + q 0) := by
417         rw [monomialWeight_phaseExponent_succ_order,
418           monomialWeight_phaseExponent_succ_order]
419         simp only [L]
420         omega
421       rw [htarget]
422       change
423         presentedPrincipalComponent k (@orderWeight (n + 1))
424             (L + (p 0 + q 0))
425             (presentedCoefficientOrdered k n (a 0) (p 0)
426                 (presentedOrderedMonomial k n
427                   (fun i => a i.succ) (fun i => p i.succ)) *
428               presentedCoefficientOrdered k n (c 0) (q 0)
429                 (presentedOrderedMonomial k n
430                   (fun i => c i.succ) (fun i => q i.succ))) = _
431       rw [presentedCoefficientOrdered_mul]
432       simp only [map_sum]
433       rw [Finset.sum_eq_single 0]
434       · simp only [Nat.zero_le, if_true, Nat.choose_zero_right,
435           Nat.descFactorial_zero, mul_one, one_nsmul, Nat.sub_zero]
436         rw [presentedPrincipalComponent_coefficientOrdered_order]
437         have hih := ih
438           (fun i => a i.succ) (fun i => p i.succ)
439           (fun i => c i.succ) (fun i => q i.succ)
440         change presentedPrincipalComponent k (@orderWeight n) L
441             (presentedOrderedMonomial k n
442                 (fun i => a i.succ) (fun i => p i.succ) *
443               presentedOrderedMonomial k n
444                 (fun i => c i.succ) (fun i => q i.succ)) = _ at hih
445         rw [hih]
446         exact (phaseMonomial_succ_product k n a p c q).symm
447       · intro i hi hi0
448         have hib : i ≤ p 0 := by
449           have := Finset.mem_range.mp hi
450           omega
451         by_cases hic : i ≤ c 0
452         · simp only [if_pos hic]
453           have hold :
454               presentedOrderedMonomial k n
455                     (fun j => a j.succ) (fun j => p j.succ) *
456                   presentedOrderedMonomial k n
457                     (fun j => c j.succ) (fun j => q j.succ) ∈
458                 orderPiece k n L := by
459             simpa [L] using
460               presentedOrderedMonomial_mul_mem_orderPiece k n
461                 (fun j => a j.succ) (fun j => p j.succ)
462                 (fun j => c j.succ) (fun j => q j.succ)
463           have hterm := presentedCoefficientOrdered_mem_orderPiece k n L
464             (a 0 + c 0 - i) (p 0 + q 0 - i)
465             (presentedOrderedMonomial k n
466                 (fun j => a j.succ) (fun j => p j.succ) *
467               presentedOrderedMonomial k n
468                 (fun j => c j.succ) (fun j => q j.succ)) hold
469           have hlt :
470               L + (p 0 + q 0 - i) < L + (p 0 + q 0) := by
471             omega
472           have hz := presentedPrincipalComponent_eq_zero_of_mem_of_lt k
473             (@orderWeight (n + 1)) _ hterm hlt
474           rw [map_nsmul, hz, nsmul_zero]
475         · simp [hic]
476       · simp
477 
478 theorem presentedPBWBasis_mul_principal_bernstein {n : ℕ}
479     (m r : PhaseVar n →₀ ℕ) :
480     presentedPrincipalComponent k (@bernsteinWeight n)
481         (monomialWeight (@bernsteinWeight n) m +
482           monomialWeight (@bernsteinWeight n) r)
483         (presentedPBWBasis k n m * presentedPBWBasis k n r) =
484       MvPolynomial.monomial m 1 * MvPolynomial.monomial r 1 := by
485   rw [presentedPBWBasis_apply, presentedPBWBasis_apply,
486     ← phaseExponent_split m, ← phaseExponent_split r]
487   exact presentedOrderedMonomial_mul_principal_bernstein k n
488     (fun i => m (.inl i)) (fun i => m (.inr i))
489     (fun i => r (.inl i)) (fun i => r (.inr i))
490 
491 theorem presentedPBWBasis_mul_principal_order {n : ℕ}
492     (m r : PhaseVar n →₀ ℕ) :
493     presentedPrincipalComponent k (@orderWeight n)
494         (monomialWeight (@orderWeight n) m +
495           monomialWeight (@orderWeight n) r)
496         (presentedPBWBasis k n m * presentedPBWBasis k n r) =
497       MvPolynomial.monomial m 1 * MvPolynomial.monomial r 1 := by
498   rw [presentedPBWBasis_apply, presentedPBWBasis_apply,
499     ← phaseExponent_split m, ← phaseExponent_split r]
500   exact presentedOrderedMonomial_mul_principal_order k n
501     (fun i => m (.inl i)) (fun i => m (.inr i))
502     (fun i => r (.inl i)) (fun i => r (.inr i))
503 
504 theorem presentedPrincipalComponent_mul_bernstein
505     {n N M : ℕ} {x y : PresentedWeyl k n}
506     (hx : x ∈ bernsteinPiece k n N) (hy : y ∈ bernsteinPiece k n M) :
507     presentedPrincipalComponent k (@bernsteinWeight n) (N + M) (x * y) =
508       presentedPrincipalComponent k (@bernsteinWeight n) N x *
509         presentedPrincipalComponent k (@bernsteinWeight n) M y := by
510   rw [bernsteinPiece, presentedWeightPiece_eq_span] at hx hy
511   apply Submodule.span_induction₂
512       (p := fun x y _ _ =>
513         presentedPrincipalComponent k (@bernsteinWeight n) (N + M) (x * y) =
514           presentedPrincipalComponent k (@bernsteinWeight n) N x *
515             presentedPrincipalComponent k (@bernsteinWeight n) M y)
516       (ha := hx) (hb := hy)
517   · intro bx bz hbx hbz
518     obtain ⟨m, hm, rfl⟩ := hbx
519     obtain ⟨r, hr, rfl⟩ := hbz
520     by_cases hmN : monomialWeight (@bernsteinWeight n) m = N
521     · by_cases hrM : monomialWeight (@bernsteinWeight n) r = M
522       · rw [← hmN, ← hrM,
523           presentedPBWBasis_mul_principal_bernstein,
524           presentedPrincipalComponent_basis,
525           presentedPrincipalComponent_basis]
526         simp
527       · have hrlt : monomialWeight (@bernsteinWeight n) r < M :=
528           lt_of_le_of_ne hr hrM
529         have hprod :
530             presentedPBWBasis k n m * presentedPBWBasis k n r ∈
531               bernsteinPiece k n
532                 (monomialWeight (@bernsteinWeight n) m +
533                   monomialWeight (@bernsteinWeight n) r) := by
534           rw [presentedPBWBasis_apply, presentedPBWBasis_apply]
535           simpa [phaseExponent_split] using
536             presentedOrderedMonomial_mul_mem_bernsteinPiece k n
537               (fun i => m (.inl i)) (fun i => m (.inr i))
538               (fun i => r (.inl i)) (fun i => r (.inr i))
539         have hlt :
540             monomialWeight (@bernsteinWeight n) m +
541                 monomialWeight (@bernsteinWeight n) r < N + M := by
542           omega
543         rw [presentedPrincipalComponent_eq_zero_of_mem_of_lt k
544             (@bernsteinWeight n) _ hprod hlt,
545           presentedPrincipalComponent_basis,
546           presentedPrincipalComponent_basis]
547         simp [hrM]
548     · have hmlt : monomialWeight (@bernsteinWeight n) m < N :=
549         lt_of_le_of_ne hm hmN
550       have hprod :
551           presentedPBWBasis k n m * presentedPBWBasis k n r ∈
552             bernsteinPiece k n
553               (monomialWeight (@bernsteinWeight n) m +
554                 monomialWeight (@bernsteinWeight n) r) := by
555         rw [presentedPBWBasis_apply, presentedPBWBasis_apply]
556         simpa [phaseExponent_split] using
557           presentedOrderedMonomial_mul_mem_bernsteinPiece k n
558             (fun i => m (.inl i)) (fun i => m (.inr i))
559             (fun i => r (.inl i)) (fun i => r (.inr i))
560       have hlt :
561           monomialWeight (@bernsteinWeight n) m +
562               monomialWeight (@bernsteinWeight n) r < N + M := by
563         omega
564       rw [presentedPrincipalComponent_eq_zero_of_mem_of_lt k
565           (@bernsteinWeight n) _ hprod hlt,
566         presentedPrincipalComponent_basis,
567         presentedPrincipalComponent_basis]
568       simp [hmN]
569   · intro y hy
570     simp
571   · intro x hx
572     simp
573   · intro x y z hx hy hz hxy hyz
574     simp only [add_mul, map_add, hxy, hyz]
575   · intro x y z hx hy hz hxy hxz
576     simp only [mul_add, map_add, hxy, hxz]
577   · intro c x y hx hy hxy
578     simp only [Algebra.smul_mul_assoc, map_smul, hxy]
579   · intro c x y hx hy hxy
580     simp only [Algebra.mul_smul_comm, map_smul, hxy]
581 
582 theorem presentedPrincipalComponent_mul_order
583     {n N M : ℕ} {x y : PresentedWeyl k n}
584     (hx : x ∈ orderPiece k n N) (hy : y ∈ orderPiece k n M) :
585     presentedPrincipalComponent k (@orderWeight n) (N + M) (x * y) =
586       presentedPrincipalComponent k (@orderWeight n) N x *
587         presentedPrincipalComponent k (@orderWeight n) M y := by
588   rw [orderPiece, presentedWeightPiece_eq_span] at hx hy
589   apply Submodule.span_induction₂
590       (p := fun x y _ _ =>
591         presentedPrincipalComponent k (@orderWeight n) (N + M) (x * y) =
592           presentedPrincipalComponent k (@orderWeight n) N x *
593             presentedPrincipalComponent k (@orderWeight n) M y)
594       (ha := hx) (hb := hy)
595   · intro bx bz hbx hbz
596     obtain ⟨m, hm, rfl⟩ := hbx
597     obtain ⟨r, hr, rfl⟩ := hbz
598     by_cases hmN : monomialWeight (@orderWeight n) m = N
599     · by_cases hrM : monomialWeight (@orderWeight n) r = M
600       · rw [← hmN, ← hrM,
601           presentedPBWBasis_mul_principal_order,
602           presentedPrincipalComponent_basis,
603           presentedPrincipalComponent_basis]
604         simp
605       · have hrlt : monomialWeight (@orderWeight n) r < M :=
606           lt_of_le_of_ne hr hrM
607         have hprod :
608             presentedPBWBasis k n m * presentedPBWBasis k n r ∈
609               orderPiece k n
610                 (monomialWeight (@orderWeight n) m +
611                   monomialWeight (@orderWeight n) r) := by
612           rw [presentedPBWBasis_apply, presentedPBWBasis_apply]
613           simpa [phaseExponent_split] using
614             presentedOrderedMonomial_mul_mem_orderPiece k n
615               (fun i => m (.inl i)) (fun i => m (.inr i))
616               (fun i => r (.inl i)) (fun i => r (.inr i))
617         have hlt :
618             monomialWeight (@orderWeight n) m +
619                 monomialWeight (@orderWeight n) r < N + M := by
620           omega
621         rw [presentedPrincipalComponent_eq_zero_of_mem_of_lt k
622             (@orderWeight n) _ hprod hlt,
623           presentedPrincipalComponent_basis,
624           presentedPrincipalComponent_basis]
625         simp [hrM]
626     · have hmlt : monomialWeight (@orderWeight n) m < N :=
627           lt_of_le_of_ne hm hmN
628       have hprod :
629           presentedPBWBasis k n m * presentedPBWBasis k n r ∈
630             orderPiece k n
631               (monomialWeight (@orderWeight n) m +
632                 monomialWeight (@orderWeight n) r) := by
633         rw [presentedPBWBasis_apply, presentedPBWBasis_apply]
634         simpa [phaseExponent_split] using
635           presentedOrderedMonomial_mul_mem_orderPiece k n
636             (fun i => m (.inl i)) (fun i => m (.inr i))
637             (fun i => r (.inl i)) (fun i => r (.inr i))
638       have hlt :
639           monomialWeight (@orderWeight n) m +
640               monomialWeight (@orderWeight n) r < N + M := by
641         omega
642       rw [presentedPrincipalComponent_eq_zero_of_mem_of_lt k
643           (@orderWeight n) _ hprod hlt,
644         presentedPrincipalComponent_basis,
645         presentedPrincipalComponent_basis]
646       simp [hmN]
647   · intro y hy
648     simp
649   · intro x hx
650     simp
651   · intro x y z hx hy hz hxy hyz
652     simp only [add_mul, map_add, hxy, hyz]
653   · intro x y z hx hy hz hxy hxz
654     simp only [mul_add, map_add, hxy, hxz]
655   · intro c x y hx hy hxy
656     simp only [Algebra.smul_mul_assoc, map_smul, hxy]
657   · intro c x y hx hy hxy
658     simp only [Algebra.mul_smul_comm, map_smul, hxy]
659 
660 #print axioms weightedHomogeneousComponent_monomial_mul
661 #print axioms weightedHomogeneousComponent_monomial
662 #print axioms weightedHomogeneousComponent_rename
663 #print axioms finsupp_weight_eq_monomialWeight
664 #print axioms monomialWeight_mapDomain_oldIndex_bernstein
665 #print axioms monomialWeight_mapDomain_oldIndex_order
666 #print axioms presentedNormalFormLinearEquiv_previous_ordered_monomial
667 #print axioms monomialWeight_extend_zero_bernstein
668 #print axioms monomialWeight_extend_zero_order
669 #print axioms presentedPrincipalComponent
670 #print axioms coeff_presentedPrincipalComponent
671 #print axioms presentedPrincipalComponent_eq_zero_of_mem_of_lt
672 #print axioms presentedPrincipalComponent_basis
673 #print axioms presentedPrincipalComponent_coefficientOrdered_bernstein
674 #print axioms presentedPrincipalComponent_coefficientOrdered_order
675 #print axioms phaseMonomial_succ_product
676 #print axioms presentedOrderedMonomial_mul_principal_bernstein
677 #print axioms presentedOrderedMonomial_mul_principal_order
678 #print axioms presentedPBWBasis_mul_principal_bernstein
679 #print axioms presentedPBWBasis_mul_principal_order
680 #print axioms presentedPrincipalComponent_mul_bernstein
681 #print axioms presentedPrincipalComponent_mul_order
682 
683 end
684 
685 end Stafford38.WeylLeadingSymbol
686