import Mathlib
import OAI.Algebra.FrobeniusObstruction.Obstruction
import OAI.Algebra.AlgebraicObstruction.IdealBounds

namespace OAI

noncomputable section
open scoped BigOperators

namespace BoundaryOnly.FormalObstruction.CoefficientRing
open MvPowerSeries FormalCorrection AlgebraicReplacement
open scoped Classical
variable {R : Type*} [CommRing R] {d : ℕ} {n : Fin d → ℕ}

def wallCoordinates (b : Bool) (i : Fin d) : WallVar n i → MvPowerSeries (AmbientVar n) R :=
  if b then plusCoordinates n i else minusCoordinates n i

theorem wallCoordinates_centered (b : Bool) (i : Fin d) :
    ∀ w, constantCoeff (wallCoordinates (R := R) (n := n) b i w) = 0 := by
  cases b
  · exact minusCoordinates_centered i
  · exact plusCoordinates_centered i

def wallEval (Y : InternalVar n → MvPowerSeries (GraphVar n) R)
    (hY : ∀ c, Y c ∈ originIdeal R (GraphVar n)) (b : Bool) (i : Fin d) :
    MvPowerSeries (WallVar n i) R →ₐ[R] MvPowerSeries (GraphVar n) R :=
  (substAlgHom (hasSubst_of_constantCoeff_zero (graphCoordinates_centered Y hY))).comp
    (substAlgHom (hasSubst_of_constantCoeff_zero (wallCoordinates_centered b i)))

theorem subst_potential_eq_sum (P : (i : Fin d) → MvPowerSeries (WallVar n i) R)
    (Y : InternalVar n → MvPowerSeries (GraphVar n) R)
    (hY : ∀ c, Y c ∈ originIdeal R (GraphVar n)) :
    subst (graphCoordinates n Y) (potential n P) =
      ∑ i, (wallEval Y hY true i (P i) - wallEval Y hY false i (P i)) := by
  rw [← substAlgHom_apply (hasSubst_of_constantCoeff_zero (graphCoordinates_centered Y hY))]
  simp only [potential, map_sum, map_sub]
  apply Finset.sum_congr rfl
  intro i _
  simp [wallEval, wallCoordinates, AlgHom.comp_apply, substAlgHom_apply]

theorem wallEval_negativeSlope (P : (i : Fin d) → MvPowerSeries (WallVar n i) R)
    (Y : InternalVar n → MvPowerSeries (GraphVar n) R)
    (hY : ∀ c, Y c ∈ originIdeal R (GraphVar n)) (i : Fin d) :
    negativeSlopeValue n P Y i = wallEval Y hY false i (pderiv (.inl 0) (P i)) := by
  have hz : ∀ w : WallVar n i, constantCoeff (zeroSlopes (k := R) n i w) = 0 := by
    intro w; cases w <;> simp [zeroSlopes]
  have hminus : ∀ j : Fin (n i), constantCoeff (Y (false,⟨i,j⟩)) = 0 :=
    fun j => mem_origin_iff.mp (hY _)
  simp only [wallEval, AlgHom.comp_apply, substAlgHom_apply, wallCoordinates, Bool.false_eq_true, ite_false]
  change subst (fun j => Y (false,⟨i,j⟩))
      (subst (zeroSlopes (k := R) n i) (pderiv (.inl 0) (P i))) =
    subst (graphCoordinates n Y)
      (subst (minusCoordinates (k := R) n i) (pderiv (.inl 0) (P i)))
  rw [subst_comp_subst_apply (hasSubst_of_constantCoeff_zero hz)
      (hasSubst_of_constantCoeff_zero hminus),
    subst_comp_subst_apply (hasSubst_of_constantCoeff_zero (minusCoordinates_centered i))
      (hasSubst_of_constantCoeff_zero (graphCoordinates_centered Y hY))]
  congr 1
  funext w
  cases w with
  | inl a =>
    simp only [zeroSlopes, minusCoordinates,
      ← substAlgHom_apply (hasSubst_of_constantCoeff_zero hminus),
      ← substAlgHom_apply (hasSubst_of_constantCoeff_zero (graphCoordinates_centered Y hY)), map_zero]
  | inr j =>
    simp only [zeroSlopes, minusCoordinates,
      subst_X (hasSubst_of_constantCoeff_zero hminus),
      subst_X (hasSubst_of_constantCoeff_zero (graphCoordinates_centered Y hY)), graphCoordinates]

