File size: 6,236 Bytes
7f5fab8 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 | import Mathlib
import OAI.AlgebraicGeometry.Seshadri.Interpolation.CompressionRanks
namespace OAI
section
namespace MaximalSeshadri.Interpolation
open scoped BigOperators Pointwise
open scoped BigOperators ContDiff
open Filter Topology
abbrev RowIndex {Q : Type*} (n : Q → ℕ) := (q : Q) × Fin (n q + 1)
theorem compression_column_mem_span {Q : Type*} [Fintype Q]
(q : Q → ℤ) (B n : Q → ℕ) (r m : ℕ) (points : Fin r → ℂ × ℂ)
(s : ℂ) (hs : s ≠ 0) (i : RowIndex n) :
finiteJetColumn r m points (fun u z => u ^ q i.1 *
((1 + s * z) ^ B i.1 * z ^ (i.2 : ℕ))) ∈
Submodule.span ℂ (Set.range fun j : RowIndex n => finiteJetColumn r m points
(fun u z => u ^ q j.1 * (1 + s * z) ^ (B j.1 + (j.2 : ℕ)))) := by
let L := (polynomialJetMap r m points (q i.1)).comp (compressionRowMap s (B i.1))
have hp := polynomial_image_mem_span L
((Polynomial.C s⁻¹ * (Polynomial.X - 1)) ^ (i.2 : ℕ)) (n i.1)
((compression_inverse_degree s i.2).trans (by omega))
have hv : L ((Polynomial.C s⁻¹ * (Polynomial.X - 1)) ^ (i.2 : ℕ)) =
finiteJetColumn r m points (fun u z => u ^ q i.1 *
((1 + s * z) ^ B i.1 * z ^ (i.2 : ℕ))) := by
dsimp only [L, LinearMap.comp_apply]
rw [compressionRowMap_inverse s hs, polynomialJetMap_eq]
congr 1
funext u z
simp
rw [hv] at hp
apply (Submodule.span_mono ?_) hp
rintro _ ⟨j, rfl⟩
refine ⟨⟨i.1, j⟩, ?_⟩
dsimp only [L, LinearMap.comp_apply]
rw [compressionRowMap_pow, polynomialJetMap_eq]
congr 1
funext u z
simp
theorem compression_rank_to_powers {Q : Type*} [Fintype Q]
(q : Q → ℤ) (B n : Q → ℕ) (r m : ℕ) (points : Fin r → ℂ × ℂ)
(s : ℂ) (hs : s ≠ 0)
(h : LinearIndependent ℂ (fun i : RowIndex n => finiteJetColumn r m points
(fun u z => u ^ q i.1 * ((1 + s * z) ^ B i.1 * z ^ (i.2 : ℕ))))) :
LinearIndependent ℂ (fun i : RowIndex n => finiteJetColumn r m points
(fun u z => u ^ q i.1 * (1 + s * z) ^ (B i.1 + (i.2 : ℕ)))) := by
apply linearIndependent_of_span_le _ _ h
apply Submodule.span_le.mpr
rintro _ ⟨i, rfl⟩
exact compression_column_mem_span q B n r m points s hs i
theorem iteratedDeriv_affine_pow (s : ℂ) (b N : ℕ) :
iteratedDeriv b (fun z : ℂ => (1 + s * z) ^ N) =
fun z => s ^ b * iteratedDeriv b (fun z : ℂ => z ^ N) (1 + s * z) := by
have hd : ContDiff ℂ (b : ℕ∞ω) (fun z : ℂ => (1 + z) ^ N) := by fun_prop
rw [show (fun z : ℂ => (1 + s * z) ^ N) =
(fun z : ℂ => (fun y : ℂ => (1 + y) ^ N) (s * z)) by rfl,
iteratedDeriv_comp_const_mul hd s]
funext z
congr 1
exact congrFun (iteratedDeriv_comp_const_add b (fun z : ℂ => z ^ N) 1) (s * z)
noncomputable def verticalJetScale (r m : ℕ) (s : ℂ) :
(JetIndex r m → ℂ) →ₗ[ℂ] (JetIndex r m → ℂ) :=
LinearMap.pi fun j => (s ^ (j.2.2 : ℕ)) • LinearMap.proj j
theorem verticalJetScale_column (r m : ℕ) (points : Fin r → ℂ × ℂ)
(s : ℂ) (q : ℤ) (N : ℕ) :
verticalJetScale r m s
(finiteJetColumn r m (fun i => ((points i).1, 1 + s * (points i).2))
(fun u z => u ^ q * z ^ N)) =
finiteJetColumn r m points (fun u z => u ^ q * (1 + s * z) ^ N) := by
funext j
simp only [verticalJetScale, LinearMap.pi_apply, LinearMap.smul_apply,
LinearMap.proj_apply, smul_eq_mul, finiteJetColumn]
split_ifs
· simp only [mixed_deriv_separated, iteratedDeriv_affine_pow]
ring
· exact mul_zero _
theorem compression_powers_to_original {Q : Type*} [Fintype Q]
(q : Q → ℤ) (B n : Q → ℕ) (r m : ℕ) (points : Fin r → ℂ × ℂ) (s : ℂ)
(h : LinearIndependent ℂ (fun i : RowIndex n => finiteJetColumn r m points
(fun u z => u ^ q i.1 * (1 + s * z) ^ (B i.1 + (i.2 : ℕ))))) :
LinearIndependent ℂ (fun i : RowIndex n =>
finiteJetColumn r m (fun i => ((points i).1, 1 + s * (points i).2))
(fun u z => u ^ q i.1 * z ^ (B i.1 + (i.2 : ℕ)))) := by
apply LinearIndependent.of_comp (verticalJetScale r m s)
simpa only [Function.comp_def, verticalJetScale_column] using h
theorem affine_vertical_tuple_injective {r : ℕ} (points : Fin r → ℂ × ℂ)
(hi : Function.Injective points) (s : ℂ) (hs : s ≠ 0) :
Function.Injective (fun i => ((points i).1, 1 + s * (points i).2)) := by
intro i j hij
apply hi
apply Prod.ext
· simpa only using congrArg (fun p : ℂ × ℂ => p.1) hij
· have h := congrArg Prod.snd hij
exact (mul_left_cancel₀ hs) (add_left_cancel h)
theorem compression_exists_tuple {Q : Type*} [Fintype Q]
(q : Q → ℤ) (B n : Q → ℕ) (r m : ℕ) (points : Fin r → ℂ × ℂ)
(hi : Function.Injective points) (hnz : ∀ i, (points i).1 ≠ 0)
(h₀ : LinearIndependent ℂ (fun i : RowIndex n => finiteJetColumn r m points
(fun u z => u ^ q i.1 * z ^ (i.2 : ℕ)))) :
∃ p : Fin r → ℂ × ℂ, Function.Injective p ∧
(∀ i, (p i).1 ≠ 0 ∧ (p i).2 ≠ 0) ∧
LinearIndependent ℂ (fun i : RowIndex n => finiteJetColumn r m p
(fun u z => u ^ q i.1 * z ^ (B i.1 + (i.2 : ℕ)))) := by
have hrank := compression_finite_rank (fun i : RowIndex n => q i.1)
(fun i => B i.1) (fun i => (i.2 : ℕ)) r m points h₀
have hn : ∀ᶠ s : ℂ in 𝓝 0, ∀ i, 1 + s * (points i).2 ≠ 0 := by
apply Filter.eventually_all.mpr
intro i
have ht : Tendsto (fun s : ℂ => 1 + s * (points i).2) (𝓝 0) (𝓝 1) := by
simpa using (tendsto_const_nhds : Tendsto (fun _ : ℂ => (1 : ℂ)) (𝓝 0) (𝓝 1)).add
((tendsto_id : Tendsto (id : ℂ → ℂ) (𝓝 0) (𝓝 0)).mul_const (points i).2)
exact ht.eventually_ne one_ne_zero
have he : ∀ᶠ s : ℂ in 𝓝[≠] 0, s ≠ 0 := eventually_mem_nhdsWithin
obtain ⟨s, hs, hrank, hn⟩ := (he.and
((hrank.and hn).filter_mono nhdsWithin_le_nhds)).exists
refine ⟨(fun i => ((points i).1, 1 + s * (points i).2)),
affine_vertical_tuple_injective points hi s hs, ?_, ?_⟩
· intro i
exact ⟨hnz i, hn i⟩
· exact compression_powers_to_original q B n r m points s
(compression_rank_to_powers q B n r m points s hs hrank)
end MaximalSeshadri.Interpolation
end
end OAI
|