import OAI.NumberTheory.SingleFold.Model

namespace OAI

namespace SingleFold.Compiler

@[simp] lemma elim_comp_map {α β γ δ ε : Type} (x : γ → ε) (w : δ → ε)
    (f : α → γ) (g : β → δ) :
    Sum.elim x w ∘ Sum.map f g = Sum.elim (x ∘ f) (w ∘ g) := by
  funext i; cases i <;> rfl

@[simp] lemma elim_comp_assoc {α β γ δ : Type} (x : α → δ) (w : β ⊕ γ → δ) :
    Sum.elim x w ∘ (Equiv.sumAssoc α β γ) =
      Sum.elim (Sum.elim x (w ∘ Sum.inl)) (w ∘ Sum.inr) := by
  funext i; rcases i with (i|i)|i <;> rfl

structure Representation {α : Type} (R : (α → ℕ) → Prop) where
  vars : Type
  finite : Finite vars
  poly : Poly (α ⊕ vars)
  sound : ∀ x w, poly (Sum.elim x w) = 0 → R x
  complete : ∀ x, R x → ∃ w, poly (Sum.elim x w) = 0
  unique : ∀ x w w', poly (Sum.elim x w) = 0 → poly (Sum.elim x w') = 0 → w = w'

attribute [instance] Representation.finite

def SF {α : Type} (R : (α → ℕ) → Prop) : Prop := Nonempty (Representation R)

namespace Representation
variable {α β γ : Type} {R S : (α → ℕ) → Prop}

noncomputable def congr (r : Representation R) (h : ∀ x, R x ↔ S x) : Representation S where
  vars := r.vars
  finite := r.finite
  poly := r.poly
  sound x w hw := (h x).mp (r.sound x w hw)
  complete x hx := r.complete x ((h x).mpr hx)
  unique := r.unique

noncomputable def atom (p : Poly α) : Representation (fun x => p x = 0) where
  vars := Empty
  finite := inferInstance
  poly := p.map Sum.inl
  sound _x _w hw := hw
  complete _x hx := ⟨Empty.elim,hx⟩
  unique _x _w _w' _ _ := funext fun i => Empty.elim i

noncomputable def reindex (r : Representation R) (f : α → β) :
    Representation (fun x => R (x ∘ f)) where
  vars := r.vars
  finite := r.finite
  poly := r.poly.map (Sum.map f id)
  sound x w hw := r.sound (x ∘ f) w (by simpa using hw)
  complete x hx := by simpa using r.complete (x ∘ f) hx
  unique x w w' hw hw' := r.unique (x ∘ f) w w' (by simpa using hw) (by simpa using hw')

