import Mathlib
import OAI.Algebra.FrobeniusObstruction.Obstruction
import OAI.Algebra.AlgebraicObstruction.SymbolicPowers
import OAI.Algebra.AlgebraicObstruction.ArcDetection

namespace OAI

noncomputable section
open scoped BigOperators

namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement.FormalArc
open MvPowerSeries
open scoped MvPowerSeries.WithPiTopology
open MvPowerSeries.WithPiTopology
variable {R σ τ : Type*} [CommRing R] [Fintype σ]

lemma substitution_pderiv_polynomial (a : σ → MvPowerSeries τ R) (ha : HasSubst a)
    (j : τ) (p : MvPolynomial σ R) :
    pderiv (R := R) j (subst a (p : MvPowerSeries σ R)) =
      ∑ i, subst a (pderiv (R := R) i (p : MvPowerSeries σ R)) * pderiv (R := R) j (a i) := by
  classical
  have hz : subst a (0 : MvPowerSeries σ R) = 0 := by rw [← substAlgHom_apply (R := R) ha, map_zero]
  have ho : subst a (1 : MvPowerSeries σ R) = 1 := by rw [← substAlgHom_apply (R := R) ha, map_one]
  induction p using MvPolynomial.induction_on with
  | C c => simp only [MvPolynomial.coe_C, pderiv_C, subst_C, hz, zero_mul,
      Finset.sum_const_zero]
  | add p q hp hq =>
    simp only [MvPolynomial.coe_add, map_add, subst_add ha, add_mul, Finset.sum_add_distrib, hp, hq]
  | mul_X p k hp =>
    simp only [MvPolynomial.coe_mul, MvPolynomial.coe_X, subst_mul ha, subst_X ha,
      Derivation.leibniz, smul_eq_mul, subst_add ha, hp, add_mul,
      Finset.sum_add_distrib]
    rw [Finset.mul_sum]
    congr 1
    · simp [pderiv_X, Pi.single_apply, apply_ite, hz, ho]
    · simp only [mul_assoc]

omit [Fintype σ] in
lemma continuous_pderiv [TopologicalSpace R] [IsTopologicalRing R] (i : σ) :
    Continuous (pderiv (R := R) i : MvPowerSeries σ R → MvPowerSeries σ R) := by
  apply continuous_pi
  intro n
  change Continuous (fun f : MvPowerSeries σ R ↦ coeff n (pderiv (R := R) i f))
  simp only [coeff_pderiv]
  exact (continuous_coeff R _).mul continuous_const

lemma substitution_pderiv (a : σ → MvPowerSeries τ R) (ha : HasSubst a)
    (j : τ) (f : MvPowerSeries σ R) :
    pderiv (R := R) j (subst a f) =
      ∑ i, subst a (pderiv (R := R) i f) * pderiv (R := R) j (a i) := by
  let : UniformSpace R := ⊥
  have h := denseRange_toMvPowerSeries (σ := σ) (R := R)
  have h1 : Continuous (fun f : MvPowerSeries σ R ↦ pderiv (R := R) j (subst a f)) :=
    (continuous_pderiv j).comp (continuous_subst ha)
  have h2 : Continuous (fun f : MvPowerSeries σ R ↦
      ∑ i, subst a (pderiv (R := R) i f) * pderiv (R := R) j (a i)) := by
    apply continuous_finsetSum
    intro i hi
    exact ((continuous_subst ha).comp (continuous_pderiv i)).mul continuous_const
  exact congrFun (h.equalizer h1 h2 (funext (substitution_pderiv_polynomial a ha j))) f

omit [Fintype σ] in
lemma constantCoeff_subst_centered [Fintype σ] (a : σ → MvPowerSeries τ R) (ha : HasSubst a)
    (ha0 : ∀ i, constantCoeff (a i) = 0) (f : MvPowerSeries σ R) :
    constantCoeff (subst a f) = constantCoeff f := by
  have h := constantCoeff_subst_eq_zero ha ha0
    (f := f - C (constantCoeff f)) (by simp)
  rw [subst_sub ha, subst_C, map_sub, constantCoeff_C, sub_eq_zero] at h
  exact h

