import Mathlib
import OAI.Algebra.FiniteTensor.BoxCoefficients

namespace OAI

/-! Scalar finite equations reconstructing every squarefree component and primitive. -/

noncomputable section
open scoped BigOperators

namespace PD4Tensor.Spreading
noncomputable section
open scoped BigOperators
variable {A σ τ : Type*} [CommRing A] {m : ℕ}

 
def assembleBox (f : Box m → MvPowerSeries σ A) : MvPowerSeries σ (Parameters A m) :=
  ∑ q, MvPowerSeries.C (boxMonomial A m q) *
    MvPowerSeries.map (algebraMap A (Parameters A m)) (f q)

@[simp] theorem assembleBox_boxSeries (f : MvPowerSeries σ (Parameters A m)) :
    assembleBox (boxSeries A m · f)=f := sum_boxSeries A m f

 theorem boxCoeff_mul_algebraMap (q : Box m) (x : Parameters A m) (a : A) :
    boxCoeff A m q (x*algebraMap A (Parameters A m) a)=boxCoeff A m q x*a := by
  rw [mul_comm,←Algebra.smul_def,map_smul,smul_eq_mul,mul_comm]

@[simp] theorem boxSeries_assembleBox (q : Box m) (f : Box m → MvPowerSeries σ A) :
    boxSeries A m q (assembleBox f)=f q := by
  classical
  ext d
  simp only [coeff_boxSeries,assembleBox,map_sum,MvPowerSeries.coeff_C_mul,
    MvPowerSeries.coeff_map,boxCoeff_mul_algebraMap,boxCoeff_boxMonomial,
    ite_mul,one_mul,zero_mul]
  simp

 theorem boxSeries_ext (f g : MvPowerSeries σ (Parameters A m))
    (h : ∀ q,boxSeries A m q f=boxSeries A m q g) : f=g := by
  rw [←assembleBox_boxSeries f,←assembleBox_boxSeries g]
  congr 1
  funext q
  exact h q

@[simp] theorem boxSeries_zero (q : Box m) :
    boxSeries A m q (0 : MvPowerSeries σ (Parameters A m))=0 := by
  ext d
  simp only [coeff_boxSeries,map_zero]

@[simp] theorem boxSeries_add (q : Box m) (f g : MvPowerSeries σ (Parameters A m)) :
    boxSeries A m q (f+g)=boxSeries A m q f+boxSeries A m q g := by
  ext d
  simp only [coeff_boxSeries,map_add]

@[simp] theorem boxSeries_sub (q : Box m) (f g : MvPowerSeries σ (Parameters A m)) :
    boxSeries A m q (f-g)=boxSeries A m q f-boxSeries A m q g := by
  ext d
  simp only [coeff_boxSeries,map_sub]

 theorem subst_assembleBox (a : σ → MvPowerSeries τ A) (ha : MvPowerSeries.HasSubst a)
    (f : Box m → MvPowerSeries σ A) :
    MvPowerSeries.subst (fun i=>MvPowerSeries.map (algebraMap A (Parameters A m)) (a i))
      (assembleBox f) = assembleBox (fun q=>MvPowerSeries.subst a (f q)) := by
  let hm := ha.map (algebraMap A (Parameters A m))
  rw [assembleBox,←MvPowerSeries.substAlgHom_apply hm,map_sum]
  apply Finset.sum_congr rfl
  intro q _
  rw [map_mul,MvPowerSeries.substAlgHom_apply,MvPowerSeries.subst_C,
    MvPowerSeries.substAlgHom_apply,←MvPowerSeries.map_subst ha]

 

theorem boxSeries_subst (a : σ → MvPowerSeries τ A) (ha : MvPowerSeries.HasSubst a)
    (q : Box m) (f : MvPowerSeries σ (Parameters A m)) :
    boxSeries A m q (MvPowerSeries.subst
      (fun i=>MvPowerSeries.map (algebraMap A (Parameters A m)) (a i)) f)=
      MvPowerSeries.subst a (boxSeries A m q f) := by
  conv_lhs => rw [←assembleBox_boxSeries f,subst_assembleBox a ha,boxSeries_assembleBox]

 

