Stafford38/Paper/Section2/Filtration.lean

This project (Stafford38) · 1029fdb382eee06e7b59bcf32801f40931e2079a

1 module
2 
3 public import Stafford38.Paper.Section2.Weyl
4 public import Stafford38.FixedSourceChallengeTransport
5 public import Stafford38.Characteristic.AssociatedGradedModule
6 
7 @[expose] public section
8 
9 /-!
10 # Section 2 of the paper: Definitions 2.3 and 2.4
11 
12 Definition 2.3: filtrations of an algebra, the associated graded algebra
13 `gr^F = ⊕_j F_j/F_{j-1}`, the filtration degree and the symbol; the Bernstein
14 filtration `B_•` and the order filtration `F_•` of `A_n(k)`, the Bernstein
15 degree `deg_B`, and `gr A_n(k) = k[x, ξ]`.
16 
17 Definition 2.4: filtrations of a right module compatible with a filtration of
18 the algebra, the cyclic example `M_i = qF_i`, and goodness of that example for
19 `Q = A_n/I`.
20 
21 Filtrations are indexed by `ℕ`; the paper's `F_{-1} = 0` is `lowerPiece F 0 = ⊥`.
22 The repository's pieces are spans of ordered PBW words of bounded weight
23 (`WeylFiltration.presentedWeightPiece`); `B_m` uses weight `1` on every
24 generator and `F_m` weight `0` on `x_i`, `1` on `∂_i`.
25 -/
26 
27 namespace Stafford38.Paper.Section2
28 
29 open Stafford38.Characteristic
30 open Stafford38.CharacteristicAssociatedGradedModule
31 open Stafford38.CharacteristicFilteredQuotient
32 open Stafford38.CharacteristicInitialIdeal
33 open Stafford38.EulerSurjectivity
34 open Stafford38.WeylAssociatedGraded
35 open Stafford38.WeylFiltration
36 open Stafford38.WeylIteratedEquivalence
37 open Stafford38.WeylLeadingSymbol
38 open Stafford38.WeylPBW
39 
40 noncomputable section
41 
42 universe u v w
43 
44 section Graded
45 
46 variable {k : Type u} [Field k] {M : Type v} [AddCommGroup M] [Module k M]
47 
48 /-- `F_{j-1}`, with `F_{-1} = 0`. -/
49 def lowerPiece (F : ℕ → Submodule k M) : ℕ → Submodule k M
50   | 0 => ⊥
51   | j + 1 => F j
52 
53 /-- The graded piece `F_j/F_{j-1}`. -/
54 abbrev grPiece (F : ℕ → Submodule k M) (j : ℕ) :=
55   F j ⧸ (lowerPiece F j).comap (F j).subtype
56 
57 instance (priority := 10000) grPieceAddCommMonoid (F : ℕ → Submodule k M) (j : ℕ) :
58     AddCommMonoid (grPiece F j) :=
59   AddCommGroup.toAddCommMonoid
60 
61 instance (priority := 10000) grPieceModule (F : ℕ → Submodule k M) (j : ℕ) :
62     Module k (grPiece F j) :=
63   Submodule.Quotient.module _
64 
65 /-- **Definition 2.3 (associated graded).** `gr^F = ⊕_{j ≥ 0} F_j/F_{j-1}`
66 as a `k`-module, for a filtration of an algebra or (Definition 2.4) of a
67 module. -/
68 abbrev gr (F : ℕ → Submodule k M) :=
69   DirectSum ℕ (grPiece F)
70 
71 end Graded
72 
73 section General
74 
75 variable {k : Type u} [Field k] {A : Type v} [Ring A] [Algebra k A]
76 
77 /-- **Definition 2.3 (filtration).** `F_0 ⊆ F_1 ⊆ … ⊆ A` linear subspaces with
78 `F_i F_j ⊆ F_{i+j}` and `A = ⋃_j F_j`. -/
79 structure IsFiltration (F : ℕ → Submodule k A) : Prop where
80   mono : Monotone F
81   mul_mem : ∀ {i j : ℕ} {a b : A}, a ∈ F i → b ∈ F j → a * b ∈ F (i + j)
82   exhaustive : ∀ a : A, ∃ j, a ∈ F j
83 
84 /-- **Definition 2.3 (filtration degree).** `deg_F a` is the smallest `j` with
85 `a ∈ F_j`. -/
86 def filtrationDegree (F : ℕ → Submodule k A) (a : A) : ℕ :=
87   sInf {j | a ∈ F j}
88 
89 theorem mem_filtrationDegree {F : ℕ → Submodule k A} (hF : IsFiltration F) (a : A) :
90     a ∈ F (filtrationDegree F a) :=
91   Nat.sInf_mem (hF.exhaustive a)
92 
93 /-- **Definition 2.3 (symbol).** `σ_j(a)` is the class of `a` in `F_j/F_{j-1}`
94 for `j = deg_F a`. -/
95 def symbol {F : ℕ → Submodule k A} (hF : IsFiltration F) (a : A) :
96     grPiece F (filtrationDegree F a) :=
97   Submodule.Quotient.mk ⟨a, mem_filtrationDegree hF a⟩
98 
99 end General
100 
101 variable (k : Type u) [Field k]
102 
103 /-- **The Bernstein filtration `B_•`**: degree `1` on every `x_i` and `∂_i`. -/
104 abbrev bernsteinFiltration (n : ℕ) : ℕ → Submodule k (PresentedWeyl k n) :=
105   bernsteinPiece k n
106 
107 /-- **The order filtration `F_•`**: degree `0` on `x_i`, `1` on `∂_i`;
108 `F_m` is spanned by the `x^α ∂^β` with `|β| ≤ m`. -/
109 abbrev orderFiltration (n : ℕ) : ℕ → Submodule k (PresentedWeyl k n) :=
110   orderPiece k n
111 
112 theorem isFiltration_bernstein (n : ℕ) : IsFiltration (bernsteinFiltration k n) :=
113   ⟨fun _ _ h => presentedWeightPiece_mono k _ h, mul_mem_bernsteinPiece k,
114     exists_mem_bernsteinPiece k⟩
115 
116 theorem isFiltration_order (n : ℕ) : IsFiltration (orderFiltration k n) :=
117   ⟨fun _ _ h => presentedWeightPiece_mono k _ h, mul_mem_orderPiece k,
118     exists_mem_orderPiece k⟩
119 
120 /-- **The Bernstein degree** `deg_B d`, the filtration degree for `B_•`. -/
121 def bernsteinDegree {n : ℕ} (d : PresentedWeyl k n) : ℕ :=
122   filtrationDegree (bernsteinFiltration k n) d
123 
124 /-- The printed Bernstein degree is the repository's intrinsic
125 `Stafford38FixedSourceChallenge.bernsteinDegree`. -/
126 theorem bernsteinDegree_eq {n : ℕ} (d : PresentedWeyl k n) :
127     bernsteinDegree k d = Stafford38FixedSourceChallenge.bernsteinDegree k d := by
128   simp only [bernsteinDegree, filtrationDegree, Stafford38FixedSourceChallenge.bernsteinDegree,
129     Stafford38FixedSourceChallengeTransport.bernsteinPiece_eq]
130 
131 /-- `deg_B a ≤ L` exactly when `a ∈ B_L`. -/
132 theorem bernsteinDegree_le_iff {n L : ℕ} (a : PresentedWeyl k n) :
133     bernsteinDegree k a ≤ L ↔ a ∈ bernsteinPiece k n L := by
134   rw [bernsteinDegree_eq, Stafford38FixedSourceChallengeTransport.bernsteinDegree_eq,
135     Stafford38.FixedSource.bernsteinDegree, bernsteinPiece, mem_presentedWeightPiece]
136   constructor
137   · intro h m hm
138     exact (MvPolynomial.le_weightedTotalDegree _ (MvPolynomial.mem_support_iff.mpr hm)).trans h
139   · intro h
140     apply Finset.sup_le
141     intro m hm
142     exact h m (MvPolynomial.mem_support_iff.mp hm)
143 
144 /-- `deg_B d = N` once `d ∈ B_N` has nonzero degree-`N` Bernstein symbol. -/
145 theorem bernsteinDegree_eq_of_principal_ne_zero {n N : ℕ} {d : PresentedWeyl k n}
146     (hd : d ∈ bernsteinPiece k n N)
147     (hP : presentedPrincipalComponent k (@bernsteinWeight n) N d ≠ 0) :
148     bernsteinDegree k d = N := by
149   rw [bernsteinDegree_eq, Stafford38FixedSourceChallengeTransport.bernsteinDegree_eq]
150   exact Stafford38.FixedSource.bernsteinDegree_eq_of_piece_of_principal_ne_zero k hd hP
151 
152 theorem lowerPiece_weight {n : ℕ} (w : PhaseVar n → ℕ) (j : ℕ) :
153     lowerPiece (presentedWeightPiece k w) j = presentedStrictLowerPiece k w j := by
154   cases j <;> rfl
155 
156 /-- For both filtrations of `A_n(k)`, the class of `a ∈ F_j` in `F_j/F_{j-1}`
157 is the degree-`j` homogeneous component of the PBW normal form of `a`, the
158 repository's principal symbol: the class vanishes exactly when that component
159 does. -/
160 theorem grPiece_mk_eq_zero_iff {n : ℕ} (w : PhaseVar n → ℕ) {j : ℕ}
161     (a : presentedWeightPiece k w j) :
162     (Submodule.Quotient.mk a : grPiece (presentedWeightPiece k w) j) = 0 ↔
163       presentedPrincipalComponent k w j a = 0 := by
164   rw [Submodule.Quotient.mk_eq_zero, Submodule.mem_comap, Submodule.coe_subtype,
165     lowerPiece_weight, presentedPrincipalComponent_eq_zero_iff_mem_strictLower k w _ a.2]
166 
167 /-- The graded piece `F_j/F_{j-1}` is the space of weighted-homogeneous symbols of
168 degree `j`, through the principal symbol. -/
169 def grPieceEquiv {n : ℕ} (w : PhaseVar n → ℕ) (j : ℕ) :
170     grPiece (presentedWeightPiece k w) j ≃ₗ[k]
171       MvPolynomial.weightedHomogeneousSubmodule k w j :=
172   (Submodule.quotEquivOfEq _ _ (by
173       ext a
174       rw [Submodule.mem_comap, Submodule.coe_subtype, lowerPiece_weight, LinearMap.mem_ker,
175         ← presentedPrincipalComponent_eq_zero_iff_mem_strictLower k w _ a.2]
176       exact ⟨fun h => Subtype.ext h, fun h => congrArg Subtype.val h⟩)).trans
177     (LinearMap.quotKerEquivOfSurjective _ (principalComponentOnPiece_surjective k w))
178 
179 /-- **`gr A_n(k) = k[x, ξ]`** for the Bernstein and the order filtration
180 (any weight): `⊕_j F_j/F_{j-1}` is identified with the polynomial ring by
181 summing the homogeneous symbols.  Multiplication of classes is the product of
182 symbols, `σ_{i+j}(ab) = σ_i(a)σ_j(b)`
183 (`WeylLeadingSymbol.presentedPrincipalComponent_mul_bernstein`,
184 `presentedPrincipalComponent_mul_order`), so `gr A_n(k)` is commutative. -/
185 def grEquivSymbolRing {n : ℕ} (w : PhaseVar n → ℕ) :
186     gr (presentedWeightPiece k w) ≃ₗ[k] SymbolRing k n := by
187   letI := MvPolynomial.weightedDecomposition k w
188   exact (DFinsupp.mapRange.linearEquiv fun j => grPieceEquiv k w j).trans
189     (DirectSum.decomposeLinearEquiv (MvPolynomial.weightedHomogeneousSubmodule k w)).symm
190 
191 section ModuleFiltration
192 
193 variable {k}
194 variable {A : Type v} [Ring A] [Algebra k A]
195 variable {M : Type w} [AddCommGroup M] [Module Aᵐᵒᵖ M] [Module k M]
196   [IsScalarTower k Aᵐᵒᵖ M]
197 
198 /-- **Definition 2.4 (compatible filtration).** An exhaustive increasing chain
199 `M_0 ⊆ M_1 ⊆ …` of `k`-subspaces (`M_i = 0` for `i < 0`) with
200 `M_i F_j ⊆ M_{i+j}`. -/
201 structure IsCompatibleFiltration (F : ℕ → Submodule k A) (Mf : ℕ → Submodule k M) :
202     Prop where
203   mono : Monotone Mf
204   smul_mem : ∀ {i j : ℕ} {m : M} {a : A}, m ∈ Mf i → a ∈ F j →
205     MulOpposite.op a • m ∈ Mf (i + j)
206   exhaustive : ∀ m : M, ∃ i, m ∈ Mf i
207 
208 /-- `a ↦ qa`. -/
209 def orbitMap (q : M) : A →ₗ[k] M where
210   toFun a := MulOpposite.op a • q
211   map_add' a b := by rw [MulOpposite.op_add, add_smul]
212   map_smul' c a := show MulOpposite.op (c • a) • q = c • (MulOpposite.op a • q) by
213     rw [MulOpposite.op_smul, smul_assoc]
214 
215 /-- The filtration `M_i = qF_i` induced by an element `q`. -/
216 def cyclicFiltration (F : ℕ → Submodule k A) (q : M) (i : ℕ) : Submodule k M :=
217   (F i).map (orbitMap q)
218 
219 /-- **Definition 2.4, example.** For a cyclic module `M = qA` and a filtration
220 `F_•` of `A`, `M_i = qF_i` is a compatible filtration. -/
221 theorem cyclicFiltration_isCompatible {F : ℕ → Submodule k A} (hF : IsFiltration F) (q : M)
222     (hq : ∀ x : M, ∃ a : A, x = MulOpposite.op a • q) :
223     IsCompatibleFiltration F (cyclicFiltration F q) := by
224   refine ⟨fun i j hij => Submodule.map_mono (f := orbitMap q) (hF.mono hij), ?_, ?_⟩
225   · rintro i j _ a ⟨b, hb, rfl⟩ ha
226     refine ⟨b * a, hF.mul_mem hb ha, ?_⟩
227     change MulOpposite.op (b * a) • q = MulOpposite.op a • MulOpposite.op b • q
228     rw [smul_smul, MulOpposite.op_mul]
229   · intro x
230     obtain ⟨a, rfl⟩ := hq x
231     obtain ⟨i, hi⟩ := hF.exhaustive a
232     exact ⟨i, a, hi, rfl⟩
233 
234 end ModuleFiltration
235 
236 /-- **Definition 2.4 for `Q = A_n/I`.** The order filtration `Q_m = qF_m`
237 induced by `q = [1]` is the image of `F_m`; its associated graded module
238 `gr Q = ⊕_m Q_m/Q_{m-1}` with its `k[x, ξ]`-module structure is the
239 repository's `OrderAssociatedGradedModule`. -/
240 abbrev grCyclic {n : ℕ} (I : RightIdeal (PresentedWeyl k n)) :=
241   OrderAssociatedGradedModule k I
242 
243 /-- `Q_m = qF_m`: the repository's quotient pieces are the images of `F_m`. -/
244 theorem quotientOrderPiece_eq {n : ℕ} (I : RightIdeal (PresentedWeyl k n)) (m : ℕ) :
245     quotientOrderPiece k I m = (orderFiltration k n m).map (rightIdealKSubmodule k I).mkQ :=
246   rfl
247 
248 /-- The class `q̄ ∈ Q_0/Q_{-1}` of `q = [1]`. -/
249 abbrev qBar {n : ℕ} (I : RightIdeal (PresentedWeyl k n)) : grCyclic k I :=
250   orderAssociatedGradedOneClass k I
251 
252 /-- `gr Q` is generated over `k[x, ξ]` by `q̄`. -/
253 theorem grCyclic_generated {n : ℕ} (I : RightIdeal (PresentedWeyl k n)) (m : grCyclic k I) :
254     ∃ f : SymbolRing k n, f • qBar k I = m := by
255   rw [qBar, ← orderAssociatedGradedGenerator_eq_oneClass]
256   exact exists_smul_orderAssociatedGradedGenerator k _ m
257 
258 /-- **Definition 2.4, example: goodness.** `gr Q` is finitely generated over
259 `gr A_n = k[x, ξ]`, being generated by `q̄`. -/
260 theorem grCyclic_good {n : ℕ} (I : RightIdeal (PresentedWeyl k n)) :
261     Module.Finite (SymbolRing k n) (grCyclic k I) := by
262   refine ⟨⟨{qBar k I}, eq_top_iff.mpr fun m _ => ?_⟩⟩
263   obtain ⟨f, rfl⟩ := grCyclic_generated k I m
264   exact Submodule.smul_mem _ f (Submodule.subset_span (by simp))
265 
266 
267 section CyclicGraded
268 
269 variable {k}
270 
271 /-- A linear equivalence carrying `F` to `F'` and `G` to `G'` identifies
272 `F/(G ∩ F)` with `F'/(G' ∩ F')`. -/
273 def quotientMapEquiv {P P' : Type*} [AddCommGroup P] [Module k P] [AddCommGroup P']
274     [Module k P'] (e : P ≃ₗ[k] P') (F G : Submodule k P) :
275     (F ⧸ G.comap F.subtype) ≃ₗ[k] (F.map e.toLinearMap ⧸ (G.map e.toLinearMap).comap
276       (F.map e.toLinearMap).subtype) :=
277   Submodule.Quotient.equiv _ _ (e.submoduleMap F) (by
278     ext ⟨x, hx⟩
279     simp only [Submodule.mem_map, Submodule.mem_comap, Submodule.coe_subtype]
280     constructor
281     · rintro ⟨⟨y, hyF⟩, hyG, hxy⟩
282       refine ⟨y, hyG, ?_⟩
283       have := congrArg Subtype.val hxy
284       simpa using this
285     · rintro ⟨y, hyG, rfl⟩
286       obtain ⟨z, hzF, hz⟩ := hx
287       have hzy : z = y := e.injective hz
288       subst hzy
289       exact ⟨⟨z, hzF⟩, hyG, rfl⟩)
290 
291 end CyclicGraded
292 
293 /-- `q = [1] ∈ Q = A_n/I`, the cyclic generator. -/
294 abbrev qClass {n : ℕ} (I : RightIdeal (PresentedWeyl k n)) : RightQuotient I :=
295   Submodule.Quotient.mk 1
296 
297 theorem orbitMap_qClass {n : ℕ} (I : RightIdeal (PresentedWeyl k n)) (a : PresentedWeyl k n) :
298     orbitMap (k := k) (qClass k I) a = Submodule.Quotient.mk a := by
299   change MulOpposite.op a • (Submodule.Quotient.mk 1 : RightQuotient I) = _
300   rw [← Submodule.Quotient.mk_smul, MulOpposite.smul_eq_mul_unop, MulOpposite.unop_op, one_mul]
301 
302 /-- Every element of `Q` is `qa`: `Q` is cyclic, generated by `q`. -/
303 theorem qClass_generates {n : ℕ} (I : RightIdeal (PresentedWeyl k n)) (x : RightQuotient I) :
304     ∃ a : PresentedWeyl k n, x = MulOpposite.op a • qClass k I := by
305   obtain ⟨a, rfl⟩ := Submodule.Quotient.mk_surjective _ x
306   exact ⟨a, (orbitMap_qClass k I a).symm⟩
307 
308 /-- **Definition 2.4 for `Q = A_n/I`.** `M_i = qF_i` is a compatible filtration
309 of `Q` (`cyclicFiltration_isCompatible`). -/
310 theorem cyclicFiltration_order_isCompatible {n : ℕ} (I : RightIdeal (PresentedWeyl k n)) :
311     IsCompatibleFiltration (orderFiltration k n) (cyclicFiltration (orderFiltration k n)
312       (qClass k I)) :=
313   cyclicFiltration_isCompatible (isFiltration_order k n) _ (qClass_generates k I)
314 
315 /-- `Q_m = qF_m` is the repository's quotient piece, transported to `Q`. -/
316 theorem cyclicFiltration_order_eq {n : ℕ} (I : RightIdeal (PresentedWeyl k n)) (m : ℕ) :
317     cyclicFiltration (orderFiltration k n) (qClass k I) m =
318       (quotientOrderPiece k I m).map
319         (filteredRightQuotientEquivRightQuotient k I).toLinearMap := by
320   rw [quotientOrderPiece_eq, ← Submodule.map_comp, cyclicFiltration]
321   congr 1
322   ext a
323   exact (orbitMap_qClass k I a).trans rfl
324 
325 theorem lowerPiece_cyclicFiltration_order_eq {n : ℕ} (I : RightIdeal (PresentedWeyl k n))
326     (m : ℕ) :
327     lowerPiece (cyclicFiltration (orderFiltration k n) (qClass k I)) m =
328       (quotientOrderStrictLowerPiece k I m).map
329         (filteredRightQuotientEquivRightQuotient k I).toLinearMap := by
330   cases m with
331   | zero =>
332       have h0 : presentedStrictLowerPiece k (@orderWeight n) 0 = ⊥ :=
333         (lowerPiece_weight k _ 0).symm
334       rw [quotientOrderStrictLowerPiece, h0, Submodule.map_bot, Submodule.map_bot]
335       rfl
336   | succ m =>
337       rw [quotientOrderStrictLowerPiece, ← lowerPiece_weight]
338       exact cyclicFiltration_order_eq k I m
339 
340 /-- **Definition 2.4, `gr Q`.** The associated graded module
341 `⊕_m Q_m/Q_{m-1}` of the filtration `Q_m = qF_m` (Definition 2.3, `gr`) is
342 `grCyclic`, the module on which `k[x, ξ]` acts. -/
343 def grCyclicEquiv {n : ℕ} (I : RightIdeal (PresentedWeyl k n)) :
344     grCyclic k I ≃ₗ[k] gr (cyclicFiltration (orderFiltration k n) (qClass k I)) :=
345   DFinsupp.mapRange.linearEquiv fun m =>
346     (quotientMapEquiv (filteredRightQuotientEquivRightQuotient k I) _ _).trans
347       (Submodule.Quotient.equiv _ _ (LinearEquiv.ofEq _ _ (cyclicFiltration_order_eq k I m).symm)
348         (by
349           rw [lowerPiece_cyclicFiltration_order_eq]
350           ext ⟨x, hx⟩
351           simp [Submodule.mem_comap]))
352 
353 #print axioms grCyclicEquiv
354 
355 end
356 
357 end Stafford38.Paper.Section2
358