theorem primitive_constant_on_arc [IsAddTorsionFree R]
    (a : σ → MvPowerSeries τ R) (ha : HasSubst a)
    (ha0 : ∀ i, constantCoeff (a i) = 0)
    (I : Ideal (MvPowerSeries σ R))
    (hI : I ≤ RingHom.ker (substAlgHom (R := R) ha).toRingHom)
    (f : MvPowerSeries σ R) (hgrad : ∀ i, pderiv (R := R) i f ∈ I) :
    subst a (f - C (constantCoeff f)) = 0 := by
  have hg (i : σ) : subst a (pderiv (R := R) i f) = 0 := by
    have h := hI (hgrad i)
    change substAlgHom (R := R) ha (pderiv (R := R) i f) = 0 at h
    simpa only [substAlgHom_apply] using h
  have he : subst a f = C (constantCoeff f) := by
    apply pderiv.ext
    · intro j
      rw [substitution_pderiv a ha j]
      simp only [hg, zero_mul, Finset.sum_const_zero, pderiv_C]
    · rw [constantCoeff_subst_centered a ha ha0, constantCoeff_C]
  rw [subst_sub ha, subst_C, he, sub_self]

end BoundaryOnly.FormalObstruction.AlgebraicReplacement.FormalArc

namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement.FormalArc
open MvPowerSeries IsLocalRing
variable {K σ : Type*} [Field K] [IsAlgClosed K] [CharZero K] [Fintype σ]

theorem radical_primitive_constant (I : Ideal (MvPowerSeries σ K))
    (hI : I.IsRadical) (P : MvPowerSeries σ K)
    (hgrad : ∀ i, pderiv (R := K) i P ∈ I) : P - C (constantCoeff P) ∈ I := by
  classical
  by_contra hnot
  have hIne : I ≠ ⊤ := by
    intro h
    apply hnot
    simp [h]
  let B := MvPowerSeries σ K
  let Q := B ⧸ I
  have : Nontrivial Q := Ideal.Quotient.nontrivial_iff.mpr hIne
  have : IsReduced Q := (Ideal.isRadical_iff_quotient_reduced I).mp hI
  have : IsAdicComplete (maximalIdeal Q) Q := local_quotient_complete I
  let q : B →ₐ[K] Q := Ideal.Quotient.mkₐ K I
  have hsurj : Function.Surjective q := Ideal.Quotient.mk_surjective
  have : IsLocalHom q.toRingHom := IsLocalHom.of_surjective _ hsurj
  let b := P - C (constantCoeff P)
  have hqb : q b ≠ 0 := fun h ↦ hnot (Ideal.Quotient.eq_zero_iff_mem.mp h)
  have hbm : b ∈ maximalIdeal B := by
    rw [maximalIdeal_eq_variables,span_variables_eq_constant_kernel]
    change constantCoeff b = 0
    simp [b]
  obtain ⟨g,hglocal,hgb⟩ := reduced_detecting_arc (q b) hqb
    (map_nonunit q.toRingHom b hbm) (quotient_residue_surjective I residue_mps_surjective)
  have : IsLocalHom g.toRingHom := hglocal
  let f : B →ₐ[K] PowerSeries K := g.comp q
  have : IsLocalHom f.toRingHom := by
    change IsLocalHom (g.toRingHom.comp q.toRingHom)
    infer_instance
  let a : σ → MvPowerSeries Unit K := fun i ↦ f (X i)
  have ha0 (i : σ) : constantCoeff (a i) = 0 := by
    have hx : (X i : B) ∈ maximalIdeal B := by
      rw [maximalIdeal_eq_variables]
      exact Ideal.subset_span (Set.mem_range_self i)
    have hh := map_nonunit f.toRingHom (X i) hx
    rw [maximalIdeal_eq_variables,span_variables_eq_constant_kernel] at hh
    exact hh
  have ha : HasSubst a := ⟨fun i ↦ ha0 i ▸ IsNilpotent.zero,fun _ ↦ Set.toFinite _⟩
  let s : B →ₐ[K] PowerSeries K := substAlgHom (R := K) ha
  have : IsLocalHom s.toRingHom := ⟨by
    intro x hx
    apply MvPowerSeries.isUnit_iff_constantCoeff.mpr
    have hh := MvPowerSeries.isUnit_iff_constantCoeff.mp hx
    change IsUnit (constantCoeff (substAlgHom (R := K) ha x)) at hh
    rw [substAlgHom_apply] at hh
    rw [constantCoeff_subst_centered a ha ha0] at hh
    exact hh⟩
  have hfs : f = s := local_mps_hom_ext f s (fun i ↦ by
    change a i = substAlgHom (R := K) ha (X i)
    rw [substAlgHom_apply,subst_X ha])
  have hkill : I ≤ RingHom.ker s.toRingHom := by
    intro x hx
    change s x = 0
    rw [← hfs]
    change g (q x) = 0
    rw [show q x = 0 from Ideal.Quotient.eq_zero_iff_mem.mpr hx,map_zero]
  have hconst := primitive_constant_on_arc a ha ha0 I hkill P hgrad
  apply hgb
  change f b = 0
  rw [hfs]
  change substAlgHom (R := K) ha b = 0
  rw [substAlgHom_apply]
  exact hconst