def centerSeries (f : MvPowerSeries σ A) : MvPowerSeries σ A :=
  f-MvPowerSeries.C (MvPowerSeries.constantCoeff f)

@[simp] theorem centerSeries_zero (f : MvPowerSeries σ A) :
    MvPowerSeries.constantCoeff (centerSeries f)=0 := by
  simp [centerSeries]

 theorem centerFamily_hasSubst [Finite σ] (f : σ → MvPowerSeries τ A) :
    MvPowerSeries.HasSubst (fun i=>centerSeries (f i)) :=
  MvPowerSeries.hasSubst_of_constantCoeff_zero (fun _=>centerSeries_zero _)

 def affineUnknown (i : σ) (c : A) : MvPowerSeries σ A :=
  MvPowerSeries.X i+MvPowerSeries.C c

 theorem subst_affineUnknown (a : σ → MvPowerSeries τ A) (ha : MvPowerSeries.HasSubst a)
    (i : σ) (c : A) :
    MvPowerSeries.subst a (affineUnknown i c)=a i+MvPowerSeries.C c := by
  simp only [affineUnknown,MvPowerSeries.subst_add ha,MvPowerSeries.subst_X ha,
    MvPowerSeries.subst_C]

 theorem subst_center_affine [Finite σ] (f : σ → MvPowerSeries τ A) (i : σ) :
    MvPowerSeries.subst (fun j=>centerSeries (f j))
      (affineUnknown i (MvPowerSeries.constantCoeff (f i)))=f i := by
  rw [subst_affineUnknown _ (centerFamily_hasSubst f)]
  simp only [centerSeries,sub_add_cancel]

end
end PD4Tensor.Spreading

namespace PD4Tensor.Spreading
noncomputable section
open scoped BigOperators
variable {K : Type*} [Field K] {l m d c : ℕ} {n : Fin l → ℕ}
  {e : ((i : Fin l) × Fin (n i)) ≃ Fin d ⊕ Fin c} {active : Fin m ↪ Fin l}

abbrev LeftUnknown (V : Type*) (m : ℕ) := (V × Box m) ⊕ (Triple m × V × Box m)
abbrev RightUnknown (V : Type*) (m : ℕ) := V ⊕ (Triple m × V)
abbrev LeftEquation (m : ℕ) := Box m ⊕ (Triple m × Box m)
abbrev RightEquation (m : ℕ) := Unit ⊕ Triple m

variable (M : TensorModel K (fun i=>Fin (n i)) m d c e active)
  (W : TensorPrimitives K (fun i=>Fin (n i)) m M)

 

def leftOriginal : LeftUnknown ((i : Fin l) × Fin (n i)) m → MvPowerSeries (Fin d) K :=
  Sum.elim (fun vq=>boxSeries K m vq.2 (M.H vq.1))
    (fun tvq=>boxSeries K m tvq.2.2 (W.left tvq.1 tvq.2.1))

def rightOriginal : RightUnknown ((i : Fin l) × Fin (n i)) m → MvPowerSeries (Fin c) K :=
  Sum.elim M.G (fun tv=>W.right tv.1 tv.2)

def universalLeftH (v : (i : Fin l) × Fin (n i)) :
    MvPowerSeries (LeftUnknown ((i : Fin l) × Fin (n i)) m) (Parameters K m) :=
  assembleBox (fun q=>affineUnknown (.inl (v,q))
    (MvPowerSeries.constantCoeff (boxSeries K m q (M.H v))))

def universalLeftP (t : Triple m) (v : (i : Fin l) × Fin (n i)) :
    MvPowerSeries (LeftUnknown ((i : Fin l) × Fin (n i)) m) (Parameters K m) :=
  assembleBox (fun q=>affineUnknown (.inr (t,v,q))
    (MvPowerSeries.constantCoeff (boxSeries K m q (W.left t v))))

