import Mathlib
import OAI.Algebra.FiniteTensor.JacobianAlgebraicity
import OAI.Algebra.FiniteTensor.PreparedCoefficients

namespace OAI

/-! Fixed-jet approximation of prepared systems and the aligned Artin step. -/

noncomputable section
open scoped BigOperators

namespace PD4Tensor.Spreading
noncomputable section
variable {R M : Type*} [CommRing R] [AddCommGroup M] [Module R M]

 
theorem adic_complete_power (I : Ideal R) [IsAdicComplete I M]
    (c : ℕ) (hc : 0<c) : IsAdicComplete (I^c) M := by
  have hcn (n : ℕ) : n≤c*n := Nat.le_mul_of_pos_left n hc
  let : IsHausdorff (I^c) M := by
    constructor
    intro x hx
    apply IsHausdorff.haus' (I:=I) x
    intro n
    apply SModEq.mono (Submodule.smul_mono_left (Ideal.pow_le_pow_right (hcn n)))
    simpa only [←pow_mul] using hx n
  let : IsPrecomplete (I^c) M := by
    constructor
    intro f hf
    have hfI : ∀ {m n},m≤n→f m ≡ f n [SMOD (I^m • ⊤ : Submodule R M)] := by
      intro m n hmn
      apply SModEq.mono (Submodule.smul_mono_left (Ideal.pow_le_pow_right (hcn m)))
      simpa only [←pow_mul] using hf hmn
    obtain ⟨L,hL⟩ := IsPrecomplete.prec (I:=I) inferInstance hfI
    refine ⟨L,fun n=>?_⟩
    have h1 := hf (hcn n)
    have h2 := hL (c*n)
    rw [←pow_mul] at h1 ⊢
    exact h1.trans h2
  exact IsAdicComplete.mk

end
end PD4Tensor.Spreading

 

namespace PD4Tensor.Spreading
noncomputable section
open MvPolynomial
open scoped Matrix
variable {K τ σ ρ : Type*} [Field K] [Finite τ] [Fintype σ] [DecidableEq σ] [Fintype ρ] [DecidableEq ρ]

 

omit [Fintype ρ] [DecidableEq ρ] in
theorem prepared_algebraic_approximation
    (f : σ → MvPolynomial (σ ⊕ ρ) (MvPowerSeries τ K))
    (hcoeff : ∀ k d,IsAlgebraic (MvPolynomial τ K) ((f k).coeff d))
    (a u : (σ ⊕ ρ) → MvPowerSeries τ K)
    (ha : ∀ k,eval a (f k)=0)
    (hu : ∀ i : ρ,IsAlgebraic (MvPolynomial τ K) (u (Sum.inr i)))
    (n : ℕ)
    (hJ : Matrix.det (fun k i=>eval u (pderiv (Sum.inl i) (f k)))≠0)
    (hclose : ∀ i,u i-a i∈(jetIdeal (K:=K) (σ:=τ))^
      ((Matrix.det (fun k i=>eval u (pderiv (Sum.inl i) (f k)))^2).order.toNat+(n+1)))
    (hdiv : ∀ k,(Matrix.det (fun k i=>eval u (pderiv (Sum.inl i) (f k)))^2)∣eval u (f k)) :
    ∃ b : (σ ⊕ ρ) → MvPowerSeries τ K,(∀ k,eval b (f k)=0) ∧
      (∀ i,IsAlgebraic (MvPolynomial τ K) (b i)) ∧
      (∀ i : ρ,b (Sum.inr i)=u (Sum.inr i)) ∧
      ∀ i,b i-a i∈(jetIdeal (K:=K) (σ:=τ))^n := by
  let δ := Matrix.det (fun k i=>eval u (pderiv (Sum.inl i) (f k)))
  let J : Ideal (MvPowerSeries τ K) := jetIdeal
  let I := J^(n+1)
  have hδ : δ^2≠0 := pow_ne_zero _ hJ
  choose e he using hdiv
  have heI (k : σ) : e k∈I := by
    apply quotient_jet_control hδ (n+1)
    change δ^2*e k∈J^((δ^2).order.toNat+(n+1))
    rw [←he k]
    simpa only [ha,sub_zero] using mv_eval_sub_mem _ (f k) u a hclose
  let : IsAdicComplete I (MvPowerSeries τ K) :=
    adic_complete_power J (n+1) (Nat.succ_pos n)
  obtain ⟨b,hb,halg,hfree,hbu⟩ := algebraic_rectangular_tougeron I f hcoeff u hu e heI hJ he
  refine ⟨b,hb,halg,hfree,fun i=>?_⟩
  have hsmall : I≤J^n := Ideal.pow_le_pow_right (Nat.le_succ n)
  have hlarge : J^((δ^2).order.toNat+(n+1))≤J^n :=
    Ideal.pow_le_pow_right (by omega)
  have hua : u i-a i∈J^n := hlarge (hclose i)
  have hbi : b i-u i∈J^n := by
    cases i with
    | inl i =>
      obtain ⟨v,hv,hvEq⟩ := hbu i
      rw [hvEq,add_sub_cancel_left]
      exact hsmall (I.mul_mem_left _ hv)
    | inr i => simpa only [hfree,sub_self] using (J^n).zero_mem
  convert (J^n).add_mem hbi hua using 1
  abel

