Stafford38/Weyl/PBWFirstContraction.lean

This project (Stafford38) · 1029fdb382eee06e7b59bcf32801f40931e2079a

1 module
2 public import Stafford38.MathlibCompat.MvPolynomialCoeff
3 public import Stafford38.Weyl.FilteredCommutator
4 
5 @[expose] public section
6 
7 /-!
8 # The first PBW contraction
9 
10 This file extracts the degree-one contraction term from the recursive ordered
11 PBW multiplication formula.  It is kept separate from the downstream
12 commutator argument so that the one-sided normal-ordering calculation is an
13 independent input.
14 -/
15 
16 namespace Stafford38.WeylPBWFirstContraction
17 
18 open Stafford38.Characteristic
19 open Stafford38.WeylFilteredCommutator
20 open Stafford38.WeylFiltration
21 open Stafford38.WeylIteratedEquivalence
22 open Stafford38.WeylLeadingSymbol
23 open Stafford38.WeylPBW
24 
25 noncomputable section
26 
27 universe u
28 
29 variable (k : Type u) [Field k]
30 
31 private theorem weightedHomogeneousComponent_monomial_mul_eq_zero_of_lt
32     {n T : ℕ} (w : PhaseVar n → ℕ) (s : PhaseVar n →₀ ℕ)
33     (f : SymbolRing k n) (hT : T < monomialWeight w s) :
34     MvPolynomial.weightedHomogeneousComponent w T
35         (MvPolynomial.monomial s 1 * f) = 0 := by
36   classical
37   ext q
38   change AddMonoidAlgebra.coeff
39     (MvPolynomial.weightedHomogeneousComponent w T
40       (MvPolynomial.monomial s 1 * f)) q = 0
41   rw [MvPolynomial.coeff_weightedHomogeneousComponent,
42     MvPolynomial.coeff_monomial_mul']
43   by_cases hsq : s ≤ q
44   · rw [if_pos hsq, one_mul]
45     have hsplit : s + (q - s) = q := by
46       rw [add_comm]
47       exact tsub_add_cancel_of_le hsq
48     have hweight :
49         monomialWeight w q =
50           monomialWeight w s + monomialWeight w (q - s) := by
51       rw [← hsplit]
52       simp [monomialWeight, Finsupp.sum_add_index, add_mul]
53     have hne : monomialWeight w q ≠ T := by omega
54     rw [finsupp_weight_eq_monomialWeight, if_neg hne]
55   · rw [if_neg hsq]
56     simp
57 
58 private theorem phaseExponent_old_contraction_exponents
59     (n : ℕ) (a p c q : Fin (n + 1) → ℕ) (i : Fin n) :
60     (phaseExponent a p -
61           Finsupp.single (.inr i.succ : PhaseVar (n + 1)) 1) +
62         (phaseExponent c q -
63           Finsupp.single (.inl i.succ : PhaseVar (n + 1)) 1) =
64       extendPhaseExponent n (a 0 + c 0) (p 0 + q 0) 0 +
65         (((phaseExponent (fun j => a j.succ) (fun j => p j.succ) -
66               Finsupp.single (.inr i : PhaseVar n) 1) +
67             (phaseExponent (fun j => c j.succ) (fun j => q j.succ) -
68               Finsupp.single (.inl i : PhaseVar n) 1)).mapDomain oldIndex) := by
69   classical
70   have hmapCoordinate (s : PhaseVar n →₀ ℕ) (j : Fin n) :
71       Finsupp.mapDomain oldIndex s (.inl j.succ) = s (.inl j) := by
72     change Finsupp.mapDomain oldIndex s (oldIndex (.inl j)) = _
73     rw [Finsupp.mapDomain_apply_of_injective oldIndex_injective]
74   have hmapMomentum (s : PhaseVar n →₀ ℕ) (j : Fin n) :
75       Finsupp.mapDomain oldIndex s (.inr j.succ) = s (.inr j) := by
76     change Finsupp.mapDomain oldIndex s (oldIndex (.inr j)) = _
77     rw [Finsupp.mapDomain_apply_of_injective oldIndex_injective]
78   have hmapCoordinateZero (s : PhaseVar n →₀ ℕ) :
79       Finsupp.mapDomain oldIndex s (.inl (0 : Fin (n + 1))) = 0 := by
80     apply Finsupp.mapDomain_notin_range
81     rintro ⟨v, hv⟩
82     cases v <;> simp [oldIndex, Fin.succ_ne_zero] at hv
83   have hmapMomentumZero (s : PhaseVar n →₀ ℕ) :
84       Finsupp.mapDomain oldIndex s (.inr (0 : Fin (n + 1))) = 0 := by
85     apply Finsupp.mapDomain_notin_range
86     rintro ⟨v, hv⟩
87     cases v <;> simp [oldIndex, Fin.succ_ne_zero] at hv
88   ext v
89   rcases v with v | v
90   · refine Fin.cases ?_ (fun j => ?_) v
91     · simp [phaseExponent, extendPhaseExponent, oldIndex,
92         Finsupp.single_apply, Fin.succ_ne_zero, hmapCoordinateZero]
93     · have hzero : (0 : Fin (n + 1)) ≠ j.succ :=
94         Ne.symm (Fin.succ_ne_zero j)
95       simp [phaseExponent, extendPhaseExponent, oldIndex,
96         Finsupp.single_apply, Fin.succ_ne_zero, hzero, hmapCoordinate]
97   · refine Fin.cases ?_ (fun j => ?_) v
98     · simp [phaseExponent, extendPhaseExponent, oldIndex,
99         Finsupp.single_apply, Fin.succ_ne_zero, hmapMomentumZero]
100     · have hzero : (0 : Fin (n + 1)) ≠ j.succ :=
101         Ne.symm (Fin.succ_ne_zero j)
102       simp [phaseExponent, extendPhaseExponent, oldIndex,
103         Finsupp.single_apply, Fin.succ_ne_zero, hzero, hmapMomentum]
104 
105 private theorem firstContraction_old_term
106     (n : ℕ) (a p c q : Fin (n + 1) → ℕ) (i : Fin n) :
107     MvPolynomial.pderiv (.inr i.succ)
108           (MvPolynomial.monomial (phaseExponent a p) (1 : k)) *
109         MvPolynomial.pderiv (.inl i.succ)
110           (MvPolynomial.monomial (phaseExponent c q) 1) =
111       MvPolynomial.monomial
112           (extendPhaseExponent n (a 0 + c 0) (p 0 + q 0) 0) 1 *
113         MvPolynomial.rename oldIndex
114           (MvPolynomial.pderiv (.inr i)
115               (MvPolynomial.monomial
116                 (phaseExponent (fun j => a j.succ) (fun j => p j.succ)) 1) *
117             MvPolynomial.pderiv (.inl i)
118               (MvPolynomial.monomial
119                 (phaseExponent (fun j => c j.succ) (fun j => q j.succ)) 1)) := by
120   classical
121   simp only [MvPolynomial.pderiv_monomial,
122     MvPolynomial.monomial_mul, MvPolynomial.rename_monomial, map_mul]
123   rw [phaseExponent_old_contraction_exponents n a p c q i]
124   simp [phaseExponent]
125 
126 private theorem phaseExponent_newest_contraction_exponents
127     (n : ℕ) (a p c q : Fin (n + 1) → ℕ)
128     (hp : 0 < p 0) (hc : 0 < c 0) :
129     (phaseExponent a p -
130           Finsupp.single (.inr (0 : Fin (n + 1))) 1) +
131         (phaseExponent c q -
132           Finsupp.single (.inl (0 : Fin (n + 1))) 1) =
133       extendPhaseExponent n (a 0 + c 0 - 1) (p 0 + q 0 - 1) 0 +
134         (phaseExponent (fun j => a j.succ) (fun j => p j.succ) +
135           phaseExponent (fun j => c j.succ) (fun j => q j.succ)).mapDomain
136             oldIndex := by
137   classical
138   rw [phaseExponent_succ_eq_extend, phaseExponent_succ_eq_extend]
139   ext v
140   rcases v with v | v
141   · refine Fin.cases ?_ (fun j => ?_) v
142     · have hmap (s : PhaseVar n →₀ ℕ) :
143           Finsupp.mapDomain oldIndex s (.inl (0 : Fin (n + 1))) = 0 := by
144         apply Finsupp.mapDomain_notin_range
145         rintro ⟨w, hw⟩
146         cases w <;> simp [oldIndex, Fin.succ_ne_zero] at hw
147       simp [extendPhaseExponent, Finsupp.single_apply, hmap]
148       omega
149     · have hmap (s : PhaseVar n →₀ ℕ) :
150           Finsupp.mapDomain oldIndex s (.inl j.succ) = s (.inl j) := by
151         change Finsupp.mapDomain oldIndex s (oldIndex (.inl j)) = _
152         rw [Finsupp.mapDomain_apply_of_injective oldIndex_injective]
153       have hzero : (0 : Fin (n + 1)) ≠ j.succ :=
154         Ne.symm (Fin.succ_ne_zero j)
155       simp [extendPhaseExponent, phaseExponent, Finsupp.single_apply,
156         hmap, hzero, Fin.succ_ne_zero]
157   · refine Fin.cases ?_ (fun j => ?_) v
158     · have hmap (s : PhaseVar n →₀ ℕ) :
159           Finsupp.mapDomain oldIndex s (.inr (0 : Fin (n + 1))) = 0 := by
160         apply Finsupp.mapDomain_notin_range
161         rintro ⟨w, hw⟩
162         cases w <;> simp [oldIndex, Fin.succ_ne_zero] at hw
163       simp [extendPhaseExponent, Finsupp.single_apply, hmap]
164       omega
165     · have hmap (s : PhaseVar n →₀ ℕ) :
166           Finsupp.mapDomain oldIndex s (.inr j.succ) = s (.inr j) := by
167         change Finsupp.mapDomain oldIndex s (oldIndex (.inr j)) = _
168         rw [Finsupp.mapDomain_apply_of_injective oldIndex_injective]
169       have hzero : (0 : Fin (n + 1)) ≠ j.succ :=
170         Ne.symm (Fin.succ_ne_zero j)
171       simp [extendPhaseExponent, phaseExponent, Finsupp.single_apply,
172         hmap, hzero, Fin.succ_ne_zero]
173 
174 private theorem firstContraction_newest_term
175     (n : ℕ) (a p c q : Fin (n + 1) → ℕ)
176     (hp : 0 < p 0) (hc : 0 < c 0) :
177     ((p 0).choose 1 * (c 0).descFactorial 1) •
178         (MvPolynomial.monomial
179             (extendPhaseExponent n (a 0 + c 0 - 1)
180               (p 0 + q 0 - 1) 0) (1 : k) *
181           MvPolynomial.rename oldIndex
182             (MvPolynomial.monomial
183                 (phaseExponent (fun i => a i.succ) (fun i => p i.succ)) 1 *
184               MvPolynomial.monomial
185                 (phaseExponent (fun i => c i.succ) (fun i => q i.succ)) 1)) =
186       MvPolynomial.pderiv (.inr (0 : Fin (n + 1)))
187           (MvPolynomial.monomial (phaseExponent a p) 1) *
188         MvPolynomial.pderiv (.inl (0 : Fin (n + 1)))
189           (MvPolynomial.monomial (phaseExponent c q) 1) := by
190   classical
191   simp only [MvPolynomial.pderiv_monomial,
192     MvPolynomial.monomial_mul, MvPolynomial.rename_monomial, map_mul]
193   rw [phaseExponent_newest_contraction_exponents n a p c q hp hc]
194   simp [phaseExponent, Nat.choose, Nat.descFactorial]
195   rw [← map_natCast
196       (MvPolynomial.C : k →+* SymbolRing k (n + 1)) (p 0),
197     ← map_natCast
198       (MvPolynomial.C : k →+* SymbolRing k (n + 1)) (c 0),
199     ← map_mul, MvPolynomial.C_mul_monomial, mul_one]
200 
201 set_option maxHeartbeats 500000 in
202 /-- Splitting off the newest pair decomposes the first contraction into its
203 newest-pair term and the renamed first contraction in the older pairs. -/
204 theorem pbwFirstContraction_phaseExponent_succ
205     (n : ℕ) (a p c q : Fin (n + 1) → ℕ) :
206     pbwFirstContraction k (phaseExponent a p) (phaseExponent c q) =
207       MvPolynomial.pderiv (.inr (0 : Fin (n + 1)))
208           (MvPolynomial.monomial (phaseExponent a p) 1) *
209         MvPolynomial.pderiv (.inl (0 : Fin (n + 1)))
210           (MvPolynomial.monomial (phaseExponent c q) 1) +
211       MvPolynomial.monomial
212           (extendPhaseExponent n (a 0 + c 0) (p 0 + q 0) 0) 1 *
213         MvPolynomial.rename oldIndex
214           (pbwFirstContraction k
215             (phaseExponent (fun i => a i.succ) (fun i => p i.succ))
216             (phaseExponent (fun i => c i.succ) (fun i => q i.succ))) := by
217   rw [pbwFirstContraction, Fin.sum_univ_succ,
218     pbwFirstContraction, map_sum, Finset.mul_sum]
219   congr 1
220   apply Finset.sum_congr rfl
221   intro i hi
222   exact firstContraction_old_term k n a p c q i
223 
224 /-- For ordered monomials of positive total differential order, the component
225 one below the top order of their product is exactly the one-contraction term. -/
226 theorem presentedOrderedMonomial_mul_firstContraction :
227     ∀ (n : ℕ) (a p c q : Fin n → ℕ),
228       0 < monomialWeight (@orderWeight n) (phaseExponent a p) +
229           monomialWeight (@orderWeight n) (phaseExponent c q) →
230       presentedPrincipalComponent k (@orderWeight n)
231           (monomialWeight (@orderWeight n) (phaseExponent a p) +
232             monomialWeight (@orderWeight n) (phaseExponent c q) - 1)
233           (presentedOrderedMonomial k n a p *
234             presentedOrderedMonomial k n c q) =
235         pbwFirstContraction k (phaseExponent a p) (phaseExponent c q) := by
236   intro n
237   induction n with
238   | zero =>
239       intro a p c q hpos
240       have hap : phaseExponent a p = 0 := by
241         ext i
242         exact Sum.elim Fin.elim0 Fin.elim0 i
243       have hcq : phaseExponent c q = 0 := by
244         ext i
245         exact Sum.elim Fin.elim0 Fin.elim0 i
246       rw [hap, hcq] at hpos
247       simp [monomialWeight] at hpos
248   | succ n ih =>
249       intro a p c q hpos
250       let mold :=
251         phaseExponent (fun i => a i.succ) (fun i => p i.succ)
252       let qold :=
253         phaseExponent (fun i => c i.succ) (fun i => q i.succ)
254       let z :=
255         presentedOrderedMonomial k n (fun i => a i.succ) (fun i => p i.succ) *
256           presentedOrderedMonomial k n (fun i => c i.succ) (fun i => q i.succ)
257       let L := monomialWeight (@orderWeight n) mold +
258         monomialWeight (@orderWeight n) qold
259       let t := p 0 + q 0
260       have htarget :
261           monomialWeight (@orderWeight (n + 1)) (phaseExponent a p) +
262               monomialWeight (@orderWeight (n + 1)) (phaseExponent c q) =
263             L + t := by
264         rw [monomialWeight_phaseExponent_succ_order,
265           monomialWeight_phaseExponent_succ_order]
266         dsimp [L, t, mold, qold]
267         omega
268       have htotal : 0 < L + t := by
269         rwa [htarget] at hpos
270       have hzOrder : z ∈ orderPiece k n L := by
271         dsimp [z, L, mold, qold]
272         exact presentedOrderedMonomial_mul_mem_orderPiece k n
273           (fun i => a i.succ) (fun i => p i.succ)
274           (fun i => c i.succ) (fun i => q i.succ)
275       have hzeroTerm :
276           presentedPrincipalComponent k (@orderWeight (n + 1)) (L + t - 1)
277               (presentedCoefficientOrdered k n (a 0 + c 0) t z) =
278             MvPolynomial.monomial
279                 (extendPhaseExponent n (a 0 + c 0) t 0) 1 *
280               MvPolynomial.rename oldIndex
281                 (pbwFirstContraction k mold qold) := by
282         by_cases hL : L = 0
283         · have ht : 0 < t := by omega
284           have hvanish :
285               presentedPrincipalComponent k (@orderWeight (n + 1))
286                   (L + t - 1)
287                   (presentedCoefficientOrdered k n (a 0 + c 0) t z) = 0 := by
288             rw [presentedPrincipalComponent, LinearMap.comp_apply]
289             change MvPolynomial.weightedHomogeneousComponent
290                 (@orderWeight (n + 1)) (L + t - 1)
291                 (presentedNormalFormLinearEquiv k (n + 1)
292                   (presentedCoefficientOrdered k n (a 0 + c 0) t z)) = 0
293             rw [presentedNormalFormLinearEquiv_previous_ordered_monomial]
294             apply weightedHomogeneousComponent_monomial_mul_eq_zero_of_lt k
295             rw [monomialWeight_extend_zero_order]
296             omega
297           have hmold : monomialWeight (@orderWeight n) mold = 0 := by
298             dsimp [L] at hL
299             omega
300           rw [hvanish,
301             pbwFirstContraction_eq_zero_of_orderWeight_eq_zero
302               k mold qold hmold, map_zero, mul_zero]
303         · have hLpos : 0 < L := Nat.pos_of_ne_zero hL
304           have hih := ih
305             (fun i => a i.succ) (fun i => p i.succ)
306             (fun i => c i.succ) (fun i => q i.succ) hLpos
307           change presentedPrincipalComponent k (@orderWeight n) (L - 1) z =
308               pbwFirstContraction k mold qold at hih
309           rw [show L + t - 1 = (L - 1) + t by omega,
310             presentedPrincipalComponent_coefficientOrdered_order, hih]
311       rw [htarget]
312       change presentedPrincipalComponent k (@orderWeight (n + 1)) (L + t - 1)
313           (presentedCoefficientOrdered k n (a 0) (p 0)
314               (presentedOrderedMonomial k n
315                 (fun i => a i.succ) (fun i => p i.succ)) *
316             presentedCoefficientOrdered k n (c 0) (q 0)
317               (presentedOrderedMonomial k n
318                 (fun i => c i.succ) (fun i => q i.succ))) = _
319       rw [presentedCoefficientOrdered_mul]
320       simp only [map_sum]
321       have hmem0 : 0 ∈ Finset.range (p 0 + 1) := by simp
322       rw [Finset.sum_eq_add_sum_sdiff_singleton_of_mem hmem0]
323       simp only [Nat.zero_le, if_true, Nat.choose_zero_right,
324         Nat.descFactorial_zero, mul_one, one_nsmul, Nat.sub_zero]
325       change presentedPrincipalComponent k (@orderWeight (n + 1)) (L + t - 1)
326             (presentedCoefficientOrdered k n (a 0 + c 0) t z) + _ = _
327       rw [hzeroTerm]
328       rw [pbwFirstContraction_phaseExponent_succ]
329       by_cases hp0 : p 0 = 0
330       · have hempty : Finset.range (p 0 + 1) \ {0} = ∅ := by
331           ext i
332           simp [hp0]
333         rw [hempty]
334         simp [MvPolynomial.pderiv_monomial, phaseExponent, hp0,
335           t, mold, qold]
336       · have hp : 0 < p 0 := Nat.pos_of_ne_zero hp0
337         by_cases hc0 : c 0 = 0
338         · have hrest :
339               ∑ i ∈ Finset.range (p 0 + 1) \ {0},
340                   presentedPrincipalComponent k (@orderWeight (n + 1))
341                     (L + t - 1)
342                     (if i ≤ c 0 then
343                       ((p 0).choose i * (c 0).descFactorial i) •
344                         presentedCoefficientOrdered k n
345                           (a 0 + c 0 - i) (p 0 + q 0 - i) z
346                     else 0) = 0 := by
347             apply Finset.sum_eq_zero
348             intro i hi
349             have hi' := Finset.mem_sdiff.mp hi
350             have hi0 : i ≠ 0 := by simpa using hi'.2
351             have hnot : ¬ i ≤ c 0 := by omega
352             simp [hnot]
353           rw [hrest]
354           simp [MvPolynomial.pderiv_monomial, phaseExponent, hc0,
355             t, mold, qold]
356         · have hc : 0 < c 0 := Nat.pos_of_ne_zero hc0
357           have honeMem : 1 ∈ Finset.range (p 0 + 1) \ {0} := by
358             simp [hp]
359           have hone :
360               presentedPrincipalComponent k (@orderWeight (n + 1))
361                 (L + t - 1)
362                 (((p 0).choose 1 * (c 0).descFactorial 1) •
363                   presentedCoefficientOrdered k n
364                     (a 0 + c 0 - 1) (p 0 + q 0 - 1) z) =
365               MvPolynomial.pderiv (.inr (0 : Fin (n + 1)))
366                     (MvPolynomial.monomial (phaseExponent a p) 1) *
367                 MvPolynomial.pderiv (.inl (0 : Fin (n + 1)))
368                     (MvPolynomial.monomial (phaseExponent c q) 1) := by
369             simp only [map_nsmul]
370             rw [show L + t - 1 = L + (p 0 + q 0 - 1) by omega,
371               presentedPrincipalComponent_coefficientOrdered_order]
372             have htop := presentedOrderedMonomial_mul_principal_order k n
373               (fun i => a i.succ) (fun i => p i.succ)
374               (fun i => c i.succ) (fun i => q i.succ)
375             change presentedPrincipalComponent k (@orderWeight n) L z =
376                 MvPolynomial.monomial mold 1 *
377                   MvPolynomial.monomial qold 1 at htop
378             rw [htop]
379             exact firstContraction_newest_term k n a p c q hp hc
380           rw [Finset.sum_eq_single 1]
381           · simp only [show 1 ≤ c 0 from hc, if_true]
382             rw [hone]
383             abel
384           · intro i hi hi1
385             have hi' := Finset.mem_sdiff.mp hi
386             have hirange : i ∈ Finset.range (p 0 + 1) := hi'.1
387             have hi0 : i ≠ 0 := by simpa using hi'.2
388             have hip : i ≤ p 0 := by
389               have := Finset.mem_range.mp hirange
390               omega
391             by_cases hic : i ≤ c 0
392             · simp only [if_pos hic, map_nsmul]
393               have hterm := presentedCoefficientOrdered_mem_orderPiece k n L
394                 (a 0 + c 0 - i) (p 0 + q 0 - i) z hzOrder
395               have hlt : L + (p 0 + q 0 - i) < L + t - 1 := by
396                 dsimp [t]
397                 omega
398               have hvanish :=
399                 presentedPrincipalComponent_eq_zero_of_mem_of_lt k
400                   (@orderWeight (n + 1)) _ hterm hlt
401               rw [hvanish, nsmul_zero]
402             · simp [hic]
403           · exact fun h => (h honeMem).elim
404 
405 /-- The exact first-contraction coefficient for arbitrary PBW basis vectors.
406 The positivity hypothesis says that the two monomials have positive combined
407 differential order, so the component one below the top is unambiguous. -/
408 theorem presentedPBWBasis_mul_firstContraction {n : ℕ}
409     (m q : PhaseVar n →₀ ℕ)
410     (hpos : 0 < monomialWeight (@orderWeight n) m +
411       monomialWeight (@orderWeight n) q) :
412     presentedPrincipalComponent k (@orderWeight n)
413         (monomialWeight (@orderWeight n) m +
414           monomialWeight (@orderWeight n) q - 1)
415         (presentedPBWBasis k n m * presentedPBWBasis k n q) =
416       pbwFirstContraction k m q := by
417   have hpos' :
418       0 < monomialWeight (@orderWeight n)
419             (phaseExponent (fun i => m (.inl i)) (fun i => m (.inr i))) +
420           monomialWeight (@orderWeight n)
421             (phaseExponent (fun i => q (.inl i)) (fun i => q (.inr i))) := by
422     simpa only [phaseExponent_split] using hpos
423   rw [presentedPBWBasis_apply, presentedPBWBasis_apply,
424     ← phaseExponent_split m, ← phaseExponent_split q]
425   exact presentedOrderedMonomial_mul_firstContraction k n
426     (fun i => m (.inl i)) (fun i => m (.inr i))
427     (fun i => q (.inl i)) (fun i => q (.inr i)) hpos'
428 
429 /-- The unconditional two-element subprincipal commutator formula. -/
430 theorem principalComponent_commutator_eq_neg_poisson
431     {n r s : ℕ} {a b : PresentedWeyl k n}
432     (ha : a ∈ orderPiece k n r) (hb : b ∈ orderPiece k n s) :
433     presentedPrincipalComponent k (@orderWeight n) (r + s - 1)
434         (Stafford.commutator a b) =
435       -poissonBracket
436         (presentedPrincipalComponent k (@orderWeight n) r a)
437         (presentedPrincipalComponent k (@orderWeight n) s b) :=
438   principalComponent_commutator_eq_neg_poisson_of_firstContraction k
439     (presentedPBWBasis_mul_firstContraction k) ha hb
440 
441 #print axioms pbwFirstContraction_phaseExponent_succ
442 #print axioms presentedOrderedMonomial_mul_firstContraction
443 #print axioms presentedPBWBasis_mul_firstContraction
444 #print axioms principalComponent_commutator_eq_neg_poisson
445 
446 end
447 
448 end Stafford38.WeylPBWFirstContraction
449