def universalRightG (v : (i : Fin l) × Fin (n i)) :
    MvPowerSeries (RightUnknown ((i : Fin l) × Fin (n i)) m) K :=
  affineUnknown (.inl v) (MvPowerSeries.constantCoeff (M.G v))

def universalRightP (t : Triple m) (v : (i : Fin l) × Fin (n i)) :
    MvPowerSeries (RightUnknown ((i : Fin l) × Fin (n i)) m) K :=
  affineUnknown (.inr (t,v)) (MvPowerSeries.constantCoeff (W.right t v))

 theorem constantCoeff_universalLeftH (v : (i : Fin l) × Fin (n i)) :
    MvPowerSeries.constantCoeff (universalLeftH M v)=MvPowerSeries.constantCoeff (M.H v) := by
  calc
    _ = MvPowerSeries.constantCoeff (assembleBox (fun q=>boxSeries K m q (M.H v))) := by
      simp only [universalLeftH,assembleBox,map_sum,map_mul,MvPowerSeries.constantCoeff_C,
        MvPowerSeries.constantCoeff_map,affineUnknown,map_add,MvPowerSeries.constantCoeff_X,map_zero,
        zero_add]
    _ = _ := by rw [assembleBox_boxSeries]

 theorem hasSubst_universalLeftH : MvPowerSeries.HasSubst (universalLeftH M) := by
  apply hasSubst_parameters K m
  intro v
  rw [constantCoeff_universalLeftH]
  exact M.H_zero v

 theorem hasSubst_universalRightG : MvPowerSeries.HasSubst (universalRightG M) := by
  apply MvPowerSeries.hasSubst_of_constantCoeff_zero
  intro v
  simp only [universalRightG,affineUnknown,map_add,MvPowerSeries.constantCoeff_X,
    MvPowerSeries.constantCoeff_C,zero_add,M.G_zero]

 

def universalLeftEquation : LeftEquation m →
    MvPowerSeries (LeftUnknown ((i : Fin l) × Fin (n i)) m) K :=
  Sum.elim (fun q=>boxSeries K m q (MvPowerSeries.subst (universalLeftH M)
    (deformed K (fun i=>Fin (n i)) m M.F active M.b)))
    (fun tq=>boxSeries K m tq.2 ((∑ v,universalLeftP M W tq.1 v *
      MvPowerSeries.subst (universalLeftH M) (MvPowerSeries.pderiv v
        (deformed K (fun i=>Fin (n i)) m M.F active M.b))) -
      MvPowerSeries.C (parameter K m tq.1.val.1 * parameter K m tq.1.val.2.1 *
        parameter K m tq.1.val.2.2)))

