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