Stafford38/Characteristic/ConcreteEquation33SourceMatrices.lean

This project (Stafford38) · 1029fdb382eee06e7b59bcf32801f40931e2079a

1 module
2 public import Stafford38.Characteristic.ConcreteLocalizedTwoBlockSpecialFibre
3 public import Stafford38.Characteristic.ArtinianAdaptedBasisExistence
4 public import Stafford38.Characteristic.ArtinianEquation33TraceProducer
5 
6 @[expose] public section
7 
8 /-!
9 # Source matrices for the concrete equation-(3.3) bridge
10 
11 This file carries out source-level matrix algebra preceding the trace
12 argument in Singh--Kumar, Proposition 3.2. It keeps the deformation ring
13 noncommutative and preserves the written left-factor orientation of the
14 central parameter. It constructs strict parameter cofactors and literal
15 trace cofactors for first-order source matrices.
16 
17 The module records the specialized source action but does not identify it
18 with the operator induced by the bracket cofactor on the concrete localized
19 module. The canonical-support proof uses the separate
20 `PaperLocalizedInvolutivity` route.
21 -/
22 
23 namespace Stafford38.Characteristic.ConcreteEquation33SourceMatrices
24 
25 open Matrix
26 open Stafford38.Characteristic
27 open Stafford38.Characteristic.ArtinianAdaptedBasisExistence
28 open Stafford38.Characteristic.ArtinianAdaptedBasisTraceAdapter
29 open Stafford38.Characteristic.ArtinianEquation33TraceProducer
30 open Stafford38.Characteristic.ConcreteLocalizedTwoBlockSpecialFibre
31 open Stafford38.Characteristic.LocalizedHighPowerTwoBlockVanishing
32 open Stafford38.Characteristic.LocalizedTwoBlockQuotient
33 open Stafford38.Characteristic.RightReesArtinianAdapter
34 open Stafford38.Characteristic.SquareZeroLocalizedExactness
35 open Stafford38.Characteristic.SquareZeroLocalizedRing
36 open Stafford38.CharacteristicConcreteSquareZeroTraceData
37 open Stafford38.CharacteristicOrderReesTwoJet
38 open Stafford38.EulerSurjectivity
39 open Stafford38.WeylIteratedEquivalence
40 
41 noncomputable section
42 
43 universe u
44 
45 section PrincipalReduction
46 
47 variable {B Abar : Type u} [Ring B] [CommRing Abar]
48 
49 /-- A surjective reduction with an exact written-order left-principal kernel.
50 This is the elementwise form supplied by the concrete localized Rees
51 specialization. -/
52 structure LeftPrincipalParameterReduction where
53   parameter : B
54   modParameter : B →+* Abar
55   surjective : Function.Surjective modParameter
56   parameter_comm : ∀ z : B, parameter * z = z * parameter
57   kernel_left : ∀ z : B,
58     modParameter z = 0 ↔ ∃ w : B, parameter * w = z
59 
60 /-- The source's ideal-valued reduction follows from the stronger explicit
61 left-principal kernel, using centrality only to match Mathlib's left-ideal
62 generator convention. -/
63 def LeftPrincipalParameterReduction.toParameterIdealReduction
64     (S : LeftPrincipalParameterReduction (B := B) (Abar := Abar)) :
65     ParameterIdealReduction B Abar where
66   parameter := S.parameter
67   modParameter := S.modParameter
68   ker_modParameter := by
69     ext z
70     constructor
71     · intro hz
72       obtain ⟨w, hw⟩ := (S.kernel_left z).1 hz
73       rw [Ideal.mem_span_singleton']
74       exact ⟨w, (S.parameter_comm w).symm.trans hw⟩
75     · intro hz
76       rw [Ideal.mem_span_singleton'] at hz
77       obtain ⟨w, rfl⟩ := hz
78       rw [← S.parameter_comm w]
79       exact (S.kernel_left (S.parameter * w)).2 ⟨w, rfl⟩
80 
81 /-- A zero-preserving choice of a lift through a surjective reduction. -/
82 def zeroPreservingLift
83     (S : LeftPrincipalParameterReduction (B := B) (Abar := Abar))
84     (z : Abar) : B := by
85   classical
86   exact if hz : z = 0 then 0 else Classical.choose (S.surjective z)
87 
88 @[simp]
89 theorem modParameter_zeroPreservingLift
90     (S : LeftPrincipalParameterReduction (B := B) (Abar := Abar))
91     (z : Abar) :
92     S.modParameter (zeroPreservingLift S z) = z := by
93   classical
94   by_cases hz : z = 0
95   · simp [zeroPreservingLift, hz]
96   · simpa [zeroPreservingLift, hz] using Classical.choose_spec (S.surjective z)
97 
98 @[simp]
99 theorem zeroPreservingLift_zero
100     (S : LeftPrincipalParameterReduction (B := B) (Abar := Abar)) :
101     zeroPreservingLift S 0 = 0 := by
102   classical
103   simp [zeroPreservingLift]
104 
105 /-- A zero-preserving written-order parameter cofactor. -/
106 def principalCofactor
107     (S : LeftPrincipalParameterReduction (B := B) (Abar := Abar))
108     (z : B) : B := by
109   classical
110   exact if hz : z = 0 then 0
111     else if hker : S.modParameter z = 0 then
112       Classical.choose ((S.kernel_left z).1 hker)
113     else 0
114 
115 theorem parameter_mul_principalCofactor
116     (S : LeftPrincipalParameterReduction (B := B) (Abar := Abar))
117     {z : B} (hz : S.modParameter z = 0) :
118     S.parameter * principalCofactor S z = z := by
119   classical
120   by_cases hzero : z = 0
121   · simp [principalCofactor, hzero]
122   · simp only [principalCofactor, hzero, hz, ↓reduceDIte]
123     exact Classical.choose_spec ((S.kernel_left z).1 hz)
124 
125 @[simp]
126 theorem principalCofactor_zero
127     (S : LeftPrincipalParameterReduction (B := B) (Abar := Abar)) :
128     principalCofactor S 0 = 0 := by
129   classical
130   simp [principalCofactor]
131 
132 end PrincipalReduction
133 
134 section MatrixAlgebra
135 
136 variable {B Abar K : Type u}
137 variable [Ring B] [CommRing Abar] [Field K]
138 variable {n : ℕ}
139 
140 /-- Entrywise scalar commutator, in the order used in equation (3.3). -/
141 def scalarMatrixCommutator
142     (x : B) (M : Matrix (Fin (n + 1)) (Fin (n + 1)) B) :
143     Matrix (Fin (n + 1)) (Fin (n + 1)) B :=
144   fun i j => x * M i j - M i j * x
145 
146 /-- Written-order matrix commutator over the deformation ring. -/
147 def sourceMatrixCommutator
148     (M N : Matrix (Fin (n + 1)) (Fin (n + 1)) B) :
149     Matrix (Fin (n + 1)) (Fin (n + 1)) B :=
150   M * N - N * M
151 
152 /-- Coefficientwise zero-preserving lift of a matrix. -/
153 def liftMatrix
154     (S : LeftPrincipalParameterReduction (B := B) (Abar := Abar))
155     (M : Matrix (Fin (n + 1)) (Fin (n + 1)) Abar) :
156     Matrix (Fin (n + 1)) (Fin (n + 1)) B :=
157   fun i j => zeroPreservingLift S (M i j)
158 
159 @[simp]
160 theorem liftMatrix_map
161     (S : LeftPrincipalParameterReduction (B := B) (Abar := Abar))
162     (M : Matrix (Fin (n + 1)) (Fin (n + 1)) Abar) :
163     (liftMatrix S M).map S.modParameter = M := by
164   ext i j
165   simp [liftMatrix, Matrix.map_apply]
166 
167 theorem liftMatrix_isStrictUpperTriangular
168     (S : LeftPrincipalParameterReduction (B := B) (Abar := Abar))
169     (M : Matrix (Fin (n + 1)) (Fin (n + 1)) Abar)
170     (hM : IsStrictUpperTriangularOver M) :
171     IsStrictUpperTriangularOver (liftMatrix S M) := by
172   intro i j hji
173   simp [liftMatrix, hM i j hji]
174 
175 /-- Entrywise parameter cofactor of a matrix whose reduction vanishes. -/
176 def factorMatrix
177     (S : LeftPrincipalParameterReduction (B := B) (Abar := Abar))
178     (M : Matrix (Fin (n + 1)) (Fin (n + 1)) B) :
179     Matrix (Fin (n + 1)) (Fin (n + 1)) B :=
180   fun i j => principalCofactor S (M i j)
181 
182 theorem parameter_mul_factorMatrix
183     (S : LeftPrincipalParameterReduction (B := B) (Abar := Abar))
184     (M : Matrix (Fin (n + 1)) (Fin (n + 1)) B)
185     (hM : M.map S.modParameter = 0) :
186     ∀ i j, S.parameter * factorMatrix S M i j = M i j := by
187   intro i j
188   apply parameter_mul_principalCofactor S
189   have hij := congrArg (fun Q => Q i j) hM
190   simpa [Matrix.map_apply] using hij
191 
192 theorem factorMatrix_isStrictUpperTriangular
193     (S : LeftPrincipalParameterReduction (B := B) (Abar := Abar))
194     (M : Matrix (Fin (n + 1)) (Fin (n + 1)) B)
195     (hM : IsStrictUpperTriangularOver M) :
196     IsStrictUpperTriangularOver (factorMatrix S M) := by
197   intro i j hji
198   simp [factorMatrix, hM i j hji]
199 
200 theorem scalarMatrixCommutator_map_eq_zero
201     (S : LeftPrincipalParameterReduction (B := B) (Abar := Abar))
202     (x : B) (M : Matrix (Fin (n + 1)) (Fin (n + 1)) B) :
203     (scalarMatrixCommutator x M).map S.modParameter = 0 := by
204   ext i j
205   simp [scalarMatrixCommutator, Matrix.map_apply, mul_comm]
206 
207 theorem scalarMatrixCommutator_isStrictUpperTriangular
208     (x : B) (M : Matrix (Fin (n + 1)) (Fin (n + 1)) B)
209     (hM : IsStrictUpperTriangularOver M) :
210     IsStrictUpperTriangularOver (scalarMatrixCommutator x M) := by
211   intro i j hji
212   simp [scalarMatrixCommutator, hM i j hji]
213 
214 theorem mul_isStrictUpperTriangular
215     (M N : Matrix (Fin (n + 1)) (Fin (n + 1)) B)
216     (hM : IsStrictUpperTriangularOver M)
217     (hN : IsStrictUpperTriangularOver N) :
218     IsStrictUpperTriangularOver (M * N) := by
219   intro i j hji
220   rw [Matrix.mul_apply]
221   apply Finset.sum_eq_zero
222   intro a _ha
223   rcases le_total a i with hai | hia
224   · rw [hM i a hai, zero_mul]
225   · rw [hN a j (hji.trans hia), mul_zero]
226 
227 theorem sourceMatrixCommutator_isStrictUpperTriangular
228     (M N : Matrix (Fin (n + 1)) (Fin (n + 1)) B)
229     (hM : IsStrictUpperTriangularOver M)
230     (hN : IsStrictUpperTriangularOver N) :
231     IsStrictUpperTriangularOver (sourceMatrixCommutator M N) := by
232   intro i j hji
233   simp [sourceMatrixCommutator,
234     mul_isStrictUpperTriangular M N hM hN i j hji,
235     mul_isStrictUpperTriangular N M hN hM i j hji]
236 
237 theorem sourceMatrixCommutator_map_eq_zero
238     (S : LeftPrincipalParameterReduction (B := B) (Abar := Abar))
239     (M N : Matrix (Fin (n + 1)) (Fin (n + 1)) B)
240     (hcomm : M.map S.modParameter * N.map S.modParameter =
241       N.map S.modParameter * M.map S.modParameter) :
242     (sourceMatrixCommutator M N).map S.modParameter = 0 := by
243   ext i j
244   have hij := congrArg (fun Q => Q i j) hcomm
245   change S.modParameter ((M * N) i j - (N * M) i j) = 0
246   rw [S.modParameter.map_sub, Matrix.mul_apply, Matrix.mul_apply]
247   simp only [map_sum, S.modParameter.map_mul]
248   simpa [Matrix.mul_apply, Matrix.map_apply] using sub_eq_zero.mpr hij
249 
250 /-- Although matrix multiplication need not commute after reduction, the
251 trace of a reduced matrix commutator vanishes over the commutative special
252 fibre. -/
253 theorem sourceMatrixCommutator_map_trace_eq_zero
254     (S : LeftPrincipalParameterReduction (B := B) (Abar := Abar))
255     (M N : Matrix (Fin (n + 1)) (Fin (n + 1)) B) :
256     Matrix.trace ((sourceMatrixCommutator M N).map S.modParameter) = 0 := by
257   have hmap : (sourceMatrixCommutator M N).map S.modParameter =
258       M.map S.modParameter * N.map S.modParameter -
259         N.map S.modParameter * M.map S.modParameter := by
260     ext i j
261     simp [sourceMatrixCommutator, Matrix.map_apply, Matrix.mul_apply]
262   rw [hmap, Matrix.trace_sub, Matrix.trace_mul_comm, sub_self]
263 
264 /-- The five cofactors retained from the primary-source calculation: three
265 strict matrix cofactors and two scalar trace cofactors. -/
266 structure Equation33Cofactors
267     (S : LeftPrincipalParameterReduction (B := B) (Abar := Abar))
268     (x y : B)
269     (A Bm Gamma Theta : Matrix (Fin (n + 1)) (Fin (n + 1)) B) where
270   X : Matrix (Fin (n + 1)) (Fin (n + 1)) B
271   Y : Matrix (Fin (n + 1)) (Fin (n + 1)) B
272   Omega : Matrix (Fin (n + 1)) (Fin (n + 1)) B
273   tauThetaA : B
274   tauBGamma : B
275   xB_eq : ∀ i j, S.parameter * X i j = scalarMatrixCommutator x Bm i j
276   yA_eq : ∀ i j, S.parameter * Y i j = scalarMatrixCommutator y A i j
277   BA_eq : ∀ i j,
278     S.parameter * Omega i j = sourceMatrixCommutator Bm A i j
279   X_strict : IsStrictUpperTriangularOver X
280   Y_strict : IsStrictUpperTriangularOver Y
281   Omega_strict : IsStrictUpperTriangularOver Omega
282   trace_ThetaA_eq :
283     S.parameter * tauThetaA = Matrix.trace (sourceMatrixCommutator Theta A)
284   trace_BGamma_eq :
285     S.parameter * tauBGamma = Matrix.trace (sourceMatrixCommutator Bm Gamma)
286 
287 /-- The source cofactors are constructed, not assumed. -/
288 def equation33Cofactors
289     (S : LeftPrincipalParameterReduction (B := B) (Abar := Abar))
290     (x y : B)
291     (A Bm Gamma Theta : Matrix (Fin (n + 1)) (Fin (n + 1)) B)
292     (hA : IsStrictUpperTriangularOver A)
293     (hB : IsStrictUpperTriangularOver Bm)
294     (hBAcomm : Bm.map S.modParameter * A.map S.modParameter =
295       A.map S.modParameter * Bm.map S.modParameter) :
296     Equation33Cofactors S x y A Bm Gamma Theta := by
297   let X := factorMatrix S (scalarMatrixCommutator x Bm)
298   let Y := factorMatrix S (scalarMatrixCommutator y A)
299   let Omega := factorMatrix S (sourceMatrixCommutator Bm A)
300   let tauThetaA := principalCofactor S
301     (Matrix.trace (sourceMatrixCommutator Theta A))
302   let tauBGamma := principalCofactor S
303     (Matrix.trace (sourceMatrixCommutator Bm Gamma))
304   refine
305     { X := X
306       Y := Y
307       Omega := Omega
308       tauThetaA := tauThetaA
309       tauBGamma := tauBGamma
310       xB_eq := parameter_mul_factorMatrix S _
311         (scalarMatrixCommutator_map_eq_zero S x Bm)
312       yA_eq := parameter_mul_factorMatrix S _
313         (scalarMatrixCommutator_map_eq_zero S y A)
314       BA_eq := parameter_mul_factorMatrix S _
315         (sourceMatrixCommutator_map_eq_zero S Bm A hBAcomm)
316       X_strict := factorMatrix_isStrictUpperTriangular S _
317         (scalarMatrixCommutator_isStrictUpperTriangular x Bm hB)
318       Y_strict := factorMatrix_isStrictUpperTriangular S _
319         (scalarMatrixCommutator_isStrictUpperTriangular y A hA)
320       Omega_strict := factorMatrix_isStrictUpperTriangular S _
321         (sourceMatrixCommutator_isStrictUpperTriangular Bm A hB hA)
322       trace_ThetaA_eq := ?_
323       trace_BGamma_eq := ?_ }
324   · apply parameter_mul_principalCofactor S
325     calc
326       S.modParameter (Matrix.trace (sourceMatrixCommutator Theta A)) =
327           Matrix.trace ((sourceMatrixCommutator Theta A).map S.modParameter) := by
328             simpa using
329               (AddMonoidHom.map_trace S.modParameter.toAddMonoidHom
330                 (sourceMatrixCommutator Theta A))
331       _ = 0 := sourceMatrixCommutator_map_trace_eq_zero S Theta A
332   · apply parameter_mul_principalCofactor S
333     calc
334       S.modParameter (Matrix.trace (sourceMatrixCommutator Bm Gamma)) =
335           Matrix.trace ((sourceMatrixCommutator Bm Gamma).map S.modParameter) := by
336             simpa using
337               (AddMonoidHom.map_trace S.modParameter.toAddMonoidHom
338                 (sourceMatrixCommutator Bm Gamma))
339       _ = 0 := sourceMatrixCommutator_map_trace_eq_zero S Bm Gamma
340 
341 /-- The strict remainder `R = X - Y + Omega` from equation (3.3). -/
342 def sourceStrictRemainder
343     {S : LeftPrincipalParameterReduction (B := B) (Abar := Abar)}
344     {x y : B} {A Bm Gamma Theta : Matrix (Fin (n + 1)) (Fin (n + 1)) B}
345     (C : Equation33Cofactors S x y A Bm Gamma Theta) :
346     Matrix (Fin (n + 1)) (Fin (n + 1)) B :=
347   C.X - C.Y + C.Omega
348 
349 theorem sourceStrictRemainder_isStrictUpperTriangular
350     {S : LeftPrincipalParameterReduction (B := B) (Abar := Abar)}
351     {x y : B} {A Bm Gamma Theta : Matrix (Fin (n + 1)) (Fin (n + 1)) B}
352     (C : Equation33Cofactors S x y A Bm Gamma Theta) :
353     IsStrictUpperTriangularOver (sourceStrictRemainder C) := by
354   intro i j hji
355   simp [sourceStrictRemainder, C.X_strict i j hji,
356     C.Y_strict i j hji, C.Omega_strict i j hji]
357 
358 /-- The two correction matrices `Q1=[Theta,A]` and `Q2=[B,Gamma]`. -/
359 def sourceCorrectionThetaA
360     (Theta A : Matrix (Fin (n + 1)) (Fin (n + 1)) B) :=
361   sourceMatrixCommutator Theta A
362 
363 def sourceCorrectionBGamma
364     (Bm Gamma : Matrix (Fin (n + 1)) (Fin (n + 1)) B) :=
365   sourceMatrixCommutator Bm Gamma
366 
367 theorem correctionThetaA_traceInParameter
368     {S : LeftPrincipalParameterReduction (B := B) (Abar := Abar)}
369     {x y : B} {A Bm Gamma Theta : Matrix (Fin (n + 1)) (Fin (n + 1)) B}
370     (C : Equation33Cofactors S x y A Bm Gamma Theta) :
371     CorrectionTraceInParameter S.toParameterIdealReduction
372       (sourceCorrectionThetaA Theta A) := by
373   rw [CorrectionTraceInParameter, Ideal.mem_span_singleton']
374   exact ⟨C.tauThetaA,
375     (S.parameter_comm C.tauThetaA).symm.trans C.trace_ThetaA_eq⟩
376 
377 theorem correctionBGamma_traceInParameter
378     {S : LeftPrincipalParameterReduction (B := B) (Abar := Abar)}
379     {x y : B} {A Bm Gamma Theta : Matrix (Fin (n + 1)) (Fin (n + 1)) B}
380     (C : Equation33Cofactors S x y A Bm Gamma Theta) :
381     CorrectionTraceInParameter S.toParameterIdealReduction
382       (sourceCorrectionBGamma Bm Gamma) := by
383   rw [CorrectionTraceInParameter, Ideal.mem_span_singleton']
384   exact ⟨C.tauBGamma,
385     (S.parameter_comm C.tauBGamma).symm.trans C.trace_BGamma_eq⟩
386 
387 /-- Literal trace-zero conclusion for the matrix produced by the source
388 cofactors.  This consumes the faithful equation-(3.3) trace reducer, not the
389 stronger same-size coefficient-field commutator surrogate. -/
390 theorem sourceReducedEquation33Matrix_trace_eq_zero
391     (S : LeftPrincipalParameterReduction (B := B) (Abar := Abar))
392     (residue : Abar →+* K)
393     (x y : B)
394     (A Bm Gamma Theta : Matrix (Fin (n + 1)) (Fin (n + 1)) B)
395     (hA : IsStrictUpperTriangularOver A)
396     (hB : IsStrictUpperTriangularOver Bm)
397     (hBAcomm : Bm.map S.modParameter * A.map S.modParameter =
398       A.map S.modParameter * Bm.map S.modParameter) :
399     Matrix.trace
400       (reducedEquation33Matrix S.toParameterIdealReduction residue
401         (sourceStrictRemainder
402           (equation33Cofactors S x y A Bm Gamma Theta hA hB hBAcomm))
403         (sourceCorrectionThetaA Theta A)
404         (sourceCorrectionBGamma Bm Gamma)) = 0 := by
405   let C := equation33Cofactors S x y A Bm Gamma Theta hA hB hBAcomm
406   exact reducedEquation33Matrix_trace_eq_zero
407     S.toParameterIdealReduction residue
408       (sourceStrictRemainder C)
409       (sourceCorrectionThetaA Theta A)
410       (sourceCorrectionBGamma Bm Gamma)
411       (sourceStrictRemainder_isStrictUpperTriangular C)
412       (correctionThetaA_traceInParameter C)
413       (correctionBGamma_traceInParameter C)
414 
415 end MatrixAlgebra
416 
417 section AdaptedActionMatrices
418 
419 variable {K R V B : Type u}
420 variable [Field K] [CommRing R] [Algebra K R] [IsLocalRing R]
421 variable [IsArtinianRing R]
422 variable [AddCommGroup V] [Module K V] [Module R V] [IsScalarTower K R V]
423 variable [FiniteDimensional K V]
424 variable [Ring B]
425 variable {n : ℕ}
426 
427 local notation "m" => IsLocalRing.maximalIdeal R
428 
429 /-- The literal matrix of multiplication by a special-fibre element.  This is
430 the operator that equation (3.3) must identify when the element is the
431 bracket cofactor `z`. -/
432 def inducedSpecialFibreActionMatrix
433     (b : Module.Basis (Fin (n + 1)) K V) (zbar : R) :
434     Matrix (Fin (n + 1)) (Fin (n + 1)) K :=
435   LinearMap.toMatrix b b
436     (leftMultiplicationEnd (K := K) (V := V) zbar)
437 
438 /-- The source uses row vectors, whereas `LinearMap.toMatrix` uses the usual
439 column convention.  Transposition is therefore part of the literal
440 source-to-Lean adapter. -/
441 def inducedSpecialFibreSourceMatrix
442     (b : Module.Basis (Fin (n + 1)) K V) (zbar : R) :
443     Matrix (Fin (n + 1)) (Fin (n + 1)) K :=
444   (inducedSpecialFibreActionMatrix b zbar)ᵀ
445 
446 /-- Actual zeroth-order adapted-basis action matrices in Lean's column
447 convention, with strict zero-preserving lifts to the deformation ring.  The
448 returned lifts `x` and `y` specialize to the requested elements.  Passing to
449 the source's row convention requires the explicit transpose adapter above. -/
450 theorem exists_lifted_adapted_actionMatrices
451     (S : LeftPrincipalParameterReduction (B := B) (Abar := R))
452     (hdim : Module.finrank K V = n + 1)
453     (xbar ybar : R) (hx : xbar ∈ m) (hy : ybar ∈ m) :
454     ∃ (b : Module.Basis (Fin (n + 1)) K V)
455       (level : Fin (n + 1) → ℕ)
456       (x y : B)
457       (A Bm : Matrix (Fin (n + 1)) (Fin (n + 1)) B),
458       IsMaximalIdealFiltrationAdapted m b level ∧
459       S.modParameter x = xbar ∧
460       S.modParameter y = ybar ∧
461       A.map S.modParameter =
462         (LinearMap.toMatrix b b
463           (leftMultiplicationEnd (K := K) (V := V) xbar)).map
464             (algebraMap K R) ∧
465       Bm.map S.modParameter =
466         (LinearMap.toMatrix b b
467           (leftMultiplicationEnd (K := K) (V := V) ybar)).map
468             (algebraMap K R) ∧
469       IsStrictUpperTriangularOver A ∧
470       IsStrictUpperTriangularOver Bm ∧
471       Bm.map S.modParameter * A.map S.modParameter =
472         A.map S.modParameter * Bm.map S.modParameter := by
473   obtain ⟨b, level, hadapted⟩ :=
474     exists_maximalIdealFiltrationAdaptedBasis (K := K) (R := R) (V := V) hdim
475   let Ax := leftMultiplicationEnd (K := K) (V := V) xbar
476   let By := leftMultiplicationEnd (K := K) (V := V) ybar
477   let A0K := LinearMap.toMatrix b b Ax
478   let B0K := LinearMap.toMatrix b b By
479   let A0 := A0K.map (algebraMap K R)
480   let B0 := B0K.map (algebraMap K R)
481   let A := liftMatrix S A0
482   let Bm := liftMatrix S B0
483   let x := zeroPreservingLift S xbar
484   let y := zeroPreservingLift S ybar
485   have hA0K : IsStrictUpperTriangularOver A0K :=
486     leftMultiplicationMatrix_isStrictUpperTriangular b level hadapted hx
487   have hB0K : IsStrictUpperTriangularOver B0K :=
488     leftMultiplicationMatrix_isStrictUpperTriangular b level hadapted hy
489   have hA0 : IsStrictUpperTriangularOver A0 :=
490     fun i j hji => by simp [A0, Matrix.map_apply, hA0K i j hji]
491   have hB0 : IsStrictUpperTriangularOver B0 :=
492     fun i j hji => by simp [B0, Matrix.map_apply, hB0K i j hji]
493   have hEnd : By * Ax = Ax * By := by
494     ext v
495     change ybar • xbar • v = xbar • ybar • v
496     rw [← mul_smul, ← mul_smul, mul_comm]
497   have hK : B0K * A0K = A0K * B0K := by
498     rw [← LinearMap.toMatrix_mul, ← LinearMap.toMatrix_mul, hEnd]
499   have hcomm : B0 * A0 = A0 * B0 := by
500     change B0K.map (algebraMap K R) * A0K.map (algebraMap K R) =
501       A0K.map (algebraMap K R) * B0K.map (algebraMap K R)
502     rw [← Matrix.map_mul, ← Matrix.map_mul, hK]
503   exact ⟨b, level, x, y, A, Bm, hadapted,
504     modParameter_zeroPreservingLift S xbar,
505     modParameter_zeroPreservingLift S ybar,
506     liftMatrix_map S A0,
507     liftMatrix_map S B0,
508     liftMatrix_isStrictUpperTriangular S A0 hA0,
509     liftMatrix_isStrictUpperTriangular S B0 hB0, by
510       rw [liftMatrix_map, liftMatrix_map]
511       exact hcomm⟩
512 
513 end AdaptedActionMatrices
514 
515 section ConcreteReduction
516 
517 variable (k : Type u) [Field k]
518 variable {n : ℕ}
519 variable (I : RightIdeal (PresentedWeyl k n))
520 variable (S : Submonoid (SymbolRing k n))
521 variable [OreLocalization.OreSet
522   (OppositeDenominators (filteredQuotientTwoJetTraceData k I) S)]
523 variable [IsLocalRing (Localization S)]
524 
525 abbrev concreteData := filteredQuotientTwoJetTraceData k I
526 
527 local notation "D" => concreteData k I
528 
529 /-- The concrete localized two-block quotient has exactly the principal
530 parameter reduction required by the source matrix construction. -/
531 def concreteLeftPrincipalParameterReduction (q : ℕ) :
532     LeftPrincipalParameterReduction
533       (B := LocalizedTwoBlockRing D S q)
534       (Abar := (Localization S) ⧸ localizedDoubledPower S q) where
535   parameter := concreteLocalizedTwoBlockParameter k I S q
536   modParameter := localizedTwoBlockSpecialization D S q
537   surjective := localizedTwoBlockSpecialization_surjective D S q
538   parameter_comm := by
539     intro z
540     induction z using Quotient.inductionOn' with
541     | _ a =>
542       change
543         (localizedTwoBlockIdeal D S q).ringCon.mk'
544             (OreLocalization.numeratorRingHom
545               (MulOpposite.op (orderReesTwoJetParameter (n := n) k))) *
546           (localizedTwoBlockIdeal D S q).ringCon.mk' a = _
547       calc
548         (localizedTwoBlockIdeal D S q).ringCon.mk'
549               (OreLocalization.numeratorRingHom
550                 (MulOpposite.op (orderReesTwoJetParameter (n := n) k))) *
551             (localizedTwoBlockIdeal D S q).ringCon.mk' a =
552           (localizedTwoBlockIdeal D S q).ringCon.mk'
553             (OreLocalization.numeratorRingHom
554               (MulOpposite.op (orderReesTwoJetParameter (n := n) k)) * a) := by
555                 exact ((localizedTwoBlockIdeal D S q).ringCon.mk').map_mul _ _ |>.symm
556         _ = (localizedTwoBlockIdeal D S q).ringCon.mk'
557             (a * OreLocalization.numeratorRingHom
558               (MulOpposite.op (orderReesTwoJetParameter (n := n) k))) := by
559                 exact congrArg ((localizedTwoBlockIdeal D S q).ringCon.mk')
560                   (localizedParameter_comm D S a)
561         _ = (localizedTwoBlockIdeal D S q).ringCon.mk' a *
562             (localizedTwoBlockIdeal D S q).ringCon.mk'
563               (OreLocalization.numeratorRingHom
564                 (MulOpposite.op (orderReesTwoJetParameter (n := n) k))) := by
565                 exact ((localizedTwoBlockIdeal D S q).ringCon.mk').map_mul _ _
566   kernel_left :=
567     concreteLocalizedTwoBlockSpecialization_eq_zero_iff_exists_parameter_mul
568       k I S q
569 
570 /-- The exact remaining source-specific bridge.  The left side is the actual
571 matrix of the operator induced by the bracket cofactor `z` on the coefficient
572 field special fibre.  The right side is the matrix already constructed from
573 the lifted adapted basis and all five explicit equation-(3.3) cofactors.
574 
575 No inhabitant is constructed here: proving this equality requires the lifted
576 basis-vector action equations in the concrete localized module.  In
577 particular, this definition is not a trace-zero theorem. -/
578 def ConcreteInducedZActionIdentity
579     {K V : Type u} [Field K]
580     [AddCommGroup V]
581     {q r : ℕ}
582     (parameterReduction : LeftPrincipalParameterReduction
583       (B := LocalizedTwoBlockRing D S q)
584       (Abar := (Localization S) ⧸ localizedDoubledPower S q))
585     (residue : ((Localization S) ⧸ localizedDoubledPower S q) →+* K)
586     [Algebra K ((Localization S) ⧸ localizedDoubledPower S q)]
587     [Module K V]
588     [Module ((Localization S) ⧸ localizedDoubledPower S q) V]
589     [IsScalarTower K ((Localization S) ⧸ localizedDoubledPower S q) V]
590     (b : Module.Basis (Fin (r + 1)) K V)
591     (zbar : (Localization S) ⧸ localizedDoubledPower S q)
592     (x y : LocalizedTwoBlockRing D S q)
593     (A Bm Gamma Theta :
594       Matrix (Fin (r + 1)) (Fin (r + 1)) (LocalizedTwoBlockRing D S q))
595     (hA : IsStrictUpperTriangularOver A)
596     (hB : IsStrictUpperTriangularOver Bm)
597     (hBAcomm : Bm.map parameterReduction.modParameter *
598         A.map parameterReduction.modParameter =
599       A.map parameterReduction.modParameter *
600         Bm.map parameterReduction.modParameter) : Prop :=
601   let C := equation33Cofactors parameterReduction x y A Bm Gamma Theta
602     hA hB hBAcomm
603   inducedSpecialFibreSourceMatrix b zbar =
604     reducedEquation33Matrix parameterReduction.toParameterIdealReduction residue
605       (sourceStrictRemainder C)
606       (sourceCorrectionThetaA Theta A)
607       (sourceCorrectionBGamma Bm Gamma)
608 
609 #print axioms LeftPrincipalParameterReduction.toParameterIdealReduction
610 #print axioms modParameter_zeroPreservingLift
611 #print axioms parameter_mul_principalCofactor
612 #print axioms liftMatrix_map
613 #print axioms mul_isStrictUpperTriangular
614 #print axioms equation33Cofactors
615 #print axioms sourceReducedEquation33Matrix_trace_eq_zero
616 #print axioms exists_lifted_adapted_actionMatrices
617 #print axioms concreteLeftPrincipalParameterReduction
618 
619 end ConcreteReduction
620 
621 end
622 
623 end Stafford38.Characteristic.ConcreteEquation33SourceMatrices
624