def universalRightEquation : RightEquation m →
    MvPowerSeries (RightUnknown ((i : Fin l) × Fin (n i)) m) K :=
  Sum.elim (fun _=>MvPowerSeries.subst (universalRightG M) (potential K (fun i=>Fin (n i)) M.F))
    (fun t=>(∑ v,universalRightP M W t v * MvPowerSeries.subst (universalRightG M)
      (MvPowerSeries.pderiv v (potential K (fun i=>Fin (n i)) M.F))) -
      MvPowerSeries.subst (universalRightG M)
        (perturbation K (fun i=>Fin (n i)) m active M.b t.val.1 *
          perturbation K (fun i=>Fin (n i)) m active M.b t.val.2.1 *
          perturbation K (fun i=>Fin (n i)) m active M.b t.val.2.2))

 theorem eval_universalLeftH (v : (i : Fin l) × Fin (n i)) :
    MvPowerSeries.subst (fun i=>MvPowerSeries.map (algebraMap K (Parameters K m))
      (centerSeries (leftOriginal M W i))) (universalLeftH M v)=M.H v := by
  rw [universalLeftH,subst_assembleBox _ (centerFamily_hasSubst _)]
  convert assembleBox_boxSeries (M.H v) using 1
  congr 1
  funext q
  exact subst_center_affine (leftOriginal M W) (.inl (v,q))

 theorem eval_universalLeftP (t : Triple m) (v : (i : Fin l) × Fin (n i)) :
    MvPowerSeries.subst (fun i=>MvPowerSeries.map (algebraMap K (Parameters K m))
      (centerSeries (leftOriginal M W i))) (universalLeftP M W t v)=W.left t v := by
  rw [universalLeftP,subst_assembleBox _ (centerFamily_hasSubst _)]
  convert assembleBox_boxSeries (W.left t v) using 1
  congr 1
  funext q
  exact subst_center_affine (leftOriginal M W) (.inr (t,v,q))

 theorem eval_universalRightG (v : (i : Fin l) × Fin (n i)) :
    MvPowerSeries.subst (fun i=>centerSeries (rightOriginal M W i))
      (universalRightG M v)=M.G v :=
  subst_center_affine (rightOriginal M W) (.inl v)

 theorem eval_universalRightP (t : Triple m) (v : (i : Fin l) × Fin (n i)) :
    MvPowerSeries.subst (fun i=>centerSeries (rightOriginal M W i))
      (universalRightP M W t v)=W.right t v :=
  subst_center_affine (rightOriginal M W) (.inr (t,v))

 theorem original_solves_left (j : LeftEquation m) :
    MvPowerSeries.subst (fun i=>centerSeries (leftOriginal M W i))
      (universalLeftEquation M W j)=0 := by
  let a := fun i=>centerSeries (leftOriginal M W i)
  have ha := centerFamily_hasSubst (leftOriginal M W)
  have hma := ha.map (algebraMap K (Parameters K m))
  have hcomp (f : MvPowerSeries ((i : Fin l) × Fin (n i)) (Parameters K m)) :
      MvPowerSeries.subst (fun i=>MvPowerSeries.map (algebraMap K (Parameters K m)) (a i))
        (MvPowerSeries.subst (universalLeftH M) f)=MvPowerSeries.subst M.H f := by
    rw [MvPowerSeries.subst_comp_subst_apply (hasSubst_universalLeftH M) hma]
    simp only [eval_universalLeftH]
  rcases j with q|tq
  · change MvPowerSeries.subst a (boxSeries K m q _)=0
    rw [←boxSeries_subst a ha,hcomp,M.left_vanishing,boxSeries_zero]
  · change MvPowerSeries.subst a (boxSeries K m tq.2 _)=0
    rw [←boxSeries_subst a ha,MvPowerSeries.subst_sub hma,
      ←MvPowerSeries.substAlgHom_apply hma,map_sum]
    simp only [map_mul,MvPowerSeries.substAlgHom_apply,eval_universalLeftP]
    dsimp only [a] at hcomp
    simp only [hcomp,MvPowerSeries.subst_mul hma,MvPowerSeries.subst_C,W.left_eq,map_mul,sub_self,boxSeries_zero]

 theorem original_solves_right (j : RightEquation m) :
    MvPowerSeries.subst (fun i=>centerSeries (rightOriginal M W i))
      (universalRightEquation M W j)=0 := by
  let a := fun i=>centerSeries (rightOriginal M W i)
  have ha := centerFamily_hasSubst (rightOriginal M W)
  have hcomp (f : MvPowerSeries ((i : Fin l) × Fin (n i)) K) :
      MvPowerSeries.subst a (MvPowerSeries.subst (universalRightG M) f)=
        MvPowerSeries.subst M.G f := by
    rw [MvPowerSeries.subst_comp_subst_apply (hasSubst_universalRightG M) ha]
    simp only [eval_universalRightG]
  rcases j with u|t
  · exact (hcomp _).trans M.right_vanishing
  · change MvPowerSeries.subst a ((∑ v,_) - _)=0
    rw [MvPowerSeries.subst_sub ha,←MvPowerSeries.substAlgHom_apply ha,map_sum]
    simp only [map_mul,MvPowerSeries.substAlgHom_apply,eval_universalRightP]
    dsimp only [a] at hcomp
    simp only [hcomp,W.right_eq,sub_self]

end
end PD4Tensor.Spreading
end

end OAI