end
end PD4Tensor.Spreading

namespace PD4Tensor.Spreading
noncomputable section
open MvPowerSeries
variable {K τ : Type*} [CommRing K] [Finite τ]

 

theorem order_eq_of_close_jet {f g : MvPowerSeries τ K} (hf : f≠0)
    (hclose : g-f∈(jetIdeal (K:=K) (σ:=τ))^(f.order.toNat+1)) :
    g.order=f.order := by
  have ho := (ne_zero_iff_order_finite.mp hf).symm
  have hh := (mem_jetIdeal_pow_iff_order _ _).mp hclose
  have hlt : f.order<(g-f).order := by
    apply lt_of_lt_of_le _ hh
    rw [ho]
    exact_mod_cast Nat.lt_succ_self f.order.toNat
  have he : f+(g-f)=g := by abel
  rw [←he,order_add_of_order_ne (ne_of_lt hlt),inf_eq_left.mpr (le_of_lt hlt)]

 theorem ne_zero_of_close_jet {f g : MvPowerSeries τ K} (hf : f≠0)
    (hclose : g-f∈(jetIdeal (K:=K) (σ:=τ))^(f.order.toNat+1)) : g≠0 := by
  intro hg
  have he := order_eq_of_close_jet hf hclose
  rw [hg,order_zero] at he
  exact hf (order_eq_top_iff.mp he.symm)

end
end PD4Tensor.Spreading

namespace PD4Tensor.Spreading
noncomputable section
open MvPolynomial
open scoped Matrix
variable {K τ σ ρ : Type*} [Field K] [Finite τ] [Fintype σ] [DecidableEq σ]
  [Fintype ρ] [DecidableEq ρ]

 