theorem origin_le_jacobson {σ : Type*} [Fintype σ] :
    originIdeal R σ ≤ Ideal.jacobson ⊥ := by
  intro f hf
  apply Ideal.mem_jacobson_bot.mpr
  intro g
  apply MvPowerSeries.isUnit_iff_constantCoeff.mpr
  simp [mem_origin_iff.mp hf]

theorem wall_error_bounds
    (Y : InternalVar n → MvPowerSeries (GraphVar n) R)
    (hY : ∀ c, Y c ∈ originIdeal R (GraphVar n))
    (K : (i : Fin d) → Ideal (MvPowerSeries (WallVar n i) R))
    (r : Ideal (MvPowerSeries (GraphVar n) R))
    (hL : ∀ b i, Ideal.map (wallEval Y hY b i) (K i) ≤ originIdeal R (GraphVar n))
    (hcube : ∀ b i, (Ideal.map (wallEval Y hY b i) (K i))^3 ≤ r)
    (E : (i : Fin d) → MvPowerSeries (WallVar n i) R)
    (hE : ∀ i, E i ∈ (K i)^9) :
    (∀ b i, wallEval Y hY b i (E i) ∈ r^3) ∧
    (∀ b i w, wallEval Y hY b i (pderiv w (E i)) ∈ originIdeal R (GraphVar n) * r) := by
  constructor
  · intro b i
    have h := Ideal.mem_map_of_mem (wallEval Y hY b i) (hE i)
    rw [Ideal.map_pow] at h
    exact (ninth_order_bounds _ _ _ (hL b i) (hcube b i)).1 h
  · intro b i w
    have hd := derivation_mem_pow (pderiv w) (K i) 8 (hE i)
    have h := Ideal.mem_map_of_mem (wallEval Y hY b i) hd
    rw [Ideal.map_pow] at h
    exact eighth_le_mul _ _ ((ninth_order_bounds _ _ _ (hL b i) (hcube b i)).2 h)

theorem wall_ambient_derivative_mem
    (Y : InternalVar n → MvPowerSeries (GraphVar n) R)
    (hY : ∀ c, Y c ∈ originIdeal R (GraphVar n))
    (I : Ideal (MvPowerSeries (GraphVar n) R)) (b : Bool) (i : Fin d)
    (E : MvPowerSeries (WallVar n i) R)
    (hE : ∀ w, wallEval Y hY b i (pderiv w E) ∈ I) (c : AmbientVar n) :
    subst (graphCoordinates n Y) (pderiv (R := R) c (subst (wallCoordinates b i) E)) ∈ I := by
  rw [pderiv_subst _ (wallCoordinates_centered b i)]
  rw [← substAlgHom_apply (hasSubst_of_constantCoeff_zero (graphCoordinates_centered Y hY))]
  rw [map_sum]
  apply Ideal.sum_mem
  intro w _
  rw [map_mul]
  have hw := hE w
  simp only [wallEval, AlgHom.comp_apply, substAlgHom_apply] at hw
  simp only [substAlgHom_apply]
  exact I.mul_mem_right _ hw

end BoundaryOnly.FormalObstruction.CoefficientRing

namespace BoundaryOnly.FormalObstruction.CoefficientRing
open MvPowerSeries FormalCorrection AlgebraicReplacement
open scoped Classical
variable {R : Type*} [CommRing R] {d : ℕ} {n : Fin d → ℕ}

theorem potential_sub (P Q : (i : Fin d) → MvPowerSeries (WallVar n i) R) :
    potential n (fun i => P i - Q i) = potential n P - potential n Q := by
  unfold potential
  rw [← Finset.sum_sub_distrib]
  apply Finset.sum_congr rfl
  intro i _
  simp only [← substAlgHom_apply (hasSubst_of_constantCoeff_zero (plusCoordinates_centered i)),
    ← substAlgHom_apply (hasSubst_of_constantCoeff_zero (minusCoordinates_centered i)), map_sub]
  ring

theorem gradient_sub (P Q : (i : Fin d) → MvPowerSeries (WallVar n i) R)
    (Y : InternalVar n → MvPowerSeries (GraphVar n) R)
    (hY : ∀ c, Y c ∈ originIdeal R (GraphVar n)) (c : InternalVar n) :
    restrictedGradient n (fun i => P i - Q i) Y c =
      restrictedGradient n P Y c - restrictedGradient n Q Y c := by
  unfold restrictedGradient
  rw [potential_sub, map_sub]
  exact (substAlgHom_apply (hasSubst_of_constantCoeff_zero (graphCoordinates_centered Y hY)) _).symm.trans
    ((map_sub (substAlgHom (R := R) (S := R) (hasSubst_of_constantCoeff_zero (graphCoordinates_centered Y hY))) _ _).trans (by simp only [substAlgHom_apply]))