noncomputable def and (r : Representation R) (s : Representation S) :
    Representation (fun x => R x ∧ S x) := by
  let p : Poly (α ⊕ (r.vars ⊕ s.vars)) := r.poly.map (Sum.map id Sum.inl)
  let q : Poly (α ⊕ (r.vars ⊕ s.vars)) := s.poly.map (Sum.map id Sum.inr)
  have eval (x : α → ℕ) (w : r.vars ⊕ s.vars → ℕ) :
      (p*p+q*q) (Sum.elim x w) = 0 ↔
      r.poly (Sum.elim x (w ∘ Sum.inl)) = 0 ∧
      s.poly (Sum.elim x (w ∘ Sum.inr)) = 0 := by
    simp only [p,q,Poly.add_apply,Poly.mul_apply,Poly.map_apply,elim_comp_map,Function.comp_id]
    constructor
    · intro h
      constructor <;> nlinarith only [sq_nonneg (r.poly (Sum.elim x (w ∘ Sum.inl))),
        sq_nonneg (s.poly (Sum.elim x (w ∘ Sum.inr))),h]
    · rintro ⟨hp,hq⟩
      rw [hp,hq]; ring
  refine ⟨r.vars ⊕ s.vars,inferInstance,p*p+q*q,?_,?_,?_⟩
  · intro x w hw
    obtain ⟨hp,hq⟩ := (eval x w).mp hw
    exact ⟨r.sound _ _ hp,s.sound _ _ hq⟩
  · rintro x ⟨hx,hy⟩
    obtain ⟨w,hw⟩ := r.complete x hx
    obtain ⟨v,hv⟩ := s.complete x hy
    exact ⟨Sum.elim w v,(eval _ _).mpr ⟨hw,hv⟩⟩
  · intro x w w' hw hw'
    obtain ⟨hp,hq⟩ := (eval x w).mp hw
    obtain ⟨hp',hq'⟩ := (eval x w').mp hw'
    have hr := r.unique _ _ _ hp hp'
    have hs := s.unique _ _ _ hq hq'
    funext i
    cases i with
    | inl i => exact congrFun hr i
    | inr i => exact congrFun hs i

noncomputable def ex {R : (α ⊕ β → ℕ) → Prop} [Finite β]
    (r : Representation R)
    (hu : ∀ x y y', R (Sum.elim x y) → R (Sum.elim x y') → y=y') :
    Representation (fun x => ∃ y, R (Sum.elim x y)) := by
  let p := r.poly.map (Equiv.sumAssoc α β r.vars)
  have eval (x : α → ℕ) (w : β ⊕ r.vars → ℕ) :
      p (Sum.elim x w) = r.poly (Sum.elim (Sum.elim x (w ∘ Sum.inl)) (w ∘ Sum.inr)) := by simp [p]
  refine ⟨β ⊕ r.vars,inferInstance,p,?_,?_,?_⟩
  · intro x w hw
    exact ⟨w ∘ Sum.inl,r.sound _ _ ((eval _ _).symm.trans hw)⟩
  · rintro x ⟨y,hy⟩
    obtain ⟨w,hw⟩ := r.complete (Sum.elim x y) hy
    exact ⟨Sum.elim y w,(eval _ _).trans hw⟩
  · intro x w w' hw hw'
    rw [eval] at hw hw'
    have h := hu x (w ∘ Sum.inl) (w' ∘ Sum.inl) (r.sound _ _ hw) (r.sound _ _ hw')
    have hh : w ∘ Sum.inr = w' ∘ Sum.inr := by
      apply r.unique (Sum.elim x (w ∘ Sum.inl))
      · exact hw
      · rw [h]; exact hw'
    funext i
    cases i with
    | inl i => exact congrFun h i
    | inr i => exact congrFun hh i

noncomputable def zeros (β : Type) [Finite β] : Poly β := by
  classical
  let := Fintype.ofFinite β
  exact Poly.sumsq (Finset.univ.toList.map Poly.proj)

lemma zeros_eq {β : Type} [Finite β] (w : β → ℕ) : zeros β w = 0 ↔ w=0 := by
  classical
  let := Fintype.ofFinite β
  rw [zeros,Poly.sumsq_eq_zero,List.forall_map_iff]
  simp only [List.forall_iff_forall_mem,Finset.mem_toList,Finset.mem_univ,
    true_implies,Function.comp_apply,Poly.proj_apply,Int.natCast_eq_zero]
  exact ⟨fun h => funext h,fun h i => congrFun h i⟩

noncomputable def or (r : Representation R) (s : Representation S)
    (hd : ∀ x, ¬(R x ∧ S x)) : Representation (fun x => R x ∨ S x) := by
  let V := Unit ⊕ (r.vars ⊕ s.vars)
  let b : Poly (α ⊕ V) := Poly.proj (Sum.inr (Sum.inl ()))
  let p : Poly (α ⊕ V) := r.poly.map (Sum.map id (Sum.inr ∘ Sum.inl))
  let q : Poly (α ⊕ V) := s.poly.map (Sum.map id (Sum.inr ∘ Sum.inr))
  let z : Poly (α ⊕ V) := (zeros r.vars).map (Sum.inr ∘ Sum.inr ∘ Sum.inl)
  let z' : Poly (α ⊕ V) := (zeros s.vars).map (Sum.inr ∘ Sum.inr ∘ Sum.inr)
  let L := [b*(b-1),b*p,(1-b)*q,(1-b)*z,b*z']
  have eval (x : α → ℕ) (w : V → ℕ) :
      Poly.sumsq L (Sum.elim x w)=0 ↔
      (w (Sum.inl ())=1 ∧ r.poly (Sum.elim x (w ∘ Sum.inr ∘ Sum.inl))=0 ∧
        w ∘ Sum.inr ∘ Sum.inr=0) ∨
      (w (Sum.inl ())=0 ∧ s.poly (Sum.elim x (w ∘ Sum.inr ∘ Sum.inr))=0 ∧
        w ∘ Sum.inr ∘ Sum.inl=0) := by
    rw [Poly.sumsq_eq_zero]
    simp only [L,List.Forall,Poly.mul_apply,Poly.sub_apply,
      Poly.one_apply,p,q,z,z',b,Poly.proj_apply,Poly.map_apply,elim_comp_map,Function.comp_id]
    constructor
    · rintro ⟨h,hp,hq,hz,hz'⟩
      rcases mul_eq_zero.mp h with h|h
      · have hb : w (Sum.inl ())=0 := by exact_mod_cast h
        right
        refine ⟨hb,?_,?_⟩
        · simpa [hb] using hq
        · apply (zeros_eq _).mp
          simpa [hb,Function.comp_def] using hz
      · have hb : w (Sum.inl ())=1 := by exact_mod_cast (sub_eq_zero.mp h)
        left
        refine ⟨hb,?_,?_⟩
        · simpa [hb] using hp
        · apply (zeros_eq _).mp
          simpa [hb,Function.comp_def] using hz'
    · rintro (⟨hb,hp,hz⟩|⟨hb,hq,hz⟩)
      · have hh := (zeros_eq _).mpr hz
        simpa [hb,Function.comp_def] using And.intro hp hh
      · have hh := (zeros_eq _).mpr hz
        simpa [hb,Function.comp_def] using And.intro hq hh
  refine ⟨V,inferInstance,Poly.sumsq L,?_,?_,?_⟩
  · intro x w hw
    rcases (eval _ _).mp hw with ⟨_,hp,_⟩|⟨_,hq,_⟩
    · exact Or.inl (r.sound _ _ hp)
    · exact Or.inr (s.sound _ _ hq)
  · intro x hx
    rcases hx with hx|hx
    · obtain ⟨w,hw⟩ := r.complete x hx
      exact ⟨Sum.elim (fun _ => 1) (Sum.elim w 0),(eval _ _).mpr (Or.inl ⟨rfl,hw,rfl⟩)⟩
    · obtain ⟨w,hw⟩ := s.complete x hx
      exact ⟨Sum.elim (fun _ => 0) (Sum.elim 0 w),(eval _ _).mpr (Or.inr ⟨rfl,hw,rfl⟩)⟩
  · intro x w w' hw hw'
    rcases (eval _ _).mp hw with ⟨hb,hp,hz⟩|⟨hb,hq,hz⟩ <;>
      rcases (eval _ _).mp hw' with ⟨hb',hp',hz'⟩|⟨hb',hq',hz'⟩
    · have hh := r.unique _ _ _ hp hp'
      funext i
      rcases i with ⟨⟩|(i|i)
      · exact hb.trans hb'.symm
      · exact congrFun hh i
      · exact (congrFun hz i).trans (congrFun hz' i).symm
    · exact False.elim (hd x ⟨r.sound _ _ hp,s.sound _ _ hq'⟩)
    · exact False.elim (hd x ⟨r.sound _ _ hp',s.sound _ _ hq⟩)
    · have hh := s.unique _ _ _ hq hq'
      funext i
      rcases i with ⟨⟩|(i|i)
      · exact hb.trans hb'.symm
      · exact (congrFun hz i).trans (congrFun hz' i).symm
      · exact congrFun hh i

noncomputable def allFin : ∀ (n : ℕ) (R : Fin n → (α → ℕ) → Prop),
    (∀ i, Representation (R i)) → Representation (fun x => ∀ i, R i x)
  | 0, R, _ => (atom (Poly.const 0)).congr (by simp)
  | n+1, R, r => ((r 0).and (allFin n (fun i => R i.succ) (fun i => r i.succ))).congr
      (fun x => by rw [Fin.forall_fin_succ])

noncomputable def all [Finite β] (R : β → (α → ℕ) → Prop) (r : ∀ i, Representation (R i)) :
    Representation (fun x => ∀ i, R i x) := by
  let := Fintype.ofFinite β
  let e := Fintype.equivFin β
  exact (allFin _ (fun i => R (e.symm i)) (fun i => r (e.symm i))).congr
    (fun _ => by
      constructor
      · intro h i; simpa using h (e i)
      · intro h i; exact h (e.symm i))

noncomputable def eq (p q : Poly α) : Representation (fun x => p x=q x) :=
  (atom (p-q)).congr (by intro x; simp only [Poly.sub_apply,sub_eq_zero])

noncomputable def le (p q : Poly α) : Representation (fun x => p x≤q x) := by
  let a : Poly (α ⊕ Unit) := (p.map Sum.inl)+Poly.proj (Sum.inr ())
  let b : Poly (α ⊕ Unit) := q.map Sum.inl
  let r := eq a b
  have hu : ∀ (x : α → ℕ) (y y' : Unit → ℕ),
      a (Sum.elim x y) = b (Sum.elim x y) →
      a (Sum.elim x y') = b (Sum.elim x y') → y=y' := by
    intro x y y' h h'
    change p x+(y ():ℤ)=q x at h
    change p x+(y' ():ℤ)=q x at h'
    have hh : y () = y' () := by omega
    funext i
    exact (congrArg y (Subsingleton.elim i ())).trans (hh.trans (congrArg y' (Subsingleton.elim () i)))
  exact (r.ex hu).congr (by
    intro x
    change (∃ y : Unit → ℕ, p x+(y ():ℤ)=q x) ↔ _
    constructor
    · rintro ⟨y,hy⟩; omega
    · intro h
      exact ⟨fun _ => (q x-p x).toNat,by rw [Int.toNat_of_nonneg (by omega)]; omega⟩)

noncomputable def lt (p q : Poly α) : Representation (fun x => p x<q x) :=
  (le (p+1) q).congr (by intro x; simp only [Poly.add_apply,Poly.one_apply]; omega)

end Representation

theorem poly_to_mv {α : Type} (p : Poly α) :
    ∃ q : MvPolynomial α ℤ, ∀ x, q.eval (fun i => (x i : ℤ)) = p x := by
  induction p using Poly.induction with
  | H1 i => exact ⟨MvPolynomial.X i,by simp⟩
  | H2 n => exact ⟨MvPolynomial.C n,by simp⟩
  | H3 f g hf hg =>
    obtain ⟨p,hp⟩ := hf
    obtain ⟨q,hq⟩ := hg
    exact ⟨p-q,by intro x; simp [hp,hq]⟩
  | H4 f g hf hg =>
    obtain ⟨p,hp⟩ := hf
    obtain ⟨q,hq⟩ := hg
    exact ⟨p*q,by intro x; simp [hp,hq]⟩

theorem export_polynomial {α : Type} {R : (α → ℕ) → Prop} (r : Representation R) :
    ∃ m : ℕ, 1 ≤ m ∧ ∃ p : MvPolynomial (α ⊕ Fin m) ℤ,
      (∀ x, R x ↔ ∃ w : Fin m → ℕ, p.eval (Sum.elim (fun i => (x i:ℤ)) (fun j => (w j:ℤ)))=0) ∧
      (∀ (x : α → ℕ) (w w' : Fin m → ℕ), p.eval (Sum.elim (fun i => (x i:ℤ)) (fun j => (w j:ℤ)))=0 →
        p.eval (Sum.elim (fun i => (x i:ℤ)) (fun j => (w' j:ℤ)))=0 → w=w') := by
  classical
  let p : Poly (α ⊕ (r.vars ⊕ Unit)) := r.poly.map (Sum.map id Sum.inl)
  let q : Poly (α ⊕ (r.vars ⊕ Unit)) := Poly.proj (Sum.inr (Sum.inr ()))
  let := Fintype.ofFinite (r.vars ⊕ Unit)
  let e := Fintype.equivFin (r.vars ⊕ Unit)
  let f := (p*p+q*q).map (Sum.map id e)
  obtain ⟨P,hP⟩ := poly_to_mv f
  have ev (x : α → ℕ) (w : Fin (Fintype.card (r.vars ⊕ Unit)) → ℕ) :
      P.eval (Sum.elim (fun i => (x i:ℤ)) (fun j => (w j:ℤ)))=0 ↔
        r.poly (Sum.elim x (fun i => w (e (Sum.inl i))))=0 ∧ w (e (Sum.inr ()))=0 := by
    have he := hP (Sum.elim x w)
    have hc : (fun i : α ⊕ Fin (Fintype.card (r.vars ⊕ Unit)) => ((Sum.elim x w) i:ℤ)) =
        Sum.elim (fun i => (x i:ℤ)) (fun j => (w j:ℤ)) := by funext i; cases i <;> rfl
    rw [hc] at he
    rw [he]
    simp only [f,p,q,Poly.map_apply,Poly.add_apply,Poly.mul_apply,Poly.proj_apply,elim_comp_map,Function.comp_id]
    change r.poly (Sum.elim x (fun i => w (e (Sum.inl i)))) *
      r.poly (Sum.elim x (fun i => w (e (Sum.inl i)))) +
      (w (e (Sum.inr ())):ℤ) * (w (e (Sum.inr ())):ℤ)=0 ↔ _
    constructor
    · intro h
      have h₁ : r.poly (Sum.elim x (fun i => w (e (Sum.inl i))))=0 := by nlinarith [sq_nonneg (w (e (Sum.inr ())):ℤ)]
      exact ⟨h₁,by rw [h₁] at h; norm_num at h; exact h⟩
    · rintro ⟨h₁,h₂⟩; simp [h₁,h₂]
  refine ⟨Fintype.card (r.vars ⊕ Unit),by exact Fintype.card_pos, P,?_,?_⟩
  · intro x
    constructor
    · intro hx
      obtain ⟨w,hw⟩ := r.complete x hx
      refine ⟨Sum.elim w (fun _ => 0) ∘ e.symm,(ev _ _).mpr ?_⟩
      simpa using And.intro hw (show (0:ℕ)=0 from rfl)
    · rintro ⟨w,hw⟩
      exact r.sound _ _ ((ev _ _).mp hw).1
  · intro x w w' hw hw'
    obtain ⟨hr,hz⟩ := (ev _ _).mp hw
    obtain ⟨hr',hz'⟩ := (ev _ _).mp hw'
    have hh := r.unique _ _ _ hr hr'
    funext i
    obtain ⟨j,rfl⟩ := e.surjective i
    rcases j with j|⟨⟩
    · exact congrFun hh j
    · exact hz.trans hz'.symm

end SingleFold.Compiler

end OAI