Stafford38/Geometry/PaperDivisorTangent.lean

This project (Stafford38) · 1029fdb382eee06e7b59bcf32801f40931e2079a

1 module
2 public import Stafford38.Geometry.GeneralTangentLimitCriterion
3 public import Stafford38.Geometry.FormalDivisorTangent
4 public import Stafford38.Geometry.FormalDivisorAxisLift
5 public import Mathlib.LinearAlgebra.Projection
6 
7 @[expose] public section
8 
9 /-!
10 # The manuscript's explicit divisor-tangent route
11 
12 The selected minor produces the correction and primitive normalization.
13 The order gap forces the distinguished residue row to vanish. The resulting
14 matrix has a left inverse, and the tangent-limit theorem produces the axis.
15 The geometric generic-span dictionary is an explicit premise: this file does
16 not assume that an arbitrary local parametrization supplies it automatically.
17 -/
18 
19 namespace Stafford38.Geometry.PaperDivisorTangent
20 
21 set_option autoImplicit false
22 
23 open Stafford38.GeometrySplitTangentMatrix
24 open Stafford38.GeometryFormalDivisorTangent
25 open Stafford38.GeometryResidueMinorSelection
26 open Stafford38.Geometry.GeneralTangentLimitCriterion
27 open Stafford38.Geometry.GeneralTangentLatticePresentation
28 open Stafford38.Geometry.AffineConormalSpan
29 open Stafford38.Geometry.AffineConormalClosure
30 open Stafford38.Geometry.ConormalScalarExtensionVanishing
31 open Stafford38.Geometry.FormalDivisorLaurentConormal
32 open Stafford38.Geometry.LaurentConormalDirection
33 open Stafford38.Geometry.SmoothConormalFibreVanishing
34 open Stafford38.Characteristic
35 open Stafford38.Geometry.ProjectiveConormalDehomogenization
36 open Stafford38.Geometry.ProjectiveConormalDirections
37 open Stafford38.Geometry.ProjectiveTangentInclusion
38 open Stafford38.Geometry.ScalarExtensionPoints
39 open Stafford38.Geometry.SmoothAffineConormal
40 open Stafford38.GeometryPowerSeriesTangentLimit
41 open Stafford38.GeometryRetractionSpecialization
42 
43 noncomputable section
44 variable {k : Type*} [Field k] [CharZero k]
45 
46 omit [CharZero k] in
47 /-- The paper's order gap makes the corrected normalized transverse tangent
48 vanish in the axis row. This is derived, not assumed as an output condition. -/
49 lemma normalized_axis_constantCoeff_eq_zero
50     {ι κ : Type*} [Fintype κ]
51     (q : ι → PowerSeries k) (Z : Matrix ι κ (PowerSeries k))
52     (lambda : κ → PowerSeries k) (tau : ι → PowerSeries k)
53     (axis : ι) (b c : ℕ) (u : PowerSeries k)
54     (hbc : c + 1 < b)
55     (hq : q axis = (PowerSeries.X : PowerSeries k) ^ b * u)
56     (hZ : ∀ j, ∃ w : PowerSeries k,
57       Z axis j = (PowerSeries.X : PowerSeries k) ^ b * w)
58     (hfactor : ∀ i, PowerSeries.derivative (R := k) (q i) - Z.mulVec lambda i =
59       (PowerSeries.X : PowerSeries k) ^ c * tau i) :
60     PowerSeries.constantCoeff (tau axis) = 0 := by
61   have hd : PowerSeries.coeff c (PowerSeries.derivative (R := k) (q axis)) = 0 := by
62     rw [PowerSeries.coeff_derivative, hq, PowerSeries.coeff_X_pow_mul']
63     simp [Nat.not_le_of_gt hbc]
64   have hz : PowerSeries.coeff c (Z.mulVec lambda axis) = 0 := by
65     change PowerSeries.coeff c (∑ j, Z axis j * lambda j) = 0
66     rw [map_sum]
67     apply Finset.sum_eq_zero
68     intro j _
69     obtain ⟨w, hw⟩ := hZ j
70     rw [hw, mul_assoc, PowerSeries.coeff_X_pow_mul']
71     simp [Nat.not_le_of_gt (by omega : c < b)]
72   have he := congrArg (PowerSeries.coeff c) (hfactor axis)
73   rw [map_sub, hd, hz, sub_zero] at he
74   simpa [PowerSeries.coeff_X_pow_mul', PowerSeries.coeff_zero_eq_constantCoeff_apply]
75     using he.symm
76 
77 /-- The local derivative/minor construction yields a normalized matrix with
78 an actual splitting and zero residue axis. Its rank properties are conclusions.
79 This follows the paper's correction and common-power normalization in order. -/
80 theorem exists_normalized_split_axis_matrix
81     {n : ℕ} {κ : Type*} [Fintype κ] [DecidableEq κ]
82     (q : Fin (n + 1) → PowerSeries k)
83     (Z : Matrix (Fin (n + 1)) κ (PowerSeries k))
84     (rows : κ ↪ Fin (n + 1)) (chart : Fin (n + 1))
85     (axis : Fin n) (a b : ℕ) (u₀ u₁ : PowerSeries k)
86     (hqchart : q chart = 1) (hZchart : ∀ j, Z chart j = 0)
87     (ha : 0 < a) (hab : a < b)
88     (hqzero : q 0 = (PowerSeries.X : PowerSeries k) ^ a * u₀)
89     (hu₀ : PowerSeries.constantCoeff u₀ ≠ 0)
90     (hqaxis : q axis.succ = (PowerSeries.X : PowerSeries k) ^ b * u₁)
91     (hZzero : ∀ j, ∃ w : PowerSeries k,
92       Z 0 j = (PowerSeries.X : PowerSeries k) ^ a * w)
93     (hZaxis : ∀ j, ∃ w : PowerSeries k,
94       Z axis.succ j = (PowerSeries.X : PowerSeries k) ^ b * w)
95     (hminor : PowerSeries.constantCoeff (selectedMinor Z rows).det ≠ 0) :
96     ∃ (lambda : κ → PowerSeries k) (c : ℕ)
97       (tau : Fin (n + 1) → PowerSeries k)
98       (C : Matrix (FormalTangentColumn κ) (Fin (n + 1)) (PowerSeries k)),
99       c ≤ a - 1 ∧
100       (∀ i, PowerSeries.derivative (R := k) (q i) - Z.mulVec lambda i =
101         (PowerSeries.X : PowerSeries k) ^ c * tau i) ∧
102       C * formalTangentMatrix q Z tau = 1 ∧
103       (∀ j, PowerSeries.constantCoeff (formalTangentMatrix q Z tau axis.succ j) = 0) := by
104   obtain ⟨lambda, c, tau, C, _, _, _, _, _, hc, hfactor, _, _,
105       haxiscolumns, hCB, _, _⟩ :=
106     Stafford38.GeometryFormalDivisorAxisLift.exists_formalDivisorAxisLift
107       q Z rows chart 0 axis.succ a b u₀ u₁ hqchart hZchart ha hab
108         hqzero hu₀ hZzero hqaxis hZaxis hminor
109   exact ⟨lambda, c, tau, C, hc, hfactor, hCB, haxiscolumns⟩
110 
111 /-! ## The actual power-series tangent lattice -/
112 
113 /-- The lattice generated by the columns of the normalized position/divisor/
114 transverse matrix. -/
115 def normalizedTangentLattice
116     {n : ℕ} {κ : Type*} [Fintype κ]
117     (q : Fin (n + 1) → PowerSeries k)
118     (Z : Matrix (Fin (n + 1)) κ (PowerSeries k))
119     (tau : Fin (n + 1) → PowerSeries k) :
120     Submodule (PowerSeries k) (Fin (n + 1) → PowerSeries k) :=
121   LinearMap.range (formalTangentMatrix q Z tau).mulVecLin
122 
123 omit [CharZero k] in
124 /-- A left inverse makes the actual column lattice a direct summand.  The
125 projector is the composite B C, whose idempotence follows from C B = 1. -/
126 lemma normalizedTangentLattice_isComplemented
127     {n : ℕ} {κ : Type*} [Fintype κ] [DecidableEq κ]
128     (q : Fin (n + 1) → PowerSeries k)
129     (Z : Matrix (Fin (n + 1)) κ (PowerSeries k))
130     (tau : Fin (n + 1) → PowerSeries k)
131     (C : Matrix (FormalTangentColumn κ) (Fin (n + 1)) (PowerSeries k))
132     (hCB : C * formalTangentMatrix q Z tau = 1) :
133     IsComplemented (normalizedTangentLattice q Z tau) := by
134   let B := formalTangentMatrix q Z tau
135   let E : (Fin (n + 1) → PowerSeries k) →ₗ[PowerSeries k]
136       (Fin (n + 1) → PowerSeries k) := B.mulVecLin.comp C.mulVecLin
137   have hCBlin : C.mulVecLin.comp B.mulVecLin = LinearMap.id := by
138     rw [← Matrix.mulVecLin_mul, hCB, Matrix.mulVecLin_one]
139   have hEidem : IsIdempotentElem E := by
140     change E.comp E = E
141     dsimp [E]
142     rw [LinearMap.comp_assoc, ← LinearMap.comp_assoc C.mulVecLin B.mulVecLin]
143     rw [hCBlin]
144     simp
145   have hproj : LinearMap.IsProj (LinearMap.range E) E :=
146     (LinearMap.isProj_range_iff_isIdempotentElem E).mpr hEidem
147   have hrange : LinearMap.range E = normalizedTangentLattice q Z tau := by
148     apply le_antisymm
149     · rintro x ⟨v, rfl⟩
150       exact ⟨C.mulVecLin v, rfl⟩
151     · rintro x ⟨v, rfl⟩
152       refine ⟨B.mulVecLin v, ?_⟩
153       change B.mulVecLin (C.mulVecLin (B.mulVecLin v)) =
154         B.mulVecLin v
155       have hfix : C.mulVecLin (B.mulVecLin v) = v := by
156         have h := congrArg (fun f : (FormalTangentColumn κ → PowerSeries k) →ₗ[
157             PowerSeries k] (FormalTangentColumn κ → PowerSeries k) => f v) hCBlin
158         simpa only [LinearMap.comp_apply, LinearMap.id_apply] using h
159       rw [hfix]
160   exact ⟨LinearMap.ker E, by simpa [hrange] using hproj.isCompl⟩
161 
162 omit [CharZero k] in
163 /-- The split tangent matrix has one independent column for each formal
164 tangent direction. -/
165 lemma normalizedTangentLattice_finrank
166     {n : ℕ} {κ : Type*} [Fintype κ] [DecidableEq κ]
167     (q : Fin (n + 1) → PowerSeries k)
168     (Z : Matrix (Fin (n + 1)) κ (PowerSeries k))
169     (tau : Fin (n + 1) → PowerSeries k)
170     (C : Matrix (FormalTangentColumn κ) (Fin (n + 1)) (PowerSeries k))
171     (hCB : C * formalTangentMatrix q Z tau = 1) :
172     Module.finrank (PowerSeries k)
173         (normalizedTangentLattice q Z tau) = Fintype.card (FormalTangentColumn κ) := by
174   have hCBlin : C.mulVecLin.comp (formalTangentMatrix q Z tau).mulVecLin =
175       LinearMap.id := by
176     rw [← Matrix.mulVecLin_mul, hCB, Matrix.mulVecLin_one]
177   have hinj : Function.Injective (formalTangentMatrix q Z tau).mulVecLin := by
178     intro x y hxy
179     have h := congrArg C.mulVecLin hxy
180     have h' : (C.mulVecLin.comp (formalTangentMatrix q Z tau).mulVecLin) x =
181         (C.mulVecLin.comp (formalTangentMatrix q Z tau).mulVecLin) y := by
182       simpa only [LinearMap.comp_apply] using h
183     rw [hCBlin] at h'
184     simpa using h'
185   rw [normalizedTangentLattice, LinearMap.finrank_range_of_inj hinj]
186   simp
187 
188 omit [CharZero k] in
189 /-- The order-gap conclusion controls every residue vector in the actual
190 column lattice, not merely the displayed generators. -/
191 lemma normalizedTangentLattice_residue_axis
192     {n : ℕ} {κ : Type*} [Fintype κ] [DecidableEq κ]
193     (q : Fin (n + 1) → PowerSeries k)
194     (Z : Matrix (Fin (n + 1)) κ (PowerSeries k))
195     (tau : Fin (n + 1) → PowerSeries k)
196     (axis : Fin n)
197     (haxis : ∀ j,
198       PowerSeries.constantCoeff
199         (formalTangentMatrix q Z tau axis.succ j) = 0) :
200     ∀ v : normalizedTangentLattice q Z tau,
201       PowerSeries.constantCoeff ((v : Fin (n + 1) → PowerSeries k) axis.succ) = 0 := by
202   intro v
203   obtain ⟨c, hc⟩ := v.property
204   rw [← hc]
205   change PowerSeries.constantCoeff
206       (∑ j, formalTangentMatrix q Z tau axis.succ j * c j) = 0
207   rw [map_sum]
208   apply Finset.sum_eq_zero
209   intro j hj
210   rw [map_mul, haxis]
211   simp
212 
213 /-! ## A one-sided tangent-limit criterion -/
214 
215 /-- From containment of the projective tangent cone in a column span, the
216 point belongs to that span and the affine Zariski tangent space is contained
217 in the dehomogenized column span. The reverse span containment is unnecessary
218 for the conormal argument. -/
219 theorem matrix_tangent_dictionary_of_projectiveCone_le_span
220     {K : Type*} [Field K] {n : ℕ} {κ : Type*} [Fintype κ]
221     (q : Fin (n + 1) → K) (hq0 : q 0 ≠ 0)
222     (T : Submodule K (Fin n → K))
223     (B : Matrix (Fin (n + 1)) κ K)
224     (hspan : projectiveTangentCone q T ≤
225       Submodule.span K (Set.range fun j => fun i => B i j)) :
226     (∃ c : κ → K, ∀ i, q i = ∑ j, B i j * c j) ∧
227       T ≤ dehomogenizedTangentSpan q B := by
228   let d := dehomogenizedTangentLinearMap q
229   let H := Submodule.span K (Set.range fun j => fun i => B i j)
230   have hqcone : q ∈ projectiveTangentCone q T := by
231     change dehomogenizedTangentColumn q q ∈ T
232     convert T.zero_mem using 1
233     ext i
234     simp [dehomogenizedTangentColumn]
235   have hqspan : q ∈ H := hspan hqcone
236   obtain ⟨c, hc⟩ := (Submodule.mem_span_range_iff_exists_fun K).mp hqspan
237   have hposition : ∃ c : κ → K, ∀ i, q i = ∑ j, B i j * c j := by
238     refine ⟨c, fun i => ?_⟩
239     have hi := congrFun hc.symm i
240     simpa [Finset.sum_apply, smul_eq_mul, mul_comm] using hi
241   have hmap : H.map d = dehomogenizedTangentSpan q B := by
242     rw [dehomogenizedTangentSpan, Submodule.map_span]
243     congr 1
244     ext v
245     simp only [Set.mem_image, Set.mem_range]
246     constructor
247     · rintro ⟨w, ⟨j, rfl⟩, rfl⟩
248       exact ⟨j, rfl⟩
249     · rintro ⟨j, rfl⟩
250       exact ⟨fun i => B i j, ⟨j, rfl⟩, rfl⟩
251   have hdsurj : Function.Surjective d := by
252     intro v
253     refine ⟨Fin.cases 0 (fun i => v i * q 0), ?_⟩
254     ext i
255     change (v i * q 0 * q 0 - q i.succ * 0) / q 0 ^ 2 = v i
256     field_simp
257     ring
258   have htangent : T ≤ dehomogenizedTangentSpan q B := by
259     intro v hv
260     obtain ⟨w, hw⟩ := hdsurj v
261     have hwcone : w ∈ projectiveTangentCone q T := by
262       change d w ∈ T
263       rw [hw]
264       exact hv
265     have hwH : w ∈ H := hspan hwcone
266     have hdH : d w ∈ H.map d := ⟨w, hwH, rfl⟩
267     rw [hmap] at hdH
268     simpa [hw] using hdH
269   exact ⟨hposition, htangent⟩
270 
271 /-- If the point is in a column span and its affine tangent space is in the
272 dehomogenized column span, then the full projective tangent cone is in the
273 original column span. The only extra direction in the kernel of chart
274 dehomogenization is the radial point direction. -/
275 theorem projectiveTangentCone_le_span_of_position_and_tangent
276     {K : Type*} [Field K] {n : ℕ} {κ : Type*}
277     (q : Fin (n + 1) → K) (hq0 : q 0 ≠ 0)
278     (T : Submodule K (Fin n → K))
279     (B : Matrix (Fin (n + 1)) κ K)
280     (hqspan : q ∈ Submodule.span K (Set.range fun j => fun i => B i j))
281     (htangent : T ≤ dehomogenizedTangentSpan q B) :
282     projectiveTangentCone q T ≤
283       Submodule.span K (Set.range fun j => fun i => B i j) := by
284   let d := dehomogenizedTangentLinearMap q
285   let H := Submodule.span K (Set.range fun j => fun i => B i j)
286   have hmap : H.map d = dehomogenizedTangentSpan q B := by
287     rw [dehomogenizedTangentSpan, Submodule.map_span]
288     congr 1
289     ext v
290     simp only [Set.mem_image, Set.mem_range]
291     constructor
292     · rintro ⟨w, ⟨j, rfl⟩, rfl⟩
293       exact ⟨j, rfl⟩
294     · rintro ⟨j, rfl⟩
295       exact ⟨fun i => B i j, ⟨j, rfl⟩, rfl⟩
296   intro x hx
297   have hdx : d x ∈ T := hx
298   have hdxspan : d x ∈ H.map d := by
299     rw [hmap]
300     exact htangent hdx
301   rcases hdxspan with ⟨y, hy, hdy⟩
302   let c : K := (x 0 - y 0) / q 0
303   have hkernel : x - y = c • q := by
304     ext i
305     refine Fin.cases ?_ (fun j => ?_) i
306     · dsimp [c]
307       field_simp [hq0]
308     · have hj := congrFun hdy.symm j
309       change dehomogenizedTangentColumn q x j =
310         dehomogenizedTangentColumn q y j at hj
311       simp [dehomogenizedTangentColumn] at hj
312       field_simp [hq0] at hj
313       dsimp [c]
314       field_simp [hq0]
315       linear_combination hj
316   have hxdecomp : x = y + c • q := by
317     have := congrArg (fun v : Fin (n + 1) → K => v + y) hkernel
318     simpa [add_comm] using this
319   have hxinH : x ∈ H := by
320     rw [hxdecomp]
321     exact H.add_mem hy (H.smul_mem c hqspan)
322   exact hxinH
323 
324 /-- The radial point direction and an exact affine tangent span determine the
325 full projective tangent cone. The inclusion uses the existing radial-kernel
326 comparison; the reverse inclusion follows from the column tangent equations. -/
327 theorem projectiveTangentCone_eq_span_of_position_and_tangent
328     {K : Type*} [Field K] {n : ℕ} {κ : Type*}
329     (q : Fin (n + 1) → K) (hq0 : q 0 ≠ 0)
330     (T : Submodule K (Fin n → K))
331     (B : Matrix (Fin (n + 1)) κ K)
332     (hqspan : q ∈ Submodule.span K (Set.range fun j => fun i => B i j))
333     (htangent : T = dehomogenizedTangentSpan q B) :
334     projectiveTangentCone q T =
335       Submodule.span K (Set.range fun j => fun i => B i j) := by
336   apply le_antisymm
337   · exact projectiveTangentCone_le_span_of_position_and_tangent
338       q hq0 T B hqspan htangent.le
339   · apply Submodule.span_le.mpr
340     rintro _ ⟨j, rfl⟩
341     change dehomogenizedTangentColumn q (fun i => B i j) ∈ T
342     rw [htangent]
343     exact Submodule.subset_span ⟨j, rfl⟩
344 
345 
346 omit [CharZero k] in
347 /-- The nonposition divisor and transverse columns are among the columns of
348 the full normalized tangent matrix. -/
349 lemma dehomogenizedTangentSpan_nonposition_le_full
350     {n : ℕ} {κ : Type*}
351     (q : Fin (n + 1) → PowerSeries k)
352     (Z : Matrix (Fin (n + 1)) κ (PowerSeries k))
353     (tau : Fin (n + 1) → PowerSeries k) :
354     dehomogenizedTangentSpan (laurentColumn q)
355         (laurentNonpositionTangentMatrix Z tau) ≤
356       dehomogenizedTangentSpan (laurentColumn q)
357         (fun i j ↦ algebraMap (PowerSeries k) (LaurentSeries k)
358           (formalTangentMatrix q Z tau i j)) := by
359   change Submodule.span (LaurentSeries k)
360       (Set.range fun j => dehomogenizedTangentColumn (laurentColumn q)
361         (fun i => laurentNonpositionTangentMatrix Z tau i j)) ≤
362     Submodule.span (LaurentSeries k)
363       (Set.range fun j => dehomogenizedTangentColumn (laurentColumn q)
364         (fun i => algebraMap (PowerSeries k) (LaurentSeries k)
365           (formalTangentMatrix q Z tau i j)))
366   apply Submodule.span_mono
367   rintro x ⟨j, rfl⟩
368   refine ⟨Sum.inr j, ?_⟩
369   ext i
370   rcases j with j | j <;>
371     simp [laurentNonpositionTangentMatrix, formalTangentMatrix]
372 
373 /-- Low-level split-matrix input for the original tangent-limit conclusion,
374 with only the tangent-space containment needed to construct the conormal. -/
375 structure TangentInclusionInput {n dimY : ℕ} {κ : Type*}
376     [Fintype κ] [DecidableEq κ]
377     (I : Ideal (MvPolynomial (Fin n) k))
378     (q : Fin (n + 1) → PowerSeries k)
379     (B : Matrix (Fin (n + 1)) κ (PowerSeries k)) where
380   axis : Fin n
381   C : Matrix κ (Fin (n + 1)) (PowerSeries k)
382   hprime : I.IsPrime
383   hsplit : C * B = 1
384   hrank : Fintype.card κ = dimY + 1
385   hq0 : q 0 ≠ 0
386   hbase : ∀ f ∈ I.map (scalarPolynomialMap
387       (k := k) (K := LaurentSeries k) (Fin n)),
388       MvPolynomial.eval (dehomogenizedPoint (laurentColumn q)) f = 0
389   hsmooth : SmoothAffinePoint
390       (I.map (scalarPolynomialMap
391         (k := k) (K := LaurentSeries k) (Fin n)))
392       (dehomogenizedPoint (laurentColumn q))
393   hposition : ∃ c : κ → LaurentSeries k, ∀ i,
394       laurentColumn q i = ∑ j, algebraMap (PowerSeries k) (LaurentSeries k)
395         (B i j) * c j
396   htangent : zariskiTangentSpace (dehomogenizedPoint (laurentColumn q))
397       (I.map (scalarPolynomialMap
398         (k := k) (K := LaurentSeries k) (Fin n))) ≤
399       dehomogenizedTangentSpan (laurentColumn q)
400         (fun i j ↦ algebraMap (PowerSeries k) (LaurentSeries k) (B i j))
401   haxis : ∀ j, PowerSeries.constantCoeff (B axis.succ j) = 0
402 
403 /-- Paper-facing data for the weaker criterion. Unlike the existing exact
404 `DirectSummandInput`, this requires only that the actual projective tangent
405 cone lie in the generic fibre of the supplied lattice. -/
406 structure DirectSummandInclusionInput {n dimY : ℕ}
407     (I : Ideal (MvPolynomial (Fin n) k))
408     (q : Fin (n + 1) → PowerSeries k)
409     (L : Submodule (PowerSeries k)
410       (Fin (n + 1) → PowerSeries k)) where
411   axis : Fin n
412   isComplemented : IsComplemented L
413   rank_eq : Module.finrank (PowerSeries k) L = dimY + 1
414   hprime : I.IsPrime
415   chart_nonzero : q 0 ≠ 0
416   arc_mem_closure : FormalProjectiveArcInClosure I q
417   generic_smooth : SmoothAffinePoint
418     (I.map (scalarPolynomialMap
419       (k := k) (K := LaurentSeries k) (Fin n)))
420     (dehomogenizedPoint (laurentColumn q))
421   genericTangentCone_le :
422     projectiveTangentCone (laurentColumn q)
423         (zariskiTangentSpace
424           (dehomogenizedPoint (laurentColumn q))
425           (I.map (scalarPolynomialMap
426             (k := k) (K := LaurentSeries k) (Fin n)))) ≤
427       genericFibre (K := LaurentSeries k) L
428   residue_le_coordinateHyperplane : ∀ v : L,
429     PowerSeries.constantCoeff ((v : Fin (n + 1) → PowerSeries k) axis.succ) = 0
430 
431 /-- The divisor-normalized matrix supplies every lattice-side field of the
432 paper-facing one-sided input. The projective tangent-cone containment remains
433 an explicit output of the geometric chart producer. -/
434 def directSummandInclusionInput_of_normalizedTangentMatrix
435     {n dimY : ℕ} {κ : Type*} [Fintype κ] [DecidableEq κ]
436     (I : Ideal (MvPolynomial (Fin n) k))
437     (q : Fin (n + 1) → PowerSeries k)
438     (Z : Matrix (Fin (n + 1)) κ (PowerSeries k))
439     (tau : Fin (n + 1) → PowerSeries k)
440     (axis : Fin n)
441     (C : Matrix (FormalTangentColumn κ) (Fin (n + 1)) (PowerSeries k))
442     (hchart : q 0 = 1)
443     (hCB : C * formalTangentMatrix q Z tau = 1)
444     (haxis : ∀ j,
445       PowerSeries.constantCoeff
446         (formalTangentMatrix q Z tau axis.succ j) = 0)
447     (hcard : Fintype.card (FormalTangentColumn κ) = dimY + 1)
448     (hprime : I.IsPrime)
449     (harc : FormalProjectiveArcInClosure I q)
450     (hsmooth : SmoothAffinePoint
451       (I.map (scalarPolynomialMap
452         (k := k) (K := LaurentSeries k) (Fin n)))
453       (dehomogenizedPoint (laurentColumn q)))
454     (hcone : projectiveTangentCone (laurentColumn q)
455         (zariskiTangentSpace
456           (dehomogenizedPoint (laurentColumn q))
457           (I.map (scalarPolynomialMap
458             (k := k) (K := LaurentSeries k) (Fin n)))) ≤
459       genericFibre (K := LaurentSeries k)
460         (normalizedTangentLattice q Z tau)) :
461     DirectSummandInclusionInput (dimY := dimY) I q
462       (normalizedTangentLattice q Z tau) := by
463   refine ⟨axis,
464     normalizedTangentLattice_isComplemented q Z tau C hCB,
465     ?_, hprime, ?_, harc, hsmooth, hcone,
466     normalizedTangentLattice_residue_axis q Z tau axis haxis⟩
467   · exact (normalizedTangentLattice_finrank q Z tau C hCB).trans hcard
468   · rw [hchart]
469     exact one_ne_zero
470 
471 
472 /-- An affine tangent-space inclusion for the divisor/transverse columns
473 produces the projective cone inclusion required by the one-sided criterion.
474 The position column supplies q itself, so the radial kernel of chart
475 dehomogenization is already in the lattice. -/
476 def directSummandInclusionInput_of_normalizedTangentMatrix_of_affineTangentInclusion
477     {n dimY : ℕ} {κ : Type*} [Fintype κ] [DecidableEq κ]
478     (I : Ideal (MvPolynomial (Fin n) k))
479     (q : Fin (n + 1) → PowerSeries k)
480     (Z : Matrix (Fin (n + 1)) κ (PowerSeries k))
481     (tau : Fin (n + 1) → PowerSeries k)
482     (axis : Fin n)
483     (C : Matrix (FormalTangentColumn κ) (Fin (n + 1)) (PowerSeries k))
484     (hchart : q 0 = 1)
485     (hCB : C * formalTangentMatrix q Z tau = 1)
486     (haxis : ∀ j,
487       PowerSeries.constantCoeff
488         (formalTangentMatrix q Z tau axis.succ j) = 0)
489     (hcard : Fintype.card (FormalTangentColumn κ) = dimY + 1)
490     (hprime : I.IsPrime)
491     (harc : FormalProjectiveArcInClosure I q)
492     (hsmooth : SmoothAffinePoint
493       (I.map (scalarPolynomialMap
494         (k := k) (K := LaurentSeries k) (Fin n)))
495       (dehomogenizedPoint (laurentColumn q)))
496     (htangent : zariskiTangentSpace (dehomogenizedPoint (laurentColumn q))
497         (I.map (scalarPolynomialMap
498           (k := k) (K := LaurentSeries k) (Fin n))) ≤
499       dehomogenizedTangentSpan (laurentColumn q)
500         (laurentNonpositionTangentMatrix Z tau)) :
501     DirectSummandInclusionInput (dimY := dimY) I q
502       (normalizedTangentLattice q Z tau) := by
503   let B := formalTangentMatrix q Z tau
504   let BL : Matrix (Fin (n + 1)) (FormalTangentColumn κ) (LaurentSeries k) :=
505     fun i j => algebraMap (PowerSeries k) (LaurentSeries k) (B i j)
506   have hspan : Submodule.span (PowerSeries k)
507       (Set.range fun j => fun i => B i j) =
508         normalizedTangentLattice q Z tau := by
509     change Submodule.span (PowerSeries k)
510         (Set.range fun j => fun i => B i j) = LinearMap.range B.mulVecLin
511     exact (Matrix.range_mulVecLin B).symm
512   have hgenericSpan :
513       genericFibre (K := LaurentSeries k)
514           (normalizedTangentLattice q Z tau) =
515         Submodule.span (LaurentSeries k)
516           (Set.range fun j => fun i => BL i j) :=
517     genericFibre_eq_span_matrixColumns _ B hspan
518   have hqspan : laurentColumn q ∈ Submodule.span (LaurentSeries k)
519       (Set.range fun j => fun i => BL i j) := by
520     apply Submodule.subset_span
521     refine ⟨Sum.inl (), ?_⟩
522     funext i
523     simp [BL, laurentColumn, B, formalTangentMatrix]
524   have htangentFull := htangent.trans
525     (dehomogenizedTangentSpan_nonposition_le_full q Z tau)
526   have hconeSpan := projectiveTangentCone_le_span_of_position_and_tangent
527     (laurentColumn q) (laurentColumn_ne_zero_of_ne_zero q (by
528       rw [hchart]
529       exact one_ne_zero))
530     (zariskiTangentSpace (dehomogenizedPoint (laurentColumn q))
531       (I.map (scalarPolynomialMap
532         (k := k) (K := LaurentSeries k) (Fin n))))
533     BL hqspan htangentFull
534   have hcone :
535       projectiveTangentCone (laurentColumn q)
536           (zariskiTangentSpace
537             (dehomogenizedPoint (laurentColumn q))
538             (I.map (scalarPolynomialMap
539               (k := k) (K := LaurentSeries k) (Fin n)))) ≤
540         genericFibre (K := LaurentSeries k)
541           (normalizedTangentLattice q Z tau) := by
542     rw [hgenericSpan]
543     exact hconeSpan
544   exact directSummandInclusionInput_of_normalizedTangentMatrix
545     I q Z tau axis C hchart hCB haxis hcard hprime harc hsmooth hcone
546 
547 omit [CharZero k] in
548 private lemma rowMul_zero_of_leftInverse_axis
549     {n : ℕ} {κ : Type*} [Fintype κ] [DecidableEq κ]
550     (B : Matrix (Fin (n + 1)) κ (PowerSeries k))
551     (C : Matrix κ (Fin (n + 1)) (PowerSeries k))
552     (axis : Fin (n + 1))
553     (hCB : C * B = 1)
554     (haxis : ∀ j, PowerSeries.constantCoeff (B axis j) = 0) :
555     ∃ ell : Fin (n + 1) → PowerSeries k,
556       rowMul ell B = 0 ∧
557         residueColumn ell = axisRow (k := k) axis := by
558   classical
559   let a₀ : Fin (n + 1) → k := axisRow (k := k) axis
560   let a : Fin (n + 1) → PowerSeries k := constantColumn a₀
561   have hres : residueColumn a = a₀ := residueColumn_constantColumn a₀
562   have hred : rowMul a₀
563       (fun i j ↦ PowerSeries.constantCoeff (B i j)) = 0 := by
564     funext j
565     simp [a₀, axisRow, rowMul, haxis j]
566   let ell : Fin (n + 1) → PowerSeries k := annihilatorLift a B C
567   have hell := powerSeries_annihilatorLift_spec a a₀ B C hCB hres hred
568   refine ⟨ell, ?_, ?_⟩
569   · exact hell.1
570   · simpa [ell, a₀] using hell.2
571 
572 omit [CharZero k] in
573 private lemma rowMul_laurent_of_rowMul
574     {n : ℕ} {κ : Type*} [Fintype κ]
575     (ell : Fin (n + 1) → PowerSeries k)
576     (B : Matrix (Fin (n + 1)) κ (PowerSeries k))
577     (h : rowMul ell B = 0) :
578     rowMul (laurentColumn ell)
579       (fun i j ↦ algebraMap (PowerSeries k) (LaurentSeries k) (B i j)) = 0 := by
580   funext j
581   have hj := congrFun h j
582   simpa [rowMul, laurentColumn, map_sum] using
583     congrArg (algebraMap (PowerSeries k) (LaurentSeries k)) hj
584 
585 /-- One-sided version of the split-matrix conormal consumer. It retains the
586 same residue, smoothness, and closure conclusions; only the tangent-space
587 dictionary is weakened to the containment used in the covector argument. -/
588 theorem exists_axis_laurent_smooth_conormal_direction_of_tangentInclusion
589     {n dimY : ℕ} {κ : Type*} [Fintype κ] [DecidableEq κ]
590     [IsAlgClosed k]
591     (I : Ideal (MvPolynomial (Fin n) k))
592     (q : Fin (n + 1) → PowerSeries k)
593     (B : Matrix (Fin (n + 1)) κ (PowerSeries k))
594     (D : TangentInclusionInput (dimY := dimY) I q B) :
595     ∃ ell : Fin (n + 1) → PowerSeries k,
596       rowMul ell B = 0 ∧
597       residueColumn ell = axisRow (k := k) D.axis.succ ∧
598       (let phase : PhaseVar n → LaurentSeries k :=
599         Sum.elim (dehomogenizedPoint (laurentColumn q))
600           (fun i ↦ algebraMap (PowerSeries k) (LaurentSeries k) (ell i.succ));
601        phase ∈ smoothEquationConormalLocus I ∧
602        residueColumn (fun i : Fin n ↦ ell i.succ) ∈
603          extensionFibreClosure (k := k) (K := LaurentSeries k)
604            (smoothEquationConormalLocus I) ∧
605        Projectivization.mk k
606            (fun i : Fin n => if i = D.axis then (1 : k) else 0)
607            (by
608              intro h
609              have hh := congrFun h D.axis
610              simp at hh) ∈
611          projectiveHomogeneousClosure
612            (projectivizedDirectionSet (smoothConormalDirectionSet I))) := by
613   obtain ⟨ell, hrow, hres⟩ := rowMul_zero_of_leftInverse_axis
614     B D.C D.axis.succ D.hsplit D.haxis
615   have hrowL := rowMul_laurent_of_rowMul ell B hrow
616   have hqL : ∑ i, laurentColumn ell i * laurentColumn q i = 0 := by
617     obtain ⟨c, hc⟩ := D.hposition
618     have hprod : ∑ i, laurentColumn ell i * laurentColumn q i =
619         ∑ j, (∑ i, laurentColumn ell i *
620           algebraMap (PowerSeries k) (LaurentSeries k) (B i j)) * c j := by
621       calc
622         ∑ i, laurentColumn ell i * laurentColumn q i =
623             ∑ i, laurentColumn ell i *
624               (∑ j, algebraMap (PowerSeries k) (LaurentSeries k)
625                 (B i j) * c j) := by
626                   apply Finset.sum_congr rfl
627                   intro i hi
628                   rw [hc i]
629         _ = ∑ i, ∑ j, laurentColumn ell i *
630               (algebraMap (PowerSeries k) (LaurentSeries k) (B i j) * c j) := by
631                 apply Finset.sum_congr rfl
632                 intro i hi
633                 rw [Finset.mul_sum]
634         _ = ∑ j, ∑ i, laurentColumn ell i *
635               (algebraMap (PowerSeries k) (LaurentSeries k) (B i j) * c j) :=
636                 Finset.sum_comm
637         _ = ∑ j, (∑ i, laurentColumn ell i *
638               algebraMap (PowerSeries k) (LaurentSeries k) (B i j)) * c j := by
639                 apply Finset.sum_congr rfl
640                 intro j hj
641                 rw [Finset.sum_mul]
642                 apply Finset.sum_congr rfl
643                 intro i hi
644                 ring
645     rw [hprod]
646     have hzero : ∀ j, (∑ i, laurentColumn ell i *
647           algebraMap (PowerSeries k) (LaurentSeries k) (B i j)) = 0 := by
648       intro j
649       exact congrFun hrowL j
650     change (∑ j, rowMul (laurentColumn ell)
651       (fun i l ↦ algebraMap (PowerSeries k) (LaurentSeries k) (B i l)) j * c j) = 0
652     rw [hrowL]
653     simp
654   have hphase :
655       Sum.elim (dehomogenizedPoint (laurentColumn q))
656           (fun i ↦ algebraMap (PowerSeries k) (LaurentSeries k) (ell i.succ)) ∈
657         equationConormalLocus
658           (I.map (scalarPolynomialMap
659             (k := k) (K := LaurentSeries k) (Fin n))) := by
660     exact phasePoint_mem_equationConormalLocus_of_zariski_le_span
661       (I.map (scalarPolynomialMap
662         (k := k) (K := LaurentSeries k) (Fin n)))
663       (laurentColumn q) (laurentColumn ell)
664       (fun i j ↦ algebraMap (PowerSeries k) (LaurentSeries k) (B i j))
665       (laurentColumn_ne_zero_of_ne_zero q D.hq0)
666       hqL hrowL D.hbase D.htangent
667   let phase : PhaseVar n → LaurentSeries k :=
668     Sum.elim (dehomogenizedPoint (laurentColumn q))
669       (fun i ↦ algebraMap (PowerSeries k) (LaurentSeries k) (ell i.succ))
670   have hphaseSmooth : phase ∈ smoothEquationConormalLocus I :=
671     ⟨hphase, D.hsmooth⟩
672   have hclosure := residue_mem_extensionFibreClosure_of_laurent_generic
673     (S := smoothEquationConormalLocus I)
674     (dehomogenizedPoint (laurentColumn q))
675     (fun i : Fin n ↦ ell i.succ) hphaseSmooth
676   let axisVec : Fin n → k := fun i => if i = D.axis then 1 else 0
677   have hresTail : residueColumn (fun i : Fin n ↦ ell i.succ) = axisVec := by
678     funext i
679     have hi := congrFun hres i.succ
680     simpa [residueColumn, axisRow, axisVec] using hi
681   have hvanAxis : axisVec ∈
682       MvPolynomial.zeroLocus k
683         (MvPolynomial.vanishingIdeal k (smoothConormalFibreProjection I)) := by
684     rw [MvPolynomial.mem_zeroLocus_iff]
685     intro P hP
686     have hf : fibreLift P ∈
687         MvPolynomial.vanishingIdeal k (equationConormalLocus I) :=
688       fibreLift_mem_vanishingIdeal_equationConormal I D.hprime P hP
689     have hPext : P ∈ extensionValuedVanishingIdeal
690         (k := k) (K := LaurentSeries k)
691         (fibreImage (smoothEquationConormalLocus I)) := by
692       rw [mem_extensionValuedVanishingIdeal_iff]
693       intro v hv
694       rcases hv with ⟨z, hz, rfl⟩
695       have hs := scalarExtension_vanishing I (fibreLift P) (by
696         simpa [fibreLift, MvPolynomial.eval_rename, Function.comp_def] using hf)
697         z hz.1
698       have hsplit :
699           Sum.elim (fun i ↦ z (Sum.inl i)) (fun i ↦ z (Sum.inr i)) = z := by
700         funext i
701         rcases i with i | i <;> rfl
702       rw [← hsplit] at hs
703       simpa [eval₂_fibreLift] using hs
704     have hz := hclosure P hPext
705     rw [hresTail] at hz
706     simpa [MvPolynomial.aeval_eq_eval] using hz
707   have hproj := mk_mem_projectiveHomogeneousClosure_of_fibre_zeroLocus
708     I axisVec (by
709       intro h
710       have hh := congrFun h D.axis
711       simp [axisVec] at hh) hvanAxis
712   exact ⟨ell, hrow, hres,
713     ⟨hphaseSmooth, hclosure, by simpa [axisVec] using hproj⟩⟩
714 
715 /-- Paper-level tangent-limit criterion under the one-sided tangent-cone
716 containment. The split matrix presentation is built from the actual
717 complemented lattice, and its point/tangent dictionary is derived from that
718 containment. -/
719 theorem tangent_limit_criterion_of_directSummand_inclusion
720     {n dimY : ℕ} [IsAlgClosed k]
721     (I : Ideal (MvPolynomial (Fin n) k))
722     (q : Fin (n + 1) → PowerSeries k)
723     (L : Submodule (PowerSeries k)
724       (Fin (n + 1) → PowerSeries k))
725     (D : DirectSummandInclusionInput (dimY := dimY) I q L) :
726     Projectivization.mk k
727         (fun i : Fin n => if i = D.axis then (1 : k) else 0)
728         (by
729           intro h
730           have hh := congrFun h D.axis
731           simp at hh) ∈
732       projectiveHomogeneousClosure
733         (projectivizedDirectionSet (smoothConormalDirectionSet I)) := by
734   obtain ⟨P⟩ := exists_splitMatrixPresentation_of_isComplemented
735     L D.isComplemented (dimY + 1) D.rank_eq
736   let B : Matrix (Fin (n + 1)) (Fin (dimY + 1))
737       (PowerSeries k) := P.B
738   let BL : Matrix (Fin (n + 1)) (Fin (dimY + 1))
739       (LaurentSeries k) :=
740     fun i j => algebraMap (PowerSeries k) (LaurentSeries k) (B i j)
741   have hgenericSpan :
742       genericFibre (K := LaurentSeries k) L =
743         Submodule.span (LaurentSeries k)
744           (Set.range fun j => fun i => BL i j) :=
745     genericFibre_eq_span_matrixColumns L B P.columnsSpan
746   have hcone :
747       projectiveTangentCone (laurentColumn q)
748           (zariskiTangentSpace
749             (dehomogenizedPoint (laurentColumn q))
750             (I.map (scalarPolynomialMap
751               (k := k) (K := LaurentSeries k) (Fin n)))) ≤
752         Submodule.span (LaurentSeries k)
753           (Set.range fun j => fun i => BL i j) := by
754     rw [← hgenericSpan]
755     exact D.genericTangentCone_le
756   have hq0L : laurentColumn q 0 ≠ 0 :=
757     laurentColumn_ne_zero_of_ne_zero q D.chart_nonzero
758   obtain ⟨hposition, htangent⟩ :=
759     matrix_tangent_dictionary_of_projectiveCone_le_span
760       (laurentColumn q) hq0L
761       (zariskiTangentSpace
762         (dehomogenizedPoint (laurentColumn q))
763         (I.map (scalarPolynomialMap
764           (k := k) (K := LaurentSeries k) (Fin n))))
765       BL hcone
766   have hbase : ∀ f ∈ I.map (scalarPolynomialMap
767       (k := k) (K := LaurentSeries k) (Fin n)),
768       MvPolynomial.eval (dehomogenizedPoint (laurentColumn q)) f = 0 := by
769     have hz := (projectiveClosureAtZero_iff
770       (I.map (scalarPolynomialMap
771         (k := k) (K := LaurentSeries k) (Fin n)))
772       (laurentColumn q) hq0L).mp D.arc_mem_closure.2
773     exact hz
774   have haxis : ∀ j,
775       PowerSeries.constantCoeff (B D.axis.succ j) = 0 := by
776     intro j
777     have hmem : (fun i => B i j) ∈ L := by
778       rw [← P.columnsSpan]
779       exact Submodule.subset_span ⟨j, rfl⟩
780     let v : L := ⟨fun i => B i j, hmem⟩
781     simpa [v] using D.residue_le_coordinateHyperplane v
782   let low : TangentInclusionInput (dimY := dimY) I q B := {
783     axis := D.axis
784     C := P.C
785     hprime := D.hprime
786     hsplit := P.leftInverse
787     hrank := Fintype.card_fin (dimY + 1)
788     hq0 := D.chart_nonzero
789     hbase := hbase
790     hsmooth := D.generic_smooth
791     hposition := hposition
792     htangent := htangent
793     haxis := haxis }
794   obtain ⟨ell, hrow, hres, hfinal⟩ :=
795     exists_axis_laurent_smooth_conormal_direction_of_tangentInclusion
796       I q B low
797   exact hfinal.2.2
798 
799 #print axioms normalized_axis_constantCoeff_eq_zero
800 #print axioms exists_normalized_split_axis_matrix
801 #print axioms normalizedTangentLattice_isComplemented
802 #print axioms normalizedTangentLattice_finrank
803 #print axioms normalizedTangentLattice_residue_axis
804 #print axioms matrix_tangent_dictionary_of_projectiveCone_le_span
805 #print axioms projectiveTangentCone_le_span_of_position_and_tangent
806 #print axioms dehomogenizedTangentSpan_nonposition_le_full
807 #print axioms exists_axis_laurent_smooth_conormal_direction_of_tangentInclusion
808 #print axioms tangent_limit_criterion_of_directSummand_inclusion
809 #print axioms directSummandInclusionInput_of_normalizedTangentMatrix
810 #print axioms directSummandInclusionInput_of_normalizedTangentMatrix_of_affineTangentInclusion
811 
812 end
813 end Stafford38.Geometry.PaperDivisorTangent
814