Stafford38/Weyl/SymbolCompatibility.lean

This project (Stafford38) · 1029fdb382eee06e7b59bcf32801f40931e2079a

1 module
2 public import Stafford38.MathlibCompat.MvPolynomialCoeff
3 public import AlgebraicAnalysis.Ore.Associativity
4 public import Stafford38.Weyl.Symplectic
5 public import Stafford38.Weyl.LeadingSymbol
6 public import Stafford38.Characteristic.LinearAction
7 
8 @[expose] public section
9 
10 /-!
11 # Bernstein-symbol compatibility for linear Weyl changes
12 
13 An algebra map whose generator images have Bernstein degree one preserves the
14 Bernstein filtration. Its action on every principal component is obtained by
15 commutatively substituting the degree-one principal symbols of those images.
16 For a symplectic linear Weyl map, this induced substitution is exactly the
17 phase-space linear action defined in `Characteristic.LinearAction`.
18 -/
19 
20 namespace Stafford38.WeylSymbolCompatibility
21 
22 open Stafford
23 open AlgebraicAnalysis
24 open Stafford38.Characteristic
25 open Stafford38.CharacteristicLinearAction
26 open Stafford38.WeylFiltration
27 open Stafford38.WeylIteratedEquivalence
28 open Stafford38.WeylLeadingSymbol
29 open Stafford38.WeylPBW
30 open Stafford38.WeylSymplectic
31 
32 noncomputable section
33 
34 universe u
35 variable (k : Type u) [Field k]
36 
37 theorem normalForm_linearCombination {n : ℕ}
38     (M : Matrix (PhaseVar n) (PhaseVar n) k) (i : PhaseVar n) :
39     presentedNormalFormLinearEquiv k n
40         (freeWeylLinearCombination M
41           (freeWeylGenerator (standardForm k n)) i) =
42       symbolLinearCombination k M i := by
43   calc
44     _ = presentedNormalFormLinearEquiv k n
45         (∑ j, (M i j) • freeWeylGenerator (standardForm k n) j) := by
46       simp [freeWeylLinearCombination, Stafford.linearCombination,
47         Algebra.smul_def]
48     _ = ∑ j, (M i j) • MvPolynomial.X j := by
49       rw [map_sum]
50       apply Finset.sum_congr rfl
51       intro j hj
52       rw [map_smul, presentedNormalFormLinearEquiv_generator]
53     _ = _ := by
54       simp [symbolLinearCombination, Algebra.smul_def]
55 
56 theorem linearCombination_mem_bernsteinPiece {n : ℕ}
57     (M : Matrix (PhaseVar n) (PhaseVar n) k) (i : PhaseVar n) :
58     freeWeylLinearCombination M
59         (freeWeylGenerator (standardForm k n)) i ∈
60       bernsteinPiece k n 1 := by
61   rw [freeWeylLinearCombination]
62   apply Submodule.sum_mem
63   intro j hj
64   rw [← Algebra.smul_def]
65   apply Submodule.smul_mem
66   rw [bernsteinPiece, mem_presentedWeightPiece,
67     presentedNormalFormLinearEquiv_generator]
68   intro m hm
69   simp only [MvPolynomial.coeff_X, ne_eq, ite_eq_right_iff] at hm
70   by_contra hweight
71   exact hm (by
72     intro h
73     subst m
74     simp [monomialWeight, bernsteinWeight] at hweight)
75 
76 theorem principal_linearCombination {n : ℕ}
77     (M : Matrix (PhaseVar n) (PhaseVar n) k) (i : PhaseVar n) :
78     presentedPrincipalComponent k (@bernsteinWeight n) 1
79         (freeWeylLinearCombination M
80           (freeWeylGenerator (standardForm k n)) i) =
81       symbolLinearCombination k M i := by
82   rw [presentedPrincipalComponent, LinearMap.comp_apply,
83     LinearEquiv.coe_toLinearMap, normalForm_linearCombination]
84   rw [symbolLinearCombination, map_sum]
85   apply Finset.sum_congr rfl
86   intro j hj
87   rw [MvPolynomial.weightedHomogeneousComponent_C_mul]
88   congr 1
89   conv_lhs => rw [← pow_one (MvPolynomial.X j), MvPolynomial.X_pow_eq_monomial]
90   conv_rhs => rw [← pow_one (MvPolynomial.X j), MvPolynomial.X_pow_eq_monomial]
91   rw [weightedHomogeneousComponent_monomial]
92   simp [monomialWeight, bernsteinWeight]
93 
94 theorem one_mem_bernsteinPiece (r : ℕ) :
95     (1 : PresentedWeyl k r) ∈ bernsteinPiece k r 0 := by
96   rw [bernsteinPiece, mem_presentedWeightPiece,
97     presentedNormalFormLinearEquiv_one]
98   intro m hm
99   simp only [MvPolynomial.coeff_one, ne_eq, ite_eq_right_iff] at hm
100   by_contra hweight
101   exact hm (by
102     intro h
103     subst m
104     simp [monomialWeight] at hweight)
105 
106 theorem pow_mem_bernsteinPiece {r : ℕ} {x : PresentedWeyl k r}
107     (hx : x ∈ bernsteinPiece k r 1) :
108     ∀ a : ℕ, x ^ a ∈ bernsteinPiece k r a
109   | 0 => by simpa using one_mem_bernsteinPiece k r
110   | a + 1 => by
111       rw [pow_succ]
112       simpa [Nat.add_comm] using
113         mul_mem_bernsteinPiece k (pow_mem_bernsteinPiece hx a) hx
114 
115 theorem algHom_orderedMonomial_mem_bernstein
116     {r : ℕ} (f : PresentedWeyl k 0 →ₐ[k] PresentedWeyl k r)
117     (_hgen : ∀ i : PhaseVar 0,
118       f (freeWeylGenerator (standardForm k 0) i) ∈
119         bernsteinPiece k r 1)
120     (a p : Fin 0 → ℕ) :
121     f (presentedOrderedMonomial k 0 a p) ∈
122       bernsteinPiece k r
123         (monomialWeight (@bernsteinWeight 0) (phaseExponent a p)) := by
124   simp only [presentedOrderedMonomial, map_one]
125   have hw : monomialWeight (@bernsteinWeight 0) (phaseExponent a p) = 0 := by
126     have hphase : phaseExponent a p = 0 := by
127       ext i
128       cases i with
129       | inl i => exact Fin.elim0 i
130       | inr i => exact Fin.elim0 i
131     rw [hphase]
132     rfl
133   rw [hw]
134   exact one_mem_bernsteinPiece k r
135 
136 theorem algHom_orderedMonomial_mem_bernstein_succ
137     {n r : ℕ}
138     (ih : ∀ (f : PresentedWeyl k n →ₐ[k] PresentedWeyl k r),
139       (∀ i : PhaseVar n,
140         f (freeWeylGenerator (standardForm k n) i) ∈
141           bernsteinPiece k r 1) →
142       ∀ (a p : Fin n → ℕ),
143         f (presentedOrderedMonomial k n a p) ∈
144           bernsteinPiece k r
145             (monomialWeight (@bernsteinWeight n) (phaseExponent a p)))
146     (f : PresentedWeyl k (n + 1) →ₐ[k] PresentedWeyl k r)
147     (hgen : ∀ i : PhaseVar (n + 1),
148       f (freeWeylGenerator (standardForm k (n + 1)) i) ∈
149         bernsteinPiece k r 1)
150     (a p : Fin (n + 1) → ℕ) :
151     f (presentedOrderedMonomial k (n + 1) a p) ∈
152       bernsteinPiece k r
153         (monomialWeight (@bernsteinWeight (n + 1)) (phaseExponent a p)) := by
154   let fold : PresentedWeyl k n →ₐ[k] PresentedWeyl k r :=
155     f.comp (previousWeylEmbedding k n)
156   have hfold : ∀ i : PhaseVar n,
157       fold (freeWeylGenerator (standardForm k n) i) ∈
158         bernsteinPiece k r 1 := by
159     intro i
160     simpa [fold, oldGenerator] using hgen (oldIndex i)
161   have hold := ih fold hfold (fun i => a i.succ) (fun i => p i.succ)
162   have hx := pow_mem_bernsteinPiece k (hgen (.inl 0)) (a 0)
163   have hp := pow_mem_bernsteinPiece k (hgen (.inr 0)) (p 0)
164   have hmul := mul_mem_bernsteinPiece k
165     (mul_mem_bernsteinPiece k hold hx) hp
166   change f ((previousWeylEmbedding k n)
167       (presentedOrderedMonomial k n (fun i => a i.succ) (fun i => p i.succ))) *
168       f (presentedCoordinate k n) ^ a 0 *
169       f (presentedMomentum k n) ^ p 0 ∈ _ at hmul
170   rw [presentedOrderedMonomial, map_mul, map_mul, map_pow, map_pow]
171   rw [monomialWeight_phaseExponent_succ_bernstein]
172   simpa [fold, add_assoc] using hmul
173 
174 theorem algHom_orderedMonomial_mem_bernstein_all {r : ℕ} :
175     ∀ (n : ℕ) (f : PresentedWeyl k n →ₐ[k] PresentedWeyl k r),
176       (∀ i : PhaseVar n,
177         f (freeWeylGenerator (standardForm k n) i) ∈
178           bernsteinPiece k r 1) →
179       ∀ (a p : Fin n → ℕ),
180         f (presentedOrderedMonomial k n a p) ∈
181           bernsteinPiece k r
182             (monomialWeight (@bernsteinWeight n) (phaseExponent a p))
183   | 0 => algHom_orderedMonomial_mem_bernstein k
184   | n + 1 => algHom_orderedMonomial_mem_bernstein_succ k
185       (algHom_orderedMonomial_mem_bernstein_all n)
186 
187 theorem algHom_preserves_bernsteinPiece {n r N : ℕ}
188     (f : PresentedWeyl k n →ₐ[k] PresentedWeyl k r)
189     (hgen : ∀ i : PhaseVar n,
190       f (freeWeylGenerator (standardForm k n) i) ∈
191         bernsteinPiece k r 1)
192     {z : PresentedWeyl k n} (hz : z ∈ bernsteinPiece k n N) :
193   f z ∈ bernsteinPiece k r N := by
194   rw [bernsteinPiece, presentedWeightPiece_eq_span] at hz
195   induction hz using Submodule.span_induction with
196   | mem b hb =>
197       obtain ⟨m, hm, rfl⟩ := hb
198       rw [presentedPBWBasis_apply]
199       have h := algHom_orderedMonomial_mem_bernstein_all k n f hgen
200         (fun i => m (.inl i)) (fun i => m (.inr i))
201       rw [phaseExponent_split] at h
202       exact presentedWeightPiece_mono k bernsteinWeight hm h
203   | zero =>
204       rw [map_zero]
205       exact (bernsteinPiece k r N).zero_mem
206   | add x y hx hy ihx ihy =>
207       rw [map_add]
208       exact (bernsteinPiece k r N).add_mem ihx ihy
209   | smul c x hx ih =>
210       rw [map_smul]
211       exact (bernsteinPiece k r N).smul_mem c ih
212 
213 theorem standardSymplecticAlgHom_preserves_bernsteinPiece {n N : ℕ}
214     (M : Matrix (PhaseVar n) (PhaseVar n) k)
215     (hM : M * standardForm k n * Matrix.transpose M = standardForm k n)
216     {z : PresentedWeyl k n} (hz : z ∈ bernsteinPiece k n N) :
217     standardSymplecticAlgHom k M hM z ∈ bernsteinPiece k n N := by
218   exact algHom_preserves_bernsteinPiece k
219     (standardSymplecticAlgHom k M hM)
220     (fun i => by
221       rw [standardSymplecticAlgHom_generator]
222       exact linearCombination_mem_bernsteinPiece k M i) hz
223 
224 theorem phaseMonomial_succ_decompose {n : ℕ}
225     (a p : Fin (n + 1) → ℕ) :
226     MvPolynomial.monomial (phaseExponent a p) (1 : k) =
227       MvPolynomial.rename oldIndex
228           (MvPolynomial.monomial
229             (phaseExponent (fun i => a i.succ) (fun i => p i.succ)) 1) *
230         MvPolynomial.X (.inl (0 : Fin (n + 1))) ^ a 0 *
231         MvPolynomial.X (.inr (0 : Fin (n + 1))) ^ p 0 := by
232   rw [phaseExponent_succ_eq_extend, extendPhaseExponent,
233     MvPolynomial.rename_monomial,
234     MvPolynomial.X_pow_eq_monomial,
235     MvPolynomial.X_pow_eq_monomial,
236     MvPolynomial.monomial_mul, MvPolynomial.monomial_mul]
237   simp [add_comm, add_left_comm, add_assoc]
238 
239 theorem principal_one_bernstein (r : ℕ) :
240     presentedPrincipalComponent k (@bernsteinWeight r) 0
241         (1 : PresentedWeyl k r) = 1 := by
242   rw [presentedPrincipalComponent, LinearMap.comp_apply,
243     LinearEquiv.coe_toLinearMap, presentedNormalFormLinearEquiv_one]
244   change MvPolynomial.weightedHomogeneousComponent (@bernsteinWeight r) 0
245       (MvPolynomial.monomial (0 : PhaseVar r →₀ ℕ) (1 : k)) = 1
246   rw [weightedHomogeneousComponent_monomial]
247   simp [monomialWeight]
248 
249 theorem pow_principal_bernstein {r : ℕ} {x : PresentedWeyl k r}
250     (hx : x ∈ bernsteinPiece k r 1) :
251     ∀ a : ℕ,
252       presentedPrincipalComponent k (@bernsteinWeight r) a (x ^ a) =
253         (presentedPrincipalComponent k (@bernsteinWeight r) 1 x) ^ a
254   | 0 => by simpa using principal_one_bernstein k r
255   | a + 1 => by
256       rw [pow_succ, pow_succ, ← pow_principal_bernstein hx a]
257       simpa [Nat.add_comm] using
258         presentedPrincipalComponent_mul_bernstein k
259           (pow_mem_bernsteinPiece k hx a) hx
260 
261 theorem algHom_orderedMonomial_principal_zero
262     {r : ℕ} (f : PresentedWeyl k 0 →ₐ[k] PresentedWeyl k r)
263     (g : PhaseVar 0 → SymbolRing k r)
264     (a p : Fin 0 → ℕ) :
265     presentedPrincipalComponent k (@bernsteinWeight r)
266         (monomialWeight (@bernsteinWeight 0) (phaseExponent a p))
267         (f (presentedOrderedMonomial k 0 a p)) =
268       MvPolynomial.aeval g
269         (MvPolynomial.monomial (phaseExponent a p) (1 : k)) := by
270   have hphase : phaseExponent a p = 0 := by
271     ext i
272     cases i with
273     | inl i => exact Fin.elim0 i
274     | inr i => exact Fin.elim0 i
275   rw [hphase]
276   simp [presentedOrderedMonomial, principal_one_bernstein, monomialWeight]
277 
278 theorem algHom_orderedMonomial_principal_succ
279     {n r : ℕ}
280     (ih : ∀ (f : PresentedWeyl k n →ₐ[k] PresentedWeyl k r)
281       (_hgen : ∀ i : PhaseVar n,
282         f (freeWeylGenerator (standardForm k n) i) ∈
283           bernsteinPiece k r 1)
284       (g : PhaseVar n → SymbolRing k r),
285       (∀ i,
286         presentedPrincipalComponent k (@bernsteinWeight r) 1
287             (f (freeWeylGenerator (standardForm k n) i)) = g i) →
288       ∀ (a p : Fin n → ℕ),
289         presentedPrincipalComponent k (@bernsteinWeight r)
290             (monomialWeight (@bernsteinWeight n) (phaseExponent a p))
291             (f (presentedOrderedMonomial k n a p)) =
292           MvPolynomial.aeval g
293             (MvPolynomial.monomial (phaseExponent a p) (1 : k)))
294     (f : PresentedWeyl k (n + 1) →ₐ[k] PresentedWeyl k r)
295     (hgen : ∀ i : PhaseVar (n + 1),
296       f (freeWeylGenerator (standardForm k (n + 1)) i) ∈
297         bernsteinPiece k r 1)
298     (g : PhaseVar (n + 1) → SymbolRing k r)
299     (hprincipal : ∀ i,
300       presentedPrincipalComponent k (@bernsteinWeight r) 1
301           (f (freeWeylGenerator (standardForm k (n + 1)) i)) = g i)
302     (a p : Fin (n + 1) → ℕ) :
303     presentedPrincipalComponent k (@bernsteinWeight r)
304         (monomialWeight (@bernsteinWeight (n + 1)) (phaseExponent a p))
305         (f (presentedOrderedMonomial k (n + 1) a p)) =
306       MvPolynomial.aeval g
307         (MvPolynomial.monomial (phaseExponent a p) (1 : k)) := by
308   let fold : PresentedWeyl k n →ₐ[k] PresentedWeyl k r :=
309     f.comp (previousWeylEmbedding k n)
310   let gold : PhaseVar n → SymbolRing k r := fun i => g (oldIndex i)
311   have hfold : ∀ i : PhaseVar n,
312       fold (freeWeylGenerator (standardForm k n) i) ∈
313         bernsteinPiece k r 1 := by
314     intro i
315     simpa [fold, oldGenerator] using hgen (oldIndex i)
316   have hfoldprincipal : ∀ i,
317       presentedPrincipalComponent k (@bernsteinWeight r) 1
318           (fold (freeWeylGenerator (standardForm k n) i)) = gold i := by
319     intro i
320     simpa [fold, gold, oldGenerator] using hprincipal (oldIndex i)
321   let aold : Fin n → ℕ := fun i => a i.succ
322   let pold : Fin n → ℕ := fun i => p i.succ
323   let d := monomialWeight (@bernsteinWeight n) (phaseExponent aold pold)
324   have holdmem := algHom_orderedMonomial_mem_bernstein_all k n fold hfold aold pold
325   have holdprincipal := ih fold hfold gold hfoldprincipal aold pold
326   have hx := hgen (.inl 0)
327   have hp := hgen (.inr 0)
328   have hxa := pow_mem_bernsteinPiece k hx (a 0)
329   have hpp := pow_mem_bernsteinPiece k hp (p 0)
330   have hfirst := presentedPrincipalComponent_mul_bernstein k holdmem hxa
331   rw [pow_principal_bernstein k hx] at hfirst
332   have hfirstmem := mul_mem_bernsteinPiece k holdmem hxa
333   have hsecond := presentedPrincipalComponent_mul_bernstein k hfirstmem hpp
334   rw [pow_principal_bernstein k hp, hfirst, holdprincipal,
335     hprincipal (.inl 0), hprincipal (.inr 0)] at hsecond
336   have hf : f (presentedOrderedMonomial k (n + 1) a p) =
337       fold (presentedOrderedMonomial k n aold pold) *
338         f (presentedCoordinate k n) ^ a 0 *
339         f (presentedMomentum k n) ^ p 0 := by
340     rw [presentedOrderedMonomial, map_mul, map_mul, map_pow, map_pow]
341     rfl
342   rw [hf, monomialWeight_phaseExponent_succ_bernstein]
343   change presentedPrincipalComponent k (@bernsteinWeight r)
344       (d + a 0 + p 0)
345       (fold (presentedOrderedMonomial k n aold pold) *
346         f (presentedCoordinate k n) ^ a 0 *
347         f (presentedMomentum k n) ^ p 0) = _
348   rw [phaseMonomial_succ_decompose]
349   simp only [map_mul, map_pow, MvPolynomial.aeval_X]
350   rw [MvPolynomial.aeval_rename]
351   exact hsecond
352 
353 theorem algHom_orderedMonomial_principal_all {r : ℕ} :
354     ∀ (n : ℕ) (f : PresentedWeyl k n →ₐ[k] PresentedWeyl k r)
355       (_hgen : ∀ i : PhaseVar n,
356         f (freeWeylGenerator (standardForm k n) i) ∈
357           bernsteinPiece k r 1)
358       (g : PhaseVar n → SymbolRing k r),
359       (∀ i,
360         presentedPrincipalComponent k (@bernsteinWeight r) 1
361             (f (freeWeylGenerator (standardForm k n) i)) = g i) →
362       ∀ (a p : Fin n → ℕ),
363         presentedPrincipalComponent k (@bernsteinWeight r)
364             (monomialWeight (@bernsteinWeight n) (phaseExponent a p))
365             (f (presentedOrderedMonomial k n a p)) =
366           MvPolynomial.aeval g
367             (MvPolynomial.monomial (phaseExponent a p) (1 : k))
368   | 0 => fun f _ g _ => algHom_orderedMonomial_principal_zero k f g
369   | n + 1 => algHom_orderedMonomial_principal_succ k
370       (algHom_orderedMonomial_principal_all n)
371 
372 theorem algHom_principal_compatibility {n r N : ℕ}
373     (f : PresentedWeyl k n →ₐ[k] PresentedWeyl k r)
374     (hgen : ∀ i : PhaseVar n,
375       f (freeWeylGenerator (standardForm k n) i) ∈
376         bernsteinPiece k r 1)
377     (g : PhaseVar n → SymbolRing k r)
378     (hprincipal : ∀ i,
379       presentedPrincipalComponent k (@bernsteinWeight r) 1
380           (f (freeWeylGenerator (standardForm k n) i)) = g i)
381     {z : PresentedWeyl k n} (hz : z ∈ bernsteinPiece k n N) :
382     presentedPrincipalComponent k (@bernsteinWeight r) N (f z) =
383       MvPolynomial.aeval g
384         (presentedPrincipalComponent k (@bernsteinWeight n) N z) := by
385   rw [bernsteinPiece, presentedWeightPiece_eq_span] at hz
386   induction hz using Submodule.span_induction with
387   | mem b hb =>
388       obtain ⟨m, hm, rfl⟩ := hb
389       let d := monomialWeight (@bernsteinWeight n) m
390       have hmapmem : f (presentedPBWBasis k n m) ∈ bernsteinPiece k r d := by
391         rw [presentedPBWBasis_apply]
392         have h := algHom_orderedMonomial_mem_bernstein_all k n f hgen
393           (fun i => m (.inl i)) (fun i => m (.inr i))
394         rw [phaseExponent_split] at h
395         exact h
396       by_cases hd : d = N
397       · subst N
398         rw [presentedPrincipalComponent_basis, if_pos rfl,
399           presentedPBWBasis_apply]
400         have h := algHom_orderedMonomial_principal_all k n f hgen g hprincipal
401           (fun i => m (.inl i)) (fun i => m (.inr i))
402         rw [phaseExponent_split] at h
403         exact h
404       · have hdlt : d < N := lt_of_le_of_ne hm hd
405         rw [presentedPrincipalComponent_eq_zero_of_mem_of_lt k
406           (@bernsteinWeight r) (f (presentedPBWBasis k n m)) hmapmem hdlt,
407           presentedPrincipalComponent_basis, if_neg hd, map_zero]
408   | zero => simp
409   | add x y hx hy ihx ihy =>
410       simp only [map_add]
411       rw [ihx, ihy]
412   | smul c x hx ih =>
413       simp only [map_smul]
414       rw [ih]
415 
416 theorem standardSymplecticAlgHom_principal_compatibility {n N : ℕ}
417     (M : Matrix (PhaseVar n) (PhaseVar n) k)
418     (hM : M * standardForm k n * Matrix.transpose M = standardForm k n)
419     {z : PresentedWeyl k n} (hz : z ∈ bernsteinPiece k n N) :
420     presentedPrincipalComponent k (@bernsteinWeight n) N
421         (standardSymplecticAlgHom k M hM z) =
422       symbolLinearAlgHom k M
423         (presentedPrincipalComponent k (@bernsteinWeight n) N z) := by
424   exact algHom_principal_compatibility k
425     (standardSymplecticAlgHom k M hM)
426     (fun i => by
427       rw [standardSymplecticAlgHom_generator]
428       exact linearCombination_mem_bernsteinPiece k M i)
429     (symbolLinearCombination k M)
430     (fun i => by
431       rw [standardSymplecticAlgHom_generator]
432       exact principal_linearCombination k M i) hz
433 
434 /- Exact statement pins for the two exported compatibility conclusions. -/
435 example {n N : ℕ}
436     (M : Matrix (PhaseVar n) (PhaseVar n) k)
437     (hM : M * standardForm k n * Matrix.transpose M = standardForm k n)
438     {z : PresentedWeyl k n} (hz : z ∈ bernsteinPiece k n N) :
439     standardSymplecticAlgHom k M hM z ∈ bernsteinPiece k n N :=
440   standardSymplecticAlgHom_preserves_bernsteinPiece k M hM hz
441 
442 example {n N : ℕ}
443     (M : Matrix (PhaseVar n) (PhaseVar n) k)
444     (hM : M * standardForm k n * Matrix.transpose M = standardForm k n)
445     {z : PresentedWeyl k n} (hz : z ∈ bernsteinPiece k n N) :
446     presentedPrincipalComponent k (@bernsteinWeight n) N
447         (standardSymplecticAlgHom k M hM z) =
448       symbolLinearAlgHom k M
449         (presentedPrincipalComponent k (@bernsteinWeight n) N z) :=
450   standardSymplecticAlgHom_principal_compatibility k M hM hz
451 
452 #print axioms normalForm_linearCombination
453 #print axioms linearCombination_mem_bernsteinPiece
454 #print axioms principal_linearCombination
455 #print axioms algHom_orderedMonomial_mem_bernstein_all
456 #print axioms algHom_preserves_bernsteinPiece
457 #print axioms standardSymplecticAlgHom_preserves_bernsteinPiece
458 #print axioms phaseMonomial_succ_decompose
459 #print axioms pow_principal_bernstein
460 #print axioms algHom_orderedMonomial_principal_all
461 #print axioms algHom_principal_compatibility
462 #print axioms standardSymplecticAlgHom_principal_compatibility
463 
464 end
465 end Stafford38.WeylSymbolCompatibility
466