omit [Fintype ρ] [DecidableEq ρ] in
theorem fixed_jet_prepared_approximation
    (f : σ → MvPolynomial (σ ⊕ ρ) (MvPowerSeries τ K))
    (hcoeff : ∀ k d,IsAlgebraic (MvPolynomial τ K) ((f k).coeff d))
    (a u : (σ ⊕ ρ) → MvPowerSeries τ K)
    (ha : ∀ k,eval a (f k)=0)
    (hu : ∀ i : ρ,IsAlgebraic (MvPolynomial τ K) (u (Sum.inr i)))
    (n : ℕ)
    (hJ : Matrix.det (fun k i=>eval a (pderiv (Sum.inl i) (f k)))≠0)
    (hclose : ∀ i,u i-a i∈(jetIdeal (K:=K) (σ:=τ))^
      (2*(Matrix.det (fun k i=>eval a (pderiv (Sum.inl i) (f k)))).order.toNat+n+1))
    (hdiv : ∀ k,(Matrix.det (fun k i=>eval u (pderiv (Sum.inl i) (f k)))^2)∣eval u (f k)) :
    ∃ b : (σ ⊕ ρ) → MvPowerSeries τ K,(∀ k,eval b (f k)=0) ∧
      (∀ i,IsAlgebraic (MvPolynomial τ K) (b i)) ∧
      (∀ i : ρ,b (Sum.inr i)=u (Sum.inr i)) ∧
      ∀ i,b i-a i∈(jetIdeal (K:=K) (σ:=τ))^n := by
  let δ := Matrix.det (fun k i=>eval a (pderiv (Sum.inl i) (f k)))
  let δ' := Matrix.det (fun k i=>eval u (pderiv (Sum.inl i) (f k)))
  let J := jetIdeal (K:=K) (σ:=τ)
  have hc : ∀ i,u i-a i∈J^(δ.order.toNat+1) := fun i=>
    Ideal.pow_le_pow_right (by dsimp [δ]; omega) (hclose i)
  have hd : δ'-δ∈J^(δ.order.toNat+1) := by
    let approxJacobian : Matrix σ σ (MvPowerSeries τ K) :=
      fun row col=>eval u (pderiv (Sum.inl col) (f row))
    let baseJacobian : Matrix σ σ (MvPowerSeries τ K) :=
      fun row col=>eval a (pderiv (Sum.inl col) (f row))
    change approxJacobian.det-baseJacobian.det∈_
    apply Ideal.Quotient.eq_zero_iff_mem.mp
    rw [map_sub,sub_eq_zero,RingHom.map_det,RingHom.map_det]
    congr 1
    ext row col
    apply Ideal.Quotient.eq.mpr
    exact mv_eval_sub_mem _ (pderiv (Sum.inl col) (f row)) u a hc
  have hn : δ'≠0 := ne_zero_of_close_jet hJ hd
  have ho : δ'.order=δ.order := order_eq_of_close_jet hJ hd
  have hsq : (δ'^2).order.toNat=2*δ.order.toNat := by
    rw [pow_two,MvPowerSeries.order_mul,ho]
    rw [←(MvPowerSeries.ne_zero_iff_order_finite.mp hJ)]
    rw [←ENat.natCast_add]
    simp only [ENat.toNat_natCast]
    omega
  apply prepared_algebraic_approximation f hcoeff a u ha hu n hn _ hdiv
  intro i
  change u i-a i∈J^((δ'^2).order.toNat+(n+1))
  rw [hsq]
  simpa only [Nat.add_assoc] using hclose i

end
end PD4Tensor.Spreading

namespace PD4Tensor.Spreading
noncomputable section
open MvPolynomial
variable {K τ σ ρ : Type*} [Field K] [Finite τ]
  [Fintype σ] [DecidableEq σ] [Fintype ρ] [DecidableEq ρ]

theorem minorPolynomial_map {R S ι υ : Type*} [CommRing R] [CommRing S]
    [Fintype ι] [DecidableEq ι] (φ : R →+* S)
    (f : ι → MvPolynomial (ι ⊕ υ) R) :
    map φ (minorPolynomial f)=minorPolynomial (fun k=>map φ (f k)) := by
  unfold minorPolynomial
  calc
    _ = Matrix.det ((map φ).mapMatrix (fun k i=>pderiv (Sum.inl i) (f k))) :=
      RingHom.map_det (map φ) _
    _ = _ := by
      congr 1
      funext k i
      exact (pderiv_map).symm

 

omit [DecidableEq ρ] in
theorem aligned_artin_step
    (ih : PolynomialArtinAt K τ)
    (f : σ → MvPolynomial (σ ⊕ ρ) (Polynomial (MvPolynomial τ K)))
    (a : (σ ⊕ ρ) → PowerSeries (MvPowerSeries τ K))
    (ha : ∀ k,eval a (map (seriesCoefficientMap (B:=MvPolynomial τ K)
      (A:=MvPowerSeries τ K)) (f k))=0)
    (hreg : (eval a (map (seriesCoefficientMap (B:=MvPolynomial τ K)
      (A:=MvPowerSeries τ K)) (minorPolynomial f))).map
        (IsLocalRing.residue (MvPowerSeries τ K))≠0)
    (hnonunit : ¬IsUnit (eval a (map (seriesCoefficientMap (B:=MvPolynomial τ K)
      (A:=MvPowerSeries τ K)) (minorPolynomial f)))) (n : ℕ) :
    ∃ b : (σ ⊕ ρ) → PowerSeries (MvPowerSeries τ K),
      (∀ k,eval b (map (seriesCoefficientMap (B:=MvPolynomial τ K)
        (A:=MvPowerSeries τ K)) (f k))=0) ∧
      (∀ i,IsAlgebraic (Polynomial (MvPolynomial τ K)) (b i)) ∧
      ∀ i,(MvPowerSeries.optionEquivLeft τ K).symm (b i-a i)∈
        (jetIdeal (K:=K) (σ:=Option τ))^n := by
  let A := MvPowerSeries τ K
  let E := MvPowerSeries.optionEquivLeft τ K
  let F := fun k=>map (seriesCoefficientMap (B:=MvPolynomial τ K) (A:=A)) (f k)
  let G := fun k=>map E.symm.toRingHom (F k)
  let a' := fun i=>E.symm (a i)
  let δ := eval a (map (seriesCoefficientMap (B:=MvPolynomial τ K) (A:=A)) (minorPolynomial f))
  have hδ : δ≠0 := by
    intro h
    apply hreg
    change δ.map _=0
    simp [h]
  have hev (q : MvPolynomial (σ ⊕ ρ) (PowerSeries A))
      (v : (σ ⊕ ρ) → PowerSeries A) :
      eval (fun i=>E.symm (v i)) (map E.symm.toRingHom q)=E.symm (eval v q) := by
    rw [←eval₂_eq_eval_map]
    exact (hom_eval₂ q (RingHom.id _) E.symm.toRingHom v).symm
  have hFeval (v : (σ ⊕ ρ) → PowerSeries A) (k : σ) :
      eval (fun i=>E.symm (v i)) (G k)=E.symm (eval v (F k)) := hev (F k) v
  have hpoly : minorPolynomial G=map E.symm.toRingHom
      (map (seriesCoefficientMap (B:=MvPolynomial τ K) (A:=A)) (minorPolynomial f)) := by
    rw [minorPolynomial_map,minorPolynomial_map]
  have hminor (v : (σ ⊕ ρ) → PowerSeries A) :
      Matrix.det (fun k i=>eval (fun j=>E.symm (v j)) (pderiv (Sum.inl i) (G k)))=
        E.symm (eval v (map (seriesCoefficientMap (B:=MvPolynomial τ K) (A:=A)) (minorPolynomial f))) := by
    rw [←eval_minorPolynomial,hpoly,hev]
  have hGa (k : σ) : eval a' (G k)=0 := by
    rw [hFeval,ha,map_zero]
  have hGcoeff (k : σ) (d) : IsAlgebraic (MvPolynomial (Option τ) K) ((G k).coeff d) := by
    simp only [G,F,coeff_map]
    apply algebraic_option_series_symm
    apply polynomial_series_algebraic_coefficients
    intro m
    change IsAlgebraic (MvPolynomial τ K) ((((f k).coeff d).map (algebraMap (MvPolynomial τ K) A)).coeff m)
    rw [Polynomial.coeff_map]
    exact isAlgebraic_algebraMap (((f k).coeff d).coeff m)
  have hJa : Matrix.det (fun k i=>eval a' (pderiv (Sum.inl i) (G k)))≠0 := by
    rw [hminor]
    exact E.symm.injective.ne (by exact hδ)
  let N := 2*(E.symm δ).order.toNat+n+1
  obtain ⟨u,hu,hun,hdiv,hclose⟩ := regular_coefficient_prepared ih f (minorPolynomial f)
    a ha hreg hnonunit N (by dsimp [N]; omega)
  obtain ⟨b,hb,hbalg,hfree,hba⟩ := fixed_jet_prepared_approximation G hGcoeff a'
    (fun i=>E.symm (u i)) hGa
    (fun i=>algebraic_option_series_symm (hu (Sum.inr i))) n hJa
    (by
      intro i
      rw [hminor]
      simpa only [a',←map_sub] using hclose i)
    (by
      intro k
      rw [hminor,hFeval]
      have hd := map_dvd E.symm.toRingHom (hdiv k)
      change E.symm (_^2)∣E.symm (eval u (F k)) at hd
      rwa [map_pow] at hd)
  refine ⟨fun i=>E (b i),?_,fun i=>algebraic_option_series (hbalg i),?_⟩
  · intro k
    apply E.symm.injective
    rw [map_zero]
    rw [←hFeval]
    simpa only [AlgEquiv.symm_apply_apply] using hb k
  · intro i
    change E.symm (E (b i)-a i)∈_
    simpa only [map_sub,AlgEquiv.symm_apply_apply,a'] using hba i

end
end PD4Tensor.Spreading
end

end OAI