Stafford38/Weyl/Filtration.lean

This project (Stafford38) · 1029fdb382eee06e7b59bcf32801f40931e2079a

1 module
2 public import Stafford38.MathlibCompat.MvPolynomialCoeff
3 public import Stafford38.Weyl.PBW
4 
5 @[expose] public section
6 
7 /-!
8 # Weighted PBW truncations
9 
10 The ordered PBW basis gives intrinsic finite-degree subspaces of the presented
11 Weyl algebra.  This file constructs the truncations for an arbitrary weight on
12 the named generators, proves their coefficient characterization, monotonicity,
13 exhaustiveness, and basis-monomial membership, and specializes them to the
14 Bernstein and order weights.  Exact normal ordering then proves multiplicative
15 closure.  Leading symbols and the associated graded algebra remain downstream.
16 -/
17 
18 namespace Stafford38.WeylFiltration
19 
20 open Stafford38.Characteristic
21 open Stafford38.WeylIteratedEquivalence
22 open Stafford38.WeylPBW
23 
24 noncomputable section
25 
26 universe u
27 
28 variable (k : Type u) [Field k]
29 
30 /-- Weighted degree of a commutative phase-space monomial. -/
31 def monomialWeight {n : ℕ} (w : PhaseVar n → ℕ)
32     (m : PhaseVar n →₀ ℕ) : ℕ :=
33   m.sum fun i e => e * w i
34 
35 /-- Extend an old exponent vector by exponents for the newest coordinate and
36 momentum. -/
37 def extendPhaseExponent (n a p : ℕ) (m : PhaseVar n →₀ ℕ) :
38     PhaseVar (n + 1) →₀ ℕ :=
39   Finsupp.single (.inr (0 : Fin (n + 1))) p +
40     Finsupp.single (.inl (0 : Fin (n + 1))) a +
41     Finsupp.mapDomain oldIndex m
42 
43 theorem monomialWeight_mono {n : ℕ} {w₁ w₂ : PhaseVar n → ℕ}
44     (h : ∀ i, w₁ i ≤ w₂ i) (m : PhaseVar n →₀ ℕ) :
45     monomialWeight w₁ m ≤ monomialWeight w₂ m := by
46   apply Finsupp.sum_le_sum
47   intro i _
48   exact Nat.mul_le_mul_left _ (h i)
49 
50 /-- Symbols supported on monomials of weighted degree at most `N`. -/
51 def symbolWeightPiece {n : ℕ} (w : PhaseVar n → ℕ) (N : ℕ) :
52     Submodule k (SymbolRing k n) where
53   carrier := {f | ∀ m, MvPolynomial.coeff m f ≠ 0 → monomialWeight w m ≤ N}
54   zero_mem' m hm := by simp at hm
55   add_mem' {f g} hf hg m hm := by
56     by_cases hfm : MvPolynomial.coeff m f = 0
57     · apply hg m
58       simpa [MvPolynomial.coeff_add, hfm] using hm
59     · exact hf m hfm
60   smul_mem' c f hf m hm := by
61     apply hf m
62     intro hfm
63     apply hm
64     simp [MvPolynomial.coeff_smul, hfm]
65 
66 @[simp] theorem mem_symbolWeightPiece {n : ℕ} (w : PhaseVar n → ℕ)
67     (N : ℕ) (f : SymbolRing k n) :
68     f ∈ symbolWeightPiece k w N ↔
69       ∀ m, MvPolynomial.coeff m f ≠ 0 → monomialWeight w m ≤ N :=
70   Iff.rfl
71 
72 theorem symbolWeightPiece_mono {n : ℕ} (w : PhaseVar n → ℕ)
73     {N M : ℕ} (hNM : N ≤ M) :
74     symbolWeightPiece k w N ≤ symbolWeightPiece k w M := by
75   intro f hf m hm
76   exact (hf m hm).trans hNM
77 
78 theorem symbolWeightPiece_antitone_weight {n : ℕ}
79     {w₁ w₂ : PhaseVar n → ℕ} (h : ∀ i, w₁ i ≤ w₂ i) (N : ℕ) :
80     symbolWeightPiece k w₂ N ≤ symbolWeightPiece k w₁ N := by
81   intro f hf m hm
82   exact (monomialWeight_mono h m).trans (hf m hm)
83 
84 @[simp] theorem monomial_mem_symbolWeightPiece_iff {n : ℕ}
85     (w : PhaseVar n → ℕ) (N : ℕ) (m : PhaseVar n →₀ ℕ) :
86     MvPolynomial.monomial m (1 : k) ∈ symbolWeightPiece k w N ↔
87       monomialWeight w m ≤ N := by
88   constructor
89   · intro h
90     apply h m
91     simp [MvPolynomial.coeff_monomial]
92   · intro hm q hq
93     simp only [MvPolynomial.coeff_monomial] at hq
94     split at hq
95     · next h => simpa [h] using hm
96     · contradiction
97 
98 /-- The sum of the weights of all supported monomials is a simple exhaustive
99 bound.  It is not intended to be the minimal weighted degree. -/
100 def symbolSupportWeightBound {n : ℕ} (w : PhaseVar n → ℕ)
101     (f : SymbolRing k n) : ℕ :=
102   f.support.sum (monomialWeight w)
103 
104 theorem mem_symbolWeightPiece_supportBound {n : ℕ}
105     (w : PhaseVar n → ℕ) (f : SymbolRing k n) :
106     f ∈ symbolWeightPiece k w (symbolSupportWeightBound k w f) := by
107   intro m hm
108   apply Finset.single_le_sum (fun _ _ => Nat.zero_le _)
109   exact MvPolynomial.mem_support_iff.mpr hm
110 
111 /-- Pull a weighted symbol truncation back through checked Weyl normal-form
112 coordinates. -/
113 def presentedWeightPiece {n : ℕ} (w : PhaseVar n → ℕ) (N : ℕ) :
114     Submodule k (PresentedWeyl k n) :=
115   (symbolWeightPiece k w N).comap
116     (presentedNormalFormLinearEquiv k n).toLinearMap
117 
118 @[simp] theorem mem_presentedWeightPiece {n : ℕ} (w : PhaseVar n → ℕ)
119     (N : ℕ) (a : PresentedWeyl k n) :
120     a ∈ presentedWeightPiece k w N ↔
121       ∀ m, MvPolynomial.coeff m (presentedNormalFormLinearEquiv k n a) ≠ 0 →
122         monomialWeight w m ≤ N :=
123   Iff.rfl
124 
125 theorem presentedWeightPiece_mono {n : ℕ} (w : PhaseVar n → ℕ)
126     {N M : ℕ} (hNM : N ≤ M) :
127     presentedWeightPiece k w N ≤ presentedWeightPiece k w M :=
128   Submodule.comap_mono (symbolWeightPiece_mono k w hNM)
129 
130 theorem presentedWeightPiece_antitone_weight {n : ℕ}
131     {w₁ w₂ : PhaseVar n → ℕ} (h : ∀ i, w₁ i ≤ w₂ i) (N : ℕ) :
132     presentedWeightPiece k w₂ N ≤ presentedWeightPiece k w₁ N :=
133   Submodule.comap_mono (symbolWeightPiece_antitone_weight k h N)
134 
135 theorem presentedNormalFormLinearEquiv_basis {n : ℕ}
136     (m : PhaseVar n →₀ ℕ) :
137     presentedNormalFormLinearEquiv k n (presentedPBWBasis k n m) =
138       MvPolynomial.monomial m 1 := by
139   rw [presentedPBWBasis, presentedNormalFormBasis_apply,
140     LinearEquiv.apply_symm_apply]
141 
142 theorem presentedPBWBasis_mem_weightPiece_iff {n : ℕ}
143     (w : PhaseVar n → ℕ) (N : ℕ) (m : PhaseVar n →₀ ℕ) :
144     presentedPBWBasis k n m ∈ presentedWeightPiece k w N ↔
145       monomialWeight w m ≤ N := by
146   rw [mem_presentedWeightPiece,
147     presentedNormalFormLinearEquiv_basis]
148   exact monomial_mem_symbolWeightPiece_iff k w N m
149 
150 /-- The ordered PBW basis vectors whose weights are bounded by `N`. -/
151 def presentedWeightBasisSet {n : ℕ} (w : PhaseVar n → ℕ) (N : ℕ) :
152     Set (PresentedWeyl k n) :=
153   {a | ∃ m : PhaseVar n →₀ ℕ,
154     monomialWeight w m ≤ N ∧ a = presentedPBWBasis k n m}
155 
156 /-- The coefficient-support definition of a weighted truncation agrees with
157 the span of exactly the bounded ordered PBW basis vectors. -/
158 theorem presentedWeightPiece_eq_span {n : ℕ} (w : PhaseVar n → ℕ) (N : ℕ) :
159     presentedWeightPiece k w N =
160       Submodule.span k (presentedWeightBasisSet k w N) := by
161   apply le_antisymm
162   · intro a ha
163     let f := presentedNormalFormLinearEquiv k n a
164     have hreconstruct :
165         a = ∑ m ∈ f.support,
166           MvPolynomial.coeff m f • presentedPBWBasis k n m := by
167       apply (presentedNormalFormLinearEquiv k n).injective
168       simp only [map_sum, map_smul,
169         presentedNormalFormLinearEquiv_basis]
170       change f = _
171       calc
172         f = ∑ m ∈ f.support,
173             MvPolynomial.monomial m (MvPolynomial.coeff m f) :=
174           MvPolynomial.as_sum f
175         _ = _ := by
176           apply Finset.sum_congr rfl
177           intro m hm
178           rw [MvPolynomial.smul_monomial]
179           simp
180     rw [hreconstruct]
181     apply Submodule.sum_mem
182     intro m hm
183     apply Submodule.smul_mem
184     apply Submodule.subset_span
185     exact ⟨m, ha m (MvPolynomial.mem_support_iff.mp hm), rfl⟩
186   · apply Submodule.span_le.mpr
187     intro a ha
188     obtain ⟨m, hm, rfl⟩ := ha
189     exact (presentedPBWBasis_mem_weightPiece_iff k w N m).mpr hm
190 
191 /-- Normal form of a bounded old basis vector followed by the newest pair. -/
192 theorem presentedCoefficientOrdered_basis_normal (n a p : ℕ)
193     (m : PhaseVar n →₀ ℕ) :
194     presentedNormalFormLinearEquiv k (n + 1)
195         (presentedCoefficientOrdered k n a p (presentedPBWBasis k n m)) =
196       MvPolynomial.monomial (extendPhaseExponent n a p m) 1 := by
197   rw [presentedNormalFormLinearEquiv_previous_ordered,
198     presentedNormalFormLinearEquiv_basis,
199     MvPolynomial.rename_monomial,
200     MvPolynomial.X_pow_eq_monomial,
201     MvPolynomial.X_pow_eq_monomial,
202     MvPolynomial.monomial_mul, MvPolynomial.monomial_mul]
203   simp [extendPhaseExponent]
204 
205 /-- Appending a fixed newest-pair monomial is scalar-linear in the old
206 coefficient. -/
207 def presentedCoefficientOrderedLinear (n a p : ℕ) :
208     PresentedWeyl k n →ₗ[k] PresentedWeyl k (n + 1) where
209   toFun z := presentedCoefficientOrdered k n a p z
210   map_add' z w := by
211     simp [presentedCoefficientOrdered, map_add, add_mul]
212   map_smul' c z := by
213     simp [presentedCoefficientOrdered, map_smul, Algebra.smul_mul_assoc]
214 
215 theorem exists_mem_presentedWeightPiece {n : ℕ} (w : PhaseVar n → ℕ)
216     (a : PresentedWeyl k n) :
217     ∃ N, a ∈ presentedWeightPiece k w N := by
218   let f := presentedNormalFormLinearEquiv k n a
219   exact ⟨symbolSupportWeightBound k w f,
220     mem_symbolWeightPiece_supportBound k w f⟩
221 
222 /-- Every named generator has Bernstein weight one. -/
223 def bernsteinWeight {n : ℕ} (_ : PhaseVar n) : ℕ := 1
224 
225 /-- Coordinates have order weight zero and momenta have order weight one. -/
226 def orderWeight {n : ℕ} : PhaseVar n → ℕ := fibreWeight
227 
228 theorem monomialWeight_extend_bernstein (n a p : ℕ)
229     (m : PhaseVar n →₀ ℕ) :
230     monomialWeight (@bernsteinWeight n) m + a + p =
231       monomialWeight (@bernsteinWeight (n + 1))
232         (extendPhaseExponent n a p m) := by
233   simp only [extendPhaseExponent, monomialWeight]
234   rw [Finsupp.sum_add_index, Finsupp.sum_add_index,
235     Finsupp.sum_single_index, Finsupp.sum_single_index,
236     Finsupp.sum_mapDomain_index]
237   · simp [bernsteinWeight, add_comm, add_left_comm, add_assoc]
238   all_goals simp [bernsteinWeight, add_mul]
239 
240 theorem monomialWeight_extend_order (n a p : ℕ)
241     (m : PhaseVar n →₀ ℕ) :
242     monomialWeight (@orderWeight n) m + p =
243       monomialWeight (@orderWeight (n + 1))
244         (extendPhaseExponent n a p m) := by
245   simp only [extendPhaseExponent, monomialWeight]
246   rw [Finsupp.sum_add_index, Finsupp.sum_add_index,
247     Finsupp.sum_single_index, Finsupp.sum_single_index,
248     Finsupp.sum_mapDomain_index]
249   · simp only [orderWeight, fibreWeight, Nat.mul_one, Nat.mul_zero, add_zero]
250     rw [add_comm]
251     congr 1
252     apply Finsupp.sum_congr
253     intro i hi
254     cases i <;> simp [orderWeight, fibreWeight, oldIndex,
255       Stafford38FixedSourceChallenge.oldIndex]
256   all_goals simp [orderWeight, fibreWeight, oldIndex,
257     Stafford38FixedSourceChallenge.oldIndex, add_mul]
258 
259 theorem phaseExponent_succ_eq_extend (n : ℕ)
260     (a p : Fin (n + 1) → ℕ) :
261     phaseExponent a p =
262       extendPhaseExponent n (a 0) (p 0)
263         (phaseExponent (fun i => a i.succ) (fun i => p i.succ)) :=
264   phaseExponent_succ n a p
265 
266 theorem monomialWeight_phaseExponent_succ_bernstein
267     (n : ℕ) (a p : Fin (n + 1) → ℕ) :
268     monomialWeight (@bernsteinWeight (n + 1)) (phaseExponent a p) =
269       monomialWeight (@bernsteinWeight n)
270           (phaseExponent (fun i => a i.succ) (fun i => p i.succ)) +
271         a 0 + p 0 := by
272   rw [phaseExponent_succ_eq_extend,
273     ← monomialWeight_extend_bernstein]
274 
275 theorem monomialWeight_phaseExponent_succ_order
276     (n : ℕ) (a p : Fin (n + 1) → ℕ) :
277     monomialWeight (@orderWeight (n + 1)) (phaseExponent a p) =
278       monomialWeight (@orderWeight n)
279           (phaseExponent (fun i => a i.succ) (fun i => p i.succ)) + p 0 := by
280   rw [phaseExponent_succ_eq_extend,
281     ← monomialWeight_extend_order]
282 
283 /-- Bernstein truncation of the presented Weyl algebra. -/
284 def bernsteinPiece (n N : ℕ) : Submodule k (PresentedWeyl k n) :=
285   presentedWeightPiece k bernsteinWeight N
286 
287 /-- Differential-order truncation of the presented Weyl algebra. -/
288 abbrev orderPiece (n N : ℕ) : Submodule k (PresentedWeyl k n) :=
289   presentedWeightPiece k (@orderWeight n) N
290 
291 /-- Appending a normal-ordered newest pair increases Bernstein degree by at
292 most the sum of the two new exponents. -/
293 theorem presentedCoefficientOrdered_mem_bernsteinPiece
294     (n N a p : ℕ) (z : PresentedWeyl k n)
295     (hz : z ∈ bernsteinPiece k n N) :
296     presentedCoefficientOrdered k n a p z ∈
297       bernsteinPiece k (n + 1) (N + a + p) := by
298   rw [bernsteinPiece, presentedWeightPiece_eq_span] at hz
299   induction hz using Submodule.span_induction with
300   | mem z hz =>
301       obtain ⟨m, hm, rfl⟩ := hz
302       rw [bernsteinPiece, mem_presentedWeightPiece,
303         presentedCoefficientOrdered_basis_normal]
304       intro q hq
305       simp only [MvPolynomial.coeff_monomial] at hq
306       split at hq
307       · next h =>
308           subst q
309           rw [← monomialWeight_extend_bernstein]
310           omega
311       · contradiction
312   | zero =>
313       change presentedCoefficientOrderedLinear k n a p 0 ∈ _
314       rw [map_zero]
315       exact Submodule.zero_mem _
316   | add x y hx hy ihx ihy =>
317       change presentedCoefficientOrderedLinear k n a p (x + y) ∈ _
318       rw [map_add]
319       exact Submodule.add_mem _ ihx ihy
320   | smul c x hx ih =>
321       change presentedCoefficientOrderedLinear k n a p (c • x) ∈ _
322       rw [map_smul]
323       exact Submodule.smul_mem _ c ih
324 
325 /-- Appending a normal-ordered newest pair increases differential order by at
326 most the new momentum exponent; coordinate powers have order zero. -/
327 theorem presentedCoefficientOrdered_mem_orderPiece
328     (n N a p : ℕ) (z : PresentedWeyl k n)
329     (hz : z ∈ orderPiece k n N) :
330     presentedCoefficientOrdered k n a p z ∈
331       orderPiece k (n + 1) (N + p) := by
332   rw [orderPiece, presentedWeightPiece_eq_span] at hz
333   induction hz using Submodule.span_induction with
334   | mem z hz =>
335       obtain ⟨m, hm, rfl⟩ := hz
336       rw [orderPiece, mem_presentedWeightPiece,
337         presentedCoefficientOrdered_basis_normal]
338       intro q hq
339       simp only [MvPolynomial.coeff_monomial] at hq
340       split at hq
341       · next h =>
342           subst q
343           rw [← monomialWeight_extend_order]
344           omega
345       · contradiction
346   | zero =>
347       change presentedCoefficientOrderedLinear k n a p 0 ∈ _
348       rw [map_zero]
349       exact Submodule.zero_mem _
350   | add x y hx hy ihx ihy =>
351       change presentedCoefficientOrderedLinear k n a p (x + y) ∈ _
352       rw [map_add]
353       exact Submodule.add_mem _ ihx ihy
354   | smul c x hx ih =>
355       change presentedCoefficientOrderedLinear k n a p (c • x) ∈ _
356       rw [map_smul]
357       exact Submodule.smul_mem _ c ih
358 
359 /-- Products of ordered PBW monomials satisfy the Bernstein degree bound. -/
360 theorem presentedOrderedMonomial_mul_mem_bernsteinPiece :
361     ∀ (n : ℕ) (a p c q : Fin n → ℕ),
362       presentedOrderedMonomial k n a p * presentedOrderedMonomial k n c q ∈
363         bernsteinPiece k n
364           (monomialWeight (@bernsteinWeight n) (phaseExponent a p) +
365             monomialWeight (@bernsteinWeight n) (phaseExponent c q)) := by
366   intro n
367   induction n with
368   | zero =>
369       intro a p c q
370       have hap : phaseExponent a p = 0 := by
371         ext i
372         exact Sum.elim Fin.elim0 Fin.elim0 i
373       have hcq : phaseExponent c q = 0 := by
374         ext i
375         exact Sum.elim Fin.elim0 Fin.elim0 i
376       rw [hap, hcq]
377       simp only [monomialWeight, Finsupp.sum_zero_index, zero_add]
378       simp only [presentedOrderedMonomial, one_mul]
379       change (1 : PresentedWeyl k 0) ∈ bernsteinPiece k 0 0
380       rw [bernsteinPiece, mem_presentedWeightPiece]
381       intro m hm
382       have hone :
383           presentedNormalFormLinearEquiv k 0 (1 : PresentedWeyl k 0) = 1 :=
384         presentedNormalFormLinearEquiv_one k 0
385       rw [hone] at hm
386       have hm0 : m = 0 := by
387         symm
388         simpa [MvPolynomial.coeff_one] using hm
389       subst m
390       simp [monomialWeight]
391   | succ n ih =>
392       intro a p c q
393       change
394         presentedCoefficientOrdered k n (a 0) (p 0)
395               (presentedOrderedMonomial k n
396                 (fun i => a i.succ) (fun i => p i.succ)) *
397             presentedCoefficientOrdered k n (c 0) (q 0)
398               (presentedOrderedMonomial k n
399                 (fun i => c i.succ) (fun i => q i.succ)) ∈ _
400       rw [presentedCoefficientOrdered_mul]
401       apply Submodule.sum_mem
402       intro i hi
403       have hib : i ≤ p 0 := by
404         have := Finset.mem_range.mp hi
405         omega
406       by_cases hic : i ≤ c 0
407       · simp only [if_pos hic]
408         apply Submodule.smul_mem
409         have hterm := presentedCoefficientOrdered_mem_bernsteinPiece k
410           n
411           (monomialWeight (@bernsteinWeight n)
412               (phaseExponent (fun i => a i.succ) (fun i => p i.succ)) +
413             monomialWeight (@bernsteinWeight n)
414               (phaseExponent (fun i => c i.succ) (fun i => q i.succ)))
415           (a 0 + c 0 - i) (p 0 + q 0 - i)
416           (presentedOrderedMonomial k n
417               (fun i => a i.succ) (fun i => p i.succ) *
418             presentedOrderedMonomial k n
419               (fun i => c i.succ) (fun i => q i.succ))
420           (ih (fun i => a i.succ) (fun i => p i.succ)
421             (fun i => c i.succ) (fun i => q i.succ))
422         apply presentedWeightPiece_mono k bernsteinWeight _ hterm
423         rw [monomialWeight_phaseExponent_succ_bernstein,
424           monomialWeight_phaseExponent_succ_bernstein]
425         omega
426       · simp [hic]
427 
428 /-- Products of ordered PBW monomials satisfy the differential-order bound. -/
429 theorem presentedOrderedMonomial_mul_mem_orderPiece :
430     ∀ (n : ℕ) (a p c q : Fin n → ℕ),
431       presentedOrderedMonomial k n a p * presentedOrderedMonomial k n c q ∈
432         orderPiece k n
433           (monomialWeight (@orderWeight n) (phaseExponent a p) +
434             monomialWeight (@orderWeight n) (phaseExponent c q)) := by
435   intro n
436   induction n with
437   | zero =>
438       intro a p c q
439       have hap : phaseExponent a p = 0 := by
440         ext i
441         exact Sum.elim Fin.elim0 Fin.elim0 i
442       have hcq : phaseExponent c q = 0 := by
443         ext i
444         exact Sum.elim Fin.elim0 Fin.elim0 i
445       rw [hap, hcq]
446       simp only [monomialWeight, Finsupp.sum_zero_index, zero_add]
447       simp only [presentedOrderedMonomial, one_mul]
448       change (1 : PresentedWeyl k 0) ∈ orderPiece k 0 0
449       rw [orderPiece, mem_presentedWeightPiece]
450       intro m hm
451       have hone :
452           presentedNormalFormLinearEquiv k 0 (1 : PresentedWeyl k 0) = 1 :=
453         presentedNormalFormLinearEquiv_one k 0
454       rw [hone] at hm
455       have hm0 : m = 0 := by
456         symm
457         simpa [MvPolynomial.coeff_one] using hm
458       subst m
459       simp [monomialWeight]
460   | succ n ih =>
461       intro a p c q
462       change
463         presentedCoefficientOrdered k n (a 0) (p 0)
464               (presentedOrderedMonomial k n
465                 (fun i => a i.succ) (fun i => p i.succ)) *
466             presentedCoefficientOrdered k n (c 0) (q 0)
467               (presentedOrderedMonomial k n
468                 (fun i => c i.succ) (fun i => q i.succ)) ∈ _
469       rw [presentedCoefficientOrdered_mul]
470       apply Submodule.sum_mem
471       intro i hi
472       have hib : i ≤ p 0 := by
473         have := Finset.mem_range.mp hi
474         omega
475       by_cases hic : i ≤ c 0
476       · simp only [if_pos hic]
477         apply Submodule.smul_mem
478         have hterm := presentedCoefficientOrdered_mem_orderPiece k
479           n
480           (monomialWeight (@orderWeight n)
481               (phaseExponent (fun i => a i.succ) (fun i => p i.succ)) +
482             monomialWeight (@orderWeight n)
483               (phaseExponent (fun i => c i.succ) (fun i => q i.succ)))
484           (a 0 + c 0 - i) (p 0 + q 0 - i)
485           (presentedOrderedMonomial k n
486               (fun i => a i.succ) (fun i => p i.succ) *
487             presentedOrderedMonomial k n
488               (fun i => c i.succ) (fun i => q i.succ))
489           (ih (fun i => a i.succ) (fun i => p i.succ)
490             (fun i => c i.succ) (fun i => q i.succ))
491         apply presentedWeightPiece_mono k orderWeight _ hterm
492         rw [monomialWeight_phaseExponent_succ_order,
493           monomialWeight_phaseExponent_succ_order]
494         omega
495       · simp [hic]
496 
497 /-- The Bernstein PBW truncations are multiplicatively filtered. -/
498 theorem mul_mem_bernsteinPiece {n N M : ℕ} {x y : PresentedWeyl k n}
499     (hx : x ∈ bernsteinPiece k n N) (hy : y ∈ bernsteinPiece k n M) :
500     x * y ∈ bernsteinPiece k n (N + M) := by
501   rw [bernsteinPiece, presentedWeightPiece_eq_span] at hx hy
502   apply Submodule.span_induction₂
503       (p := fun x y _ _ => x * y ∈ bernsteinPiece k n (N + M))
504       (ha := hx) (hb := hy)
505   · intro x y hx hy
506     obtain ⟨m, hm, rfl⟩ := hx
507     obtain ⟨r, hr, rfl⟩ := hy
508     rw [presentedPBWBasis_apply, presentedPBWBasis_apply]
509     have hprod := presentedOrderedMonomial_mul_mem_bernsteinPiece k n
510       (fun i => m (.inl i)) (fun i => m (.inr i))
511       (fun i => r (.inl i)) (fun i => r (.inr i))
512     rw [phaseExponent_split, phaseExponent_split] at hprod
513     exact presentedWeightPiece_mono k bernsteinWeight
514       (Nat.add_le_add hm hr) hprod
515   · intro y hy
516     rw [zero_mul]
517     exact Submodule.zero_mem _
518   · intro x hx
519     rw [mul_zero]
520     exact Submodule.zero_mem _
521   · intro x y z hx hy hz hxy hyz
522     rw [add_mul]
523     exact Submodule.add_mem _ hxy hyz
524   · intro x y z hx hy hz hxy hxz
525     rw [mul_add]
526     exact Submodule.add_mem _ hxy hxz
527   · intro c x y hx hy hxy
528     rw [Algebra.smul_mul_assoc]
529     exact Submodule.smul_mem _ c hxy
530   · intro c x y hx hy hxy
531     rw [Algebra.mul_smul_comm]
532     exact Submodule.smul_mem _ c hxy
533 
534 /-- The differential-order PBW truncations are multiplicatively filtered. -/
535 theorem mul_mem_orderPiece {n N M : ℕ} {x y : PresentedWeyl k n}
536     (hx : x ∈ orderPiece k n N) (hy : y ∈ orderPiece k n M) :
537     x * y ∈ orderPiece k n (N + M) := by
538   rw [orderPiece, presentedWeightPiece_eq_span] at hx hy
539   apply Submodule.span_induction₂
540       (p := fun x y _ _ => x * y ∈ orderPiece k n (N + M))
541       (ha := hx) (hb := hy)
542   · intro x y hx hy
543     obtain ⟨m, hm, rfl⟩ := hx
544     obtain ⟨r, hr, rfl⟩ := hy
545     rw [presentedPBWBasis_apply, presentedPBWBasis_apply]
546     have hprod := presentedOrderedMonomial_mul_mem_orderPiece k n
547       (fun i => m (.inl i)) (fun i => m (.inr i))
548       (fun i => r (.inl i)) (fun i => r (.inr i))
549     rw [phaseExponent_split, phaseExponent_split] at hprod
550     exact presentedWeightPiece_mono k orderWeight
551       (Nat.add_le_add hm hr) hprod
552   · intro y hy
553     rw [zero_mul]
554     exact Submodule.zero_mem _
555   · intro x hx
556     rw [mul_zero]
557     exact Submodule.zero_mem _
558   · intro x y z hx hy hz hxy hyz
559     rw [add_mul]
560     exact Submodule.add_mem _ hxy hyz
561   · intro x y z hx hy hz hxy hxz
562     rw [mul_add]
563     exact Submodule.add_mem _ hxy hxz
564   · intro c x y hx hy hxy
565     rw [Algebra.smul_mul_assoc]
566     exact Submodule.smul_mem _ c hxy
567   · intro c x y hx hy hxy
568     rw [Algebra.mul_smul_comm]
569     exact Submodule.smul_mem _ c hxy
570 
571 -- Compile-time API contracts: the filtration bounds are exactly additive.
572 example {n N M : ℕ} {x y : PresentedWeyl k n}
573     (hx : x ∈ bernsteinPiece k n N) (hy : y ∈ bernsteinPiece k n M) :
574     x * y ∈ bernsteinPiece k n (N + M) :=
575   mul_mem_bernsteinPiece k hx hy
576 
577 example {n N M : ℕ} {x y : PresentedWeyl k n}
578     (hx : x ∈ orderPiece k n N) (hy : y ∈ orderPiece k n M) :
579     x * y ∈ orderPiece k n (N + M) :=
580   mul_mem_orderPiece k hx hy
581 
582 theorem bernsteinPiece_le_orderPiece (n N : ℕ) :
583     bernsteinPiece k n N ≤ orderPiece k n N := by
584   apply presentedWeightPiece_antitone_weight k
585   intro i
586   cases i <;> simp [orderWeight, fibreWeight, bernsteinWeight]
587 
588 theorem exists_mem_bernsteinPiece {n : ℕ} (a : PresentedWeyl k n) :
589     ∃ N, a ∈ bernsteinPiece k n N :=
590   exists_mem_presentedWeightPiece k bernsteinWeight a
591 
592 theorem exists_mem_orderPiece {n : ℕ} (a : PresentedWeyl k n) :
593     ∃ N, a ∈ orderPiece k n N :=
594   exists_mem_presentedWeightPiece k orderWeight a
595 
596 #print axioms symbolWeightPiece
597 #print axioms mem_symbolWeightPiece_supportBound
598 #print axioms presentedWeightPiece
599 #print axioms presentedPBWBasis_mem_weightPiece_iff
600 #print axioms presentedWeightPiece_eq_span
601 #print axioms presentedCoefficientOrdered_basis_normal
602 #print axioms monomialWeight_extend_bernstein
603 #print axioms monomialWeight_extend_order
604 #print axioms monomialWeight_phaseExponent_succ_bernstein
605 #print axioms monomialWeight_phaseExponent_succ_order
606 #print axioms presentedCoefficientOrdered_mem_bernsteinPiece
607 #print axioms presentedCoefficientOrdered_mem_orderPiece
608 #print axioms presentedOrderedMonomial_mul_mem_bernsteinPiece
609 #print axioms presentedOrderedMonomial_mul_mem_orderPiece
610 #print axioms mul_mem_bernsteinPiece
611 #print axioms mul_mem_orderPiece
612 #print axioms exists_mem_presentedWeightPiece
613 #print axioms bernsteinPiece
614 #print axioms orderPiece
615 #print axioms bernsteinPiece_le_orderPiece
616 
617 end
618 
619 end Stafford38.WeylFiltration
620