end BoundaryOnly.FormalObstruction.AlgebraicReplacement.FormalArc

namespace BoundaryOnly.FormalObstruction.FormalCorrection.AffineEtaleChart
open BoundaryOnly.FormalObstruction.AlgebraicReplacement MvPowerSeries
variable {K α : Type} [Field K] [CharZero K] [IsAlgClosed K] [Finite α]

noncomputable instance chartCoeffAlgebra (E : AffineEtaleChart K α) : Algebra K E.S :=
  Algebra.compHom E.S (algebraMap K (MvPolynomial α K))
instance chartCoeffTower (E : AffineEtaleChart K α) : IsScalarTower K (MvPolynomial α K) E.S :=
  IsScalarTower.of_algebraMap_eq' rfl

noncomputable def pointAlgHom (E : AffineEtaleChart K α) : E.S →ₐ[K] K :=
  { ((constantCoeff : MvPowerSeries α K →+* K).comp E.expansion.toRingHom) with
    commutes' := fun k ↦ by
      change constantCoeff (E.expansion (algebraMap (MvPolynomial α K) E.S (MvPolynomial.C k))) = k
      rw [E.expansion.commutes]
      simp [MvPowerSeries.algebraMap_apply'] }

theorem radical_extended (E : AffineEtaleChart K α) (I : Ideal E.LocalRing)
    (hI : I.IsRadical) (hIne : I ≠ ⊤) :
    (I.map (algebraMap E.LocalRing
      (AdicCompletion (IsLocalRing.maximalIdeal E.LocalRing) E.LocalRing))).IsRadical := by
  have : Algebra.FiniteType K E.S := Algebra.FiniteType.trans
    (inferInstance : Algebra.FiniteType K (MvPolynomial α K)) inferInstance
  have : IsLocalization.AtPrime E.LocalRing (RingHom.ker E.pointAlgHom.toRingHom) := by
    change IsLocalization.AtPrime E.LocalRing E.point
    infer_instance
  exact AnalyticReducedness.radical_local_completion E.pointAlgHom E.LocalRing I hI hIne

theorem primitive_constant_reduction (E : AffineEtaleChart K α) (L : Ideal E.LocalRing)
    (b : AdicCompletion (IsLocalRing.maximalIdeal E.LocalRing) E.LocalRing)
    (hgrad : ∀ i : α, E.completionDeriv i b ∈ L.map (algebraMap E.LocalRing
      (AdicCompletion (IsLocalRing.maximalIdeal E.LocalRing) E.LocalRing))) :
    ∃ a₀ : E.LocalRing ⧸ L.radical,
      TaylorTarget.quotientCoefficient
        (S := AdicCompletion (IsLocalRing.maximalIdeal E.LocalRing) E.LocalRing) L.radical a₀ =
      Ideal.Quotient.mk (L.radical.map (algebraMap E.LocalRing
        (AdicCompletion (IsLocalRing.maximalIdeal E.LocalRing) E.LocalRing))) b := by
  classical
  let := Fintype.ofFinite α
  let B := AdicCompletion (IsLocalRing.maximalIdeal E.LocalRing) E.LocalRing
  let I := L.radical
  let J := I.map (algebraMap E.LocalRing B)
  by_cases hI : I = ⊤
  · refine ⟨0,?_⟩
    have hJ : J = ⊤ := by
      change I.map (algebraMap E.LocalRing B) = ⊤
      rw [hI,Ideal.map_top]
    change TaylorTarget.quotientCoefficient (S := B) I 0 = Ideal.Quotient.mk J b
    rw [map_zero]
    exact (Ideal.Quotient.eq_zero_iff_mem.mpr (show b ∈ J by rw [hJ]; trivial)).symm
  have hJ : J.IsRadical := E.radical_extended I L.radical_isRadical hI
  let H := J.map E.completionEquiv.toRingHom
  have hH : H.IsRadical := by
    change (J.map (E.completionEquiv : B →+* MvPowerSeries α K)).IsRadical
    rw [Ideal.map_comap_of_equiv]
    exact hJ.comap _
  have hg : ∀ i, pderiv (R := K) i (E.completionEquiv b) ∈ H := by
    intro i
    have hi := Ideal.mem_map_of_mem E.completionEquiv.toRingHom
      ((Ideal.map_mono (show L ≤ I from Ideal.le_radical)) (hgrad i))
    change E.completionEquiv (E.completionEquiv.symm (pderiv (R := K) i (E.completionEquiv b))) ∈ H at hi
    rwa [RingEquiv.apply_symm_apply] at hi
  have hc := FormalArc.radical_primitive_constant H hH (E.completionEquiv b) hg
  let k := constantCoeff (E.completionEquiv b)
  let a : E.LocalRing := algebraMap K E.LocalRing k
  have ha : E.completionEquiv (AdicCompletion.of _ _ a) = C k := by
    rw [E.completionEquiv_of]
    change E.localExpansion (algebraMap (MvPolynomial α K) E.LocalRing (MvPolynomial.C k)) = _
    rw [E.localExpansion.commutes]
    simp [MvPowerSeries.algebraMap_apply']
  have hb : b - AdicCompletion.of _ _ a ∈ J := by
    apply (Ideal.apply_mem_of_equiv_iff (f := E.completionEquiv) (I := J)).mp
    change E.completionEquiv (b - AdicCompletion.of _ _ a) ∈ H
    rw [map_sub,ha]
    exact hc
  refine ⟨Ideal.Quotient.mk I a,?_⟩
  change Ideal.Quotient.mk J (AdicCompletion.of _ _ a) = Ideal.Quotient.mk J b
  exact (Ideal.Quotient.eq.mpr hb).symm

theorem primitive_approximation (E : AffineEtaleChart K α) (L : Ideal E.LocalRing)
    (b : AdicCompletion (IsLocalRing.maximalIdeal E.LocalRing) E.LocalRing)
    (hgrad : ∀ i : α, E.completionDeriv i b ∈ L.map (algebraMap E.LocalRing
      (AdicCompletion (IsLocalRing.maximalIdeal E.LocalRing) E.LocalRing)))
    (hjets : ∀ i : α, ∀ q : ℕ, 1 ≤ q → ∃ a : E.LocalRing,
      E.completionDeriv i b - AdicCompletion.of _ _ a ∈
        (L.map (algebraMap E.LocalRing
          (AdicCompletion (IsLocalRing.maximalIdeal E.LocalRing) E.LocalRing)))^q)
    (m : ℕ) (hm : 1 ≤ m) :
    ∃ a : E.LocalRing, b - AdicCompletion.of _ _ a ∈
      (L^m).map (algebraMap E.LocalRing
        (AdicCompletion (IsLocalRing.maximalIdeal E.LocalRing) E.LocalRing)) :=
  E.primitive_approximation_from_constant_reduction L b
    (E.primitive_constant_reduction L b hgrad) hjets m hm

end BoundaryOnly.FormalObstruction.FormalCorrection.AffineEtaleChart

end

end OAI