Stafford38/Characteristic/ArtinianAdaptedBasisExistence.lean

This project (Stafford38) · 1029fdb382eee06e7b59bcf32801f40931e2079a

1 module
2 public import Stafford38.Characteristic.ArtinianAdaptedBasisTraceAdapter
3 public import Mathlib.Data.Fintype.Sort
4 public import Mathlib.Data.Prod.Lex
5 
6 @[expose] public section
7 
8 /-!
9 # Existence of filtration-adapted bases
10 
11 This file constructs a basis adapted to a finite descending filtration of a
12 finite-dimensional vector space.  The construction is elementary: starting
13 at a zero layer, extend a linearly independent set one layer at a time, and
14 label each newly added vector by the layer at which it appears.  A final
15 sorting by decreasing labels gives the ordered `Fin` basis used by the
16 Artinian trace argument.
17 -/
18 
19 namespace Stafford38.Characteristic.ArtinianAdaptedBasisExistence
20 
21 open Stafford38.Characteristic.ArtinianAdaptedBasisTraceAdapter
22 
23 noncomputable section
24 
25 universe u
26 
27 section LinearFiltration
28 
29 variable {K V : Type u} [Field K] [AddCommGroup V] [Module K V]
30 
31 /-- Intermediate set-valued form of an adapted basis, valid from `start`
32 onwards. -/
33 private structure PartialAdaptedSet
34     (F : ℕ → Submodule K V) (start : ℕ) where
35   carrier : Set V
36   independent : LinearIndependent K ((↑) : carrier → V)
37   span_start : Submodule.span K carrier = F start
38   level : carrier → ℕ
39   start_le_level : ∀ i, start ≤ level i
40   span_level : ∀ t, start ≤ t →
41     F t = Submodule.span K (((↑) : carrier → V) '' {i | t ≤ level i})
42 
43 private noncomputable def partialAtBottom
44     (F : ℕ → Submodule K V) (hanti : Antitone F)
45     (N : ℕ) (hN : F N = ⊥) :
46     PartialAdaptedSet F N := by
47   refine
48     { carrier := ∅
49       independent := linearIndependent_empty K V
50       span_start := by simp [hN]
51       level := fun i => False.elim i.property
52       start_le_level := fun i => False.elim i.property
53       span_level := ?_ }
54   intro t hNt
55   have ht : F t = ⊥ := by
56     apply le_bot_iff.mp
57     rw [← hN]
58     exact hanti hNt
59   have hempty : {i : (∅ : Set V) | t ≤ False.elim i.property} = ∅ := by
60     ext i
61     exact False.elim i.property
62   simp [ht, hempty]
63 
64 private noncomputable def partialStep
65     (F : ℕ → Submodule K V) (hanti : Antitone F)
66     (t : ℕ) (old : PartialAdaptedSet F (t + 1)) :
67     PartialAdaptedSet F t := by
68   classical
69   let oldIn : old.carrier ⊆ (F t : Set V) := fun x hx =>
70     hanti (Nat.le_succ t) (by
71       rw [← old.span_start]
72       exact Submodule.subset_span hx)
73   have hOld : LinearIndepOn K id old.carrier :=
74     linearIndependent_subtype_iff.mp old.independent
75   let next : Set V := hOld.extend oldIn
76   have holdNext : old.carrier ⊆ next :=
77     hOld.subset_extend oldIn
78   have hnextF : next ⊆ (F t : Set V) :=
79     hOld.extend_subset oldIn
80   have hind : LinearIndependent K ((↑) : next → V) := by
81     exact linearIndependent_subtype_iff.mpr
82       (hOld.linearIndepOn_extend oldIn)
83   let lev : next → ℕ := fun i =>
84     if hi : (i : V) ∈ old.carrier then old.level ⟨i, hi⟩ else t
85   have hlev : ∀ i, t ≤ lev i := by
86     intro i
87     dsimp [lev]
88     split_ifs with hi
89     · exact le_trans (Nat.le_succ t) (old.start_le_level ⟨i, hi⟩)
90     · exact le_rfl
91   refine
92     { carrier := next
93       independent := hind
94       span_start := ?_
95       level := lev
96       start_le_level := hlev
97       span_level := ?_ }
98   · apply le_antisymm
99     · exact Submodule.span_le.mpr hnextF
100     · exact hOld.subset_span_extend oldIn
101   · intro u htu
102     rcases Nat.eq_or_lt_of_le htu with rfl | htu'
103     · have hall : (((↑) : next → V) '' {i | t ≤ lev i}) = next := by
104         ext x
105         constructor
106         · rintro ⟨i, -, rfl⟩
107           exact i.property
108         · intro hx
109           exact ⟨⟨x, hx⟩, hlev ⟨x, hx⟩, rfl⟩
110       rw [hall]
111       symm
112       apply le_antisymm
113       · exact Submodule.span_le.mpr hnextF
114       · exact hOld.subset_span_extend oldIn
115     · rw [old.span_level u (Nat.succ_le_iff.mpr htu')]
116       apply congrArg (Submodule.span K)
117       ext x
118       constructor
119       · rintro ⟨i, hi, rfl⟩
120         let j : next := ⟨(i : V), holdNext i.property⟩
121         refine ⟨j, ?_, rfl⟩
122         simpa [lev, j, i.property] using hi
123       · rintro ⟨i, hi, rfl⟩
124         have hiOld : (i : V) ∈ old.carrier := by
125           by_contra hn
126           have : lev i = t := dif_neg hn
127           change u ≤ lev i at hi
128           rw [this] at hi
129           exact (Nat.not_le_of_lt htu') hi
130         refine ⟨⟨(i : V), hiOld⟩, ?_, rfl⟩
131         simpa [lev, hiOld] using hi
132 
133 private noncomputable def partialAtZero
134     (F : ℕ → Submodule K V) (hanti : Antitone F)
135     (N : ℕ) (hN : F N = ⊥) :
136     PartialAdaptedSet F 0 :=
137   Nat.decreasingInduction
138     (motive := fun t _ => PartialAdaptedSet F t)
139     (fun t _ old => partialStep F hanti t old)
140     (partialAtBottom F hanti N hN)
141     (Nat.zero_le N)
142 
143 /-- Every finite descending filtration of a finite-dimensional vector space
144 has a `Fin`-indexed basis ordered by decreasing filtration level. -/
145 theorem exists_filtrationAdaptedBasis
146     [FiniteDimensional K V]
147     {n : ℕ} (hdim : Module.finrank K V = n + 1)
148     (F : ℕ → Submodule K V)
149     (hanti : Antitone F)
150     (hzero : F 0 = ⊤)
151     (heventually : ∃ N, F N = ⊥) :
152     ∃ (b : Module.Basis (Fin (n + 1)) K V) (level : Fin (n + 1) → ℕ),
153       Antitone level ∧
154       ∀ t, F t = Submodule.span K (b '' {i | t ≤ level i}) := by
155   classical
156   obtain ⟨N, hN⟩ := heventually
157   let data := partialAtZero F hanti N hN
158   have hspanTop : Submodule.span K data.carrier = ⊤ := data.span_start.trans hzero
159   let raw : Module.Basis data.carrier K V :=
160     Module.Basis.mk data.independent (by simpa using hspanTop.ge)
161   letI : Fintype data.carrier := FiniteDimensional.fintypeBasisIndex raw
162   have hcard : Fintype.card data.carrier = n + 1 := by
163     rw [← hdim, ← Module.finrank_eq_card_basis raw]
164   let rank : data.carrier ≃ Fin (n + 1) :=
165     Fintype.equivOfCardEq (hcard.trans (Fintype.card_fin (n + 1)).symm)
166   let key : data.carrier → (OrderDual ℕ ×ₗ Fin (n + 1)) :=
167     fun i => toLex ((data.level i : OrderDual ℕ), rank i)
168   have hkey : Function.Injective key := by
169     intro i j hij
170     apply rank.injective
171     exact congrArg (fun z => (ofLex z).2) hij
172   letI : LinearOrder data.carrier := LinearOrder.lift' key hkey
173   let sorted : Fin (n + 1) ≃o data.carrier :=
174     Fintype.orderIsoFinOfCardEq data.carrier hcard
175   let b : Module.Basis (Fin (n + 1)) K V := raw.reindex sorted.toEquiv.symm
176   let level : Fin (n + 1) → ℕ := fun i => data.level (sorted i)
177   refine ⟨b, level, ?_, ?_⟩
178   · intro i j hij
179     have hs : sorted i ≤ sorted j := sorted.monotone hij
180     have hs' : key (sorted i) ≤ key (sorted j) := hs
181     rw [Prod.Lex.toLex_le_toLex] at hs'
182     rcases hs' with hs | ⟨hs, -⟩
183     · exact Nat.le_of_lt hs
184     · exact le_of_eq (congrArg OrderDual.ofDual hs).symm
185   · intro t
186     rw [data.span_level t (Nat.zero_le t)]
187     congr 1
188     ext x
189     constructor
190     · rintro ⟨i, hi, rfl⟩
191       refine ⟨sorted.symm i, ?_, ?_⟩
192       · simpa [level] using hi
193       · simp [b, raw]
194     · rintro ⟨i, hi, rfl⟩
195       refine ⟨sorted i, ?_, ?_⟩
196       · simpa [level] using hi
197       · simp [b, raw]
198 
199 end LinearFiltration
200 
201 section ArtinianApplication
202 
203 variable {K R V : Type u}
204 variable [Field K] [CommRing R] [Algebra K R] [IsLocalRing R]
205 variable [IsArtinianRing R]
206 variable [AddCommGroup V] [Module K V] [Module R V] [IsScalarTower K R V]
207 variable [FiniteDimensional K V]
208 
209 local notation "𝔪" => IsLocalRing.maximalIdeal R
210 
211 /-- Maximal-ideal powers on a finite-dimensional module have the adapted
212 basis required by the Artinian trace adapter. -/
213 theorem exists_maximalIdealFiltrationAdaptedBasis
214     {n : ℕ} (hdim : Module.finrank K V = n + 1) :
215     ∃ (b : Module.Basis (Fin (n + 1)) K V) (level : Fin (n + 1) → ℕ),
216       IsMaximalIdealFiltrationAdapted 𝔪 b level := by
217   let F : ℕ → Submodule K V := fun t =>
218     ((𝔪 ^ t • (⊤ : Submodule R V)).restrictScalars K)
219   have hanti : Antitone F := by
220     intro a b hab
221     exact (Submodule.restrictScalarsEmbedding K R V).monotone
222       (Submodule.smul_mono (Ideal.pow_le_pow_right hab) le_rfl)
223   have hzero : F 0 = ⊤ := by
224     ext v
225     simp [F]
226   obtain ⟨N, hN⟩ :=
227     Stafford38.Characteristic.ArtinianCoefficientField.maximalIdeal_isNilpotent
228       (R := R)
229   have hbottom : F N = ⊥ := by
230     ext v
231     simp [F, hN]
232   obtain ⟨b, level, hlevel, hspan⟩ :=
233     exists_filtrationAdaptedBasis hdim F hanti hzero ⟨N, hbottom⟩
234   exact ⟨b, level, ⟨hlevel, hspan⟩⟩
235 
236 #print axioms exists_filtrationAdaptedBasis
237 #print axioms exists_maximalIdealFiltrationAdaptedBasis
238 
239 end ArtinianApplication
240 
241 end
242 
243 end Stafford38.Characteristic.ArtinianAdaptedBasisExistence
244