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