theorem gradient_mem_of_wall_derivatives
    (E : (i : Fin d) → MvPowerSeries (WallVar n i) R)
    (Y : InternalVar n → MvPowerSeries (GraphVar n) R)
    (hY : ∀ c, Y c ∈ originIdeal R (GraphVar n))
    (I : Ideal (MvPowerSeries (GraphVar n) R))
    (hE : ∀ b i w, wallEval Y hY b i (pderiv w (E i)) ∈ I)
    (c : InternalVar n) : restrictedGradient n E Y c ∈ I := by
  unfold restrictedGradient potential
  rw [map_sum]
  rw [← substAlgHom_apply (hasSubst_of_constantCoeff_zero (graphCoordinates_centered Y hY))]
  rw [map_sum]
  apply Ideal.sum_mem
  intro i _
  rw [map_sub, map_sub]
  simp only [substAlgHom_apply]
  exact I.sub_mem (wall_ambient_derivative_mem Y hY I true i (E i) (hE true i) _)
    (wall_ambient_derivative_mem Y hY I false i (E i) (hE false i) _)

def QuadraticData.replace (Q : QuadraticData (R := R) (n := n))
    (K : (i : Fin d) → Ideal (MvPowerSeries (WallVar n i) R))
    (hK : ∀ i, K i ≤ originIdeal R (WallVar n i))
    (hL : ∀ b i, Ideal.map (wallEval Q.Y Q.centered b i) (K i) ≤ originIdeal R (GraphVar n))
    (hcube : ∀ b i, (Ideal.map (wallEval Q.Y Q.centered b i) (K i))^3 ≤ gradientIdeal n Q.P Q.Y)
    (P : (i : Fin d) → MvPowerSeries (WallVar n i) R)
    (hP : ∀ i, P i - Q.P i ∈ (K i)^9) : QuadraticData (R := R) (n := n) := by
  let E := fun i => P i - Q.P i
  let r := gradientIdeal n Q.P Q.Y
  let m := originIdeal R (GraphVar n)
  have hbounds := wall_error_bounds Q.Y Q.centered K r hL hcube E hP
  have hvalue := hbounds.1
  have hderiv := hbounds.2
  have hgrad : gradientIdeal n P Q.Y = r := by
    apply span_eq_of_generator_congruence m origin_le_jacobson
    intro c
    rw [← gradient_sub P Q.P Q.Y Q.centered c]
    exact gradient_mem_of_wall_derivatives E Q.Y Q.centered (m*r) hderiv c
  have hval : subst (graphCoordinates n Q.Y) (potential n P) -
      subst (graphCoordinates n Q.Y) (potential n Q.P) ∈ r^3 := by
    simp only [← substAlgHom_apply (hasSubst_of_constantCoeff_zero
      (graphCoordinates_centered Q.Y Q.centered)), ← map_sub]
    rw [substAlgHom_apply, ← potential_sub,
      subst_potential_eq_sum _ _ Q.centered]
    apply Ideal.sum_mem
    intro i _
    exact (r^3).sub_mem (hvalue true i) (hvalue false i)
  have hneg : ∀ i, negativeSlopeValue n P Q.Y i - negativeSlopeValue n Q.P Q.Y i ∈ r := by
    intro i
    rw [wallEval_negativeSlope _ _ Q.centered, wallEval_negativeSlope _ _ Q.centered,
      ← map_sub, ← map_sub]
    exact (show m * r ≤ r from Ideal.mul_le_right) (hderiv false i (.inl 0))
  refine ⟨P, Q.Y, ?_, Q.centered, Q.complementary, ?_, ?_, ?_⟩
  · intro i
    have he : E i ∈ (originIdeal R (WallVar n i))^3 :=
      Ideal.pow_le_pow_right (by omega : 3 ≤ 9) ((pow_le_pow_left' (hK i) 9) (hP i))
    simpa only [E, sub_add_cancel] using (originIdeal R (WallVar n i)^3).add_mem he (Q.order_three i)
  · rw [hgrad]
    have hh := (r^2).add_mem (Ideal.pow_le_pow_right (by omega : 2 ≤ 3) hval) Q.graph_square
    simpa only [sub_add_cancel] using hh
  · intro i j l
    rw [hgrad]
    exact Q.positive_cubic i j l
  · intro i j l
    rw [hgrad]
    exact triple_transport_mem r (hneg i) (hneg j) (hneg l) (Q.negative_cubic i j l)

end BoundaryOnly.FormalObstruction.CoefficientRing

end

end OAI