import Mathlib
import OAI.Algebra.FrobeniusObstruction.Obstruction

namespace OAI

noncomputable section
open scoped BigOperators

namespace BoundaryOnly.FormalObstruction.CoefficientRing

abbrev SlopeVar (d : ℕ) := Fin d × Fin 3
abbrev TangentVar {d : ℕ} (n : Fin d → ℕ) := (i : Fin d) × Fin (n i)
abbrev WallVar {d : ℕ} (n : Fin d → ℕ) (i : Fin d) := Fin 3 ⊕ Fin (n i)
abbrev InternalVar {d : ℕ} (n : Fin d → ℕ) := Bool × TangentVar n
abbrev GraphVar {d : ℕ} (n : Fin d → ℕ) := SlopeVar d ⊕ TangentVar n
abbrev AmbientVar {d : ℕ} (n : Fin d → ℕ) := SlopeVar d ⊕ InternalVar n

def originIdeal (k : Type*) [CommRing k] (ι : Type*) : Ideal (MvPowerSeries ι k) :=
  Ideal.span (Set.range (MvPowerSeries.X : ι → MvPowerSeries ι k))

variable {k : Type*} [CommRing k] {d : ℕ} (n : Fin d → ℕ)

def plusCoordinates (i : Fin d) : WallVar n i → MvPowerSeries (AmbientVar n) k
  | .inl j => MvPowerSeries.X (.inl (i, j))
  | .inr y => MvPowerSeries.X (.inr (true, ⟨i, y⟩))

def minusCoordinates (i : Fin d) : WallVar n i → MvPowerSeries (AmbientVar n) k
  | .inl _ => 0
  | .inr y => MvPowerSeries.X (.inr (false, ⟨i, y⟩))

def zeroSlopes (i : Fin d) : WallVar n i → MvPowerSeries (Fin (n i)) k
  | .inl _ => 0
  | .inr y => MvPowerSeries.X y

def potential (P : (i : Fin d) → MvPowerSeries (WallVar n i) k) :
    MvPowerSeries (AmbientVar n) k :=
  ∑ i, (MvPowerSeries.subst (plusCoordinates n i) (P i) -
    MvPowerSeries.subst (minusCoordinates n i) (P i))

def slopeDerivative (P : (i : Fin d) → MvPowerSeries (WallVar n i) k)
    (i : Fin d) : MvPowerSeries (Fin (n i)) k :=
  MvPowerSeries.subst (zeroSlopes n i) (MvPowerSeries.pderiv (.inl 0) (P i))

def graphCoordinates (Y : InternalVar n → MvPowerSeries (GraphVar n) k) :
    AmbientVar n → MvPowerSeries (GraphVar n) k
  | .inl a => MvPowerSeries.X (.inl a)
  | .inr c => Y c

def restrictedGradient (P : (i : Fin d) → MvPowerSeries (WallVar n i) k)
    (Y : InternalVar n → MvPowerSeries (GraphVar n) k) (c : InternalVar n) :
    MvPowerSeries (GraphVar n) k :=
  MvPowerSeries.subst (graphCoordinates n Y)
    (MvPowerSeries.pderiv (.inr c) (potential n P))

def gradientIdeal (P : (i : Fin d) → MvPowerSeries (WallVar n i) k)
    (Y : InternalVar n → MvPowerSeries (GraphVar n) k) :
    Ideal (MvPowerSeries (GraphVar n) k) :=
  Ideal.span (Set.range (restrictedGradient n P Y))

def negativeSlopeValue (P : (i : Fin d) → MvPowerSeries (WallVar n i) k)
    (Y : InternalVar n → MvPowerSeries (GraphVar n) k) (i : Fin d) :
    MvPowerSeries (GraphVar n) k :=
  MvPowerSeries.subst (fun j => Y (false, ⟨i, j⟩)) (slopeDerivative n P i)

def slope (i : Fin d) : MvPowerSeries (GraphVar n) k :=
  MvPowerSeries.X (.inl (i, 0))

def swapBlocks (c : InternalVar n) : InternalVar n := (!c.1, c.2)

def tangentMatrix (Y : InternalVar n → MvPowerSeries (GraphVar n) k) :
    Matrix (InternalVar n) (TangentVar n) k :=
  fun c t => MvPowerSeries.constantCoeff (MvPowerSeries.pderiv (.inr t) (Y c))

def complementaryMatrix (Y : InternalVar n → MvPowerSeries (GraphVar n) k) :
    Matrix (InternalVar n) (InternalVar n) k :=
  fun c bt => if bt.1 then tangentMatrix n Y (swapBlocks n c) bt.2
    else tangentMatrix n Y c bt.2

structure FormalData where
  P : (i : Fin d) → MvPowerSeries (WallVar n i) k
  Y : InternalVar n → MvPowerSeries (GraphVar n) k
  order_three : ∀ i, P i ∈ (originIdeal k (WallVar n i)) ^ 3
  centered : ∀ c, Y c ∈ originIdeal k (GraphVar n)
  complementary : IsUnit (complementaryMatrix n Y).det
  graph_zero : MvPowerSeries.subst (graphCoordinates n Y) (potential n P) = 0
  positive_cubic : ∀ i j l : Fin d,
    slope n i * slope n j * slope n l ∈ gradientIdeal n P Y
  negative_cubic : ∀ i j l : Fin d,
    negativeSlopeValue n P Y i * negativeSlopeValue n P Y j *
      negativeSlopeValue n P Y l ∈ gradientIdeal n P Y

end BoundaryOnly.FormalObstruction.CoefficientRing

namespace BoundaryOnly.FormalObstruction.CoefficientRing
open MvPowerSeries
variable {R S ι κ : Type*} [CommRing R] [CommRing S]

 theorem map_partial (f : R →+* S) (i : ι) (P : MvPowerSeries ι R) :
    MvPowerSeries.map f (pderiv i P) = pderiv i (MvPowerSeries.map f P) := by
  classical
  ext e
  simp only [coeff_map, coeff_pderiv, map_mul, map_add, map_natCast, map_one]

 theorem map_origin (f : R →+* S) :
    Ideal.map (MvPowerSeries.map f) (originIdeal R ι) ≤ originIdeal S ι := by
  rw [originIdeal, Ideal.map_span]
  apply Ideal.span_le.mpr
  rintro _ ⟨_, ⟨i,rfl⟩, rfl⟩
  change MvPowerSeries.map f (X i) ∈ Ideal.span (Set.range (X : ι → MvPowerSeries ι S))
  rw [map_X]
  exact Ideal.subset_span ⟨i,rfl⟩

 theorem map_mem_origin (f : R →+* S) {P : MvPowerSeries ι R}
    (h : P ∈ originIdeal R ι) : MvPowerSeries.map f P ∈ originIdeal S ι :=
  map_origin f (Ideal.mem_map_of_mem (MvPowerSeries.map f) h)

 theorem map_mem_origin_pow (f : R →+* S) (q : ℕ) {P : MvPowerSeries ι R}
    (h : P ∈ (originIdeal R ι)^q) : MvPowerSeries.map f P ∈ (originIdeal S ι)^q := by
  have hp := Ideal.mem_map_of_mem (MvPowerSeries.map f) h
  rw [Ideal.map_pow] at hp
  exact Ideal.pow_right_mono (map_origin f) q hp

 theorem origin_constant {P : MvPowerSeries ι R} (h : P ∈ originIdeal R ι) :
    constantCoeff P = 0 := by
  have hi : originIdeal R ι ≤ RingHom.ker (constantCoeff : MvPowerSeries ι R →+* R) := by
    apply Ideal.span_le.mpr
    rintro _ ⟨i,rfl⟩
    change constantCoeff (X i : MvPowerSeries ι R) = 0
    exact constantCoeff_X i
  exact hi h

 theorem hasSubst_origin [Finite ι] (v : ι → MvPowerSeries κ R)
    (hv : ∀ i, v i ∈ originIdeal R κ) : HasSubst v :=
  hasSubst_of_constantCoeff_zero (fun i => origin_constant (hv i))

end BoundaryOnly.FormalObstruction.CoefficientRing

namespace BoundaryOnly.FormalObstruction.CoefficientRing
open MvPowerSeries
variable {R S : Type*} [CommRing R] [CommRing S] {d : ℕ} (n : Fin d → ℕ)

 theorem plus_hasSubst (i : Fin d) : HasSubst (plusCoordinates (k := R) n i) := by
  apply hasSubst_of_constantCoeff_zero
  rintro (j | y) <;> simp only [plusCoordinates, constantCoeff_X]

 theorem minus_hasSubst (i : Fin d) : HasSubst (minusCoordinates (k := R) n i) := by
  apply hasSubst_of_constantCoeff_zero
  rintro (j | y) <;> simp only [minusCoordinates, map_zero, constantCoeff_X]

 theorem zeroSlopes_hasSubst (i : Fin d) : HasSubst (zeroSlopes (k := R) n i) := by
  apply hasSubst_of_constantCoeff_zero
  rintro (j | y) <;> simp only [zeroSlopes, map_zero, constantCoeff_X]

 theorem map_plus (f : R →+* S) (i : Fin d) :
    (fun j => MvPowerSeries.map f (plusCoordinates n i j)) = plusCoordinates n i := by
  funext j
  cases j <;> simp only [plusCoordinates, map_X]

 theorem map_minus (f : R →+* S) (i : Fin d) :
    (fun j => MvPowerSeries.map f (minusCoordinates n i j)) = minusCoordinates n i := by
  funext j
  cases j <;> simp only [minusCoordinates, map_X, map_zero]

 theorem map_zeroSlopes (f : R →+* S) (i : Fin d) :
    (fun j => MvPowerSeries.map f (zeroSlopes n i j)) = zeroSlopes n i := by
  funext j
  cases j <;> simp only [zeroSlopes, map_X, map_zero]

 theorem map_potential (f : R →+* S) (P : (i : Fin d) → MvPowerSeries (WallVar n i) R) :
    MvPowerSeries.map f (potential n P) =
      potential n (fun i => MvPowerSeries.map f (P i)) := by
  simp only [potential, map_sum, map_sub, map_subst (plus_hasSubst n _),
    map_subst (minus_hasSubst n _), map_plus, map_minus]

 theorem map_slopeDerivative (f : R →+* S) (P : (i : Fin d) → MvPowerSeries (WallVar n i) R)
    (i : Fin d) :
    MvPowerSeries.map f (slopeDerivative n P i) =
      slopeDerivative n (fun i => MvPowerSeries.map f (P i)) i := by
  simp only [slopeDerivative, map_subst (zeroSlopes_hasSubst n i), map_zeroSlopes, map_partial]

 theorem graph_hasSubst (Y : InternalVar n → MvPowerSeries (GraphVar n) R)
    (hY : ∀ c, Y c ∈ originIdeal R (GraphVar n)) : HasSubst (graphCoordinates n Y) := by
  apply hasSubst_of_constantCoeff_zero
  rintro (a | c)
  · exact constantCoeff_X _
  · exact origin_constant (hY c)

 theorem map_graph (f : R →+* S) (Y : InternalVar n → MvPowerSeries (GraphVar n) R) :
    (fun j => MvPowerSeries.map f (graphCoordinates n Y j)) =
      graphCoordinates n (fun c => MvPowerSeries.map f (Y c)) := by
  funext j
  cases j <;> simp only [graphCoordinates, map_X]

 theorem map_restrictedGradient (f : R →+* S)
    (P : (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) :
    MvPowerSeries.map f (restrictedGradient n P Y c) =
      restrictedGradient n (fun i => MvPowerSeries.map f (P i))
        (fun c => MvPowerSeries.map f (Y c)) c := by
  simp only [restrictedGradient, map_subst (graph_hasSubst n Y hY), map_graph,
    map_partial, map_potential]

 theorem map_gradientIdeal (f : R →+* S)
    (P : (i : Fin d) → MvPowerSeries (WallVar n i) R)
    (Y : InternalVar n → MvPowerSeries (GraphVar n) R)
    (hY : ∀ c, Y c ∈ originIdeal R (GraphVar n)) :
    Ideal.map (MvPowerSeries.map f) (gradientIdeal n P Y) =
      gradientIdeal n (fun i => MvPowerSeries.map f (P i))
        (fun c => MvPowerSeries.map f (Y c)) := by
  simp only [gradientIdeal, Ideal.map_span, ← Set.range_comp]
  apply congrArg Ideal.span
  apply congrArg Set.range
  funext c
  exact map_restrictedGradient n f P Y hY c

 theorem map_negativeSlopeValue (f : R →+* S)
    (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) :
    MvPowerSeries.map f (negativeSlopeValue n P Y i) =
      negativeSlopeValue n (fun i => MvPowerSeries.map f (P i))
        (fun c => MvPowerSeries.map f (Y c)) i := by
  rw [negativeSlopeValue, map_subst (hasSubst_origin _ (fun y => hY (false,⟨i,y⟩))),
    map_slopeDerivative]
  rfl

 theorem map_complementary (f : R →+* S)
    (Y : InternalVar n → MvPowerSeries (GraphVar n) R) :
    (complementaryMatrix n Y).map f =
      complementaryMatrix n (fun c => MvPowerSeries.map f (Y c)) := by
  ext c bt
  simp only [Matrix.map_apply, complementaryMatrix]
  split_ifs <;> simp only [tangentMatrix, ← map_partial, constantCoeff_map]

end BoundaryOnly.FormalObstruction.CoefficientRing

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

def FormalData.map (D : FormalData (k := R) n) (f : R →+* S) : FormalData (k := S) n where
  P := fun i => MvPowerSeries.map f (D.P i)
  Y := fun c => MvPowerSeries.map f (D.Y c)
  order_three := fun i => map_mem_origin_pow f 3 (D.order_three i)
  centered := fun c => map_mem_origin f (D.centered c)
  complementary := by
    rw [← map_complementary]
    change IsUnit (f.mapMatrix (complementaryMatrix n D.Y)).det
    rw [← RingHom.map_det]
    exact D.complementary.map f
  graph_zero := by
    have h := congrArg (MvPowerSeries.map f) D.graph_zero
    simpa only [MvPowerSeries.map_subst (graph_hasSubst n D.Y D.centered), map_potential,
      map_graph, map_zero] using h
  positive_cubic := by
    intro i j l
    have h := Ideal.mem_map_of_mem (MvPowerSeries.map f) (D.positive_cubic i j l)
    rw [map_gradientIdeal n f D.P D.Y D.centered] at h
    simpa only [map_mul, slope, map_X] using h
  negative_cubic := by
    intro i j l
    have h := Ideal.mem_map_of_mem (MvPowerSeries.map f) (D.negative_cubic i j l)
    rw [map_gradientIdeal n f D.P D.Y D.centered] at h
    simpa only [map_mul, map_negativeSlopeValue n f D.P D.Y D.centered] using h

variable {k : Type*} [Field k]

def FormalData.toField (D : FormalData (k := k) n) : BoundaryOnly.FormalObstruction.FormalData (k := k) n where
  P := D.P
  Y := D.Y
  order_three := D.order_three
  centered := D.centered
  complementary := D.complementary.ne_zero
  graph_zero := D.graph_zero
  positive_cubic := D.positive_cubic
  negative_cubic := D.negative_cubic

end BoundaryOnly.FormalObstruction.CoefficientRing

end

end OAI