import OAI.Computability.DegreeRigidity.Representation.SourceTheory
import OAI.Computability.DegreeRigidity.Syntax.FiniteTerm
import OAI.Computability.DegreeRigidity.Syntax.BoundedFormulaRename

namespace OAI

namespace TuringRigidity.BoundedTruthRecursion
open TransitiveNameModel BoundedSetTheory

def Local (φ : Formula) (e : ℕ → ZFSet.{0}) : Prop :=
  ∀ D : ZFSet.{0}, Transitive D → ∀ t ∈ D, ∀ Y Z : ZFSet.{0},
    (∀ s ∈ D, ZFSet.rank s < ZFSet.rank t → (s ∈ Y ↔ s ∈ Z)) →
      (φ.Eval (cons t (cons Y e)) ↔ φ.Eval (cons t (cons Z e)))

def Partial (φ : Formula) (e : ℕ → ZFSet.{0}) (K D Y : ZFSet.{0}) : Prop :=
  Transitive D ∧ D ⊆ K ∧ Y ⊆ D ∧
    ∀ t ∈ D, t ∈ Y ↔ φ.Eval (cons t (cons Y e))

theorem partial_sound (φ : Formula) (e : ℕ → ZFSet.{0}) (K D Y Z : ZFSet.{0})
    (hl : Local φ e) (hp : Partial φ e K D Y)
    (hz : ∀ t ∈ K, t ∈ Z ↔ φ.Eval (cons t (cons Z e))) :
    ∀ t ∈ D, t ∈ Y ↔ t ∈ Z := by
  have wf : WellFounded (fun a b : ZFSet.{0} => ZFSet.rank a < ZFSet.rank b) :=
    InvImage.wf ZFSet.rank Ordinal.lt_wf
  intro t
  induction t using wf.induction with
  | h t ih =>
    intro ht
    exact (hp.2.2.2 t ht).trans ((hl D hp.1 t ht Y Z
      (fun s hs hst => ih s hst hs)).trans (hz t (hp.2.1 ht)).symm)

def dropSlots : ℕ → ℕ
  | 0 => 0
  | 1 => 1
  | n+2 => n+4

def partialFormula (φ : Formula) : Formula :=
  .conj (.transitive 1) (.conj (.subset 1 2) (.conj (.subset 0 1)
    (.allMem 1 (.iff (.member 0 1) (φ.rename dropSlots)))))

theorem partialFormula_spec (φ : Formula) (e : ℕ → ZFSet.{0}) (K D Y : ZFSet.{0}) :
    (partialFormula φ).Eval (cons Y (cons D (cons K e))) ↔ Partial φ e K D Y := by
  simp only [partialFormula,Formula.Eval,Formula.eval_transitive,Formula.eval_subset,
    Formula.eval_allMem,Formula.eval_iff,Formula.eval_rename_comp,cons_zero,cons_succ,Partial]
  have eq (t : ZFSet.{0}) : cons t (cons Y (cons D (cons K e))) ∘ dropSlots = cons t (cons Y e) := by
    funext i; rcases i with _|_|i <;> rfl
  simp only [eq]

noncomputable def domain (φ : Formula) (e : ℕ → ZFSet.{0}) (K Q : ZFSet.{0}) : ZFSet.{0} :=
  K.sep (fun t => ∃ D ∈ Q, ∃ Y ∈ Q, Partial φ e K D Y ∧ t ∈ D)

noncomputable def truth (φ : Formula) (e : ℕ → ZFSet.{0}) (K Q : ZFSet.{0}) : ZFSet.{0} :=
  K.sep (fun t => ∃ D ∈ Q, ∃ Y ∈ Q, Partial φ e K D Y ∧ t ∈ Y)

def candidateSlots : ℕ → ℕ
  | 0 => 0
  | 1 => 1
  | n+2 => n+4

def unionFormula (φ : Formula) (which : ℕ) : Formula :=
  .existsMem 1 (.existsMem 2 (.conj ((partialFormula φ).rename candidateSlots) (.member 2 which)))

theorem unionFormula_spec (φ : Formula) (e : ℕ → ZFSet.{0}) (K Q t : ZFSet.{0}) (which : ℕ) :
    (unionFormula φ which).Eval (cons t (cons Q (cons K e))) ↔
      ∃ D ∈ Q, ∃ Y ∈ Q, Partial φ e K D Y ∧
        t ∈ cons Y (cons D (cons t (cons Q (cons K e)))) which := by
  simp only [unionFormula,Formula.Eval,Formula.eval_rename_comp,cons_zero,cons_succ]
  have eq (D Y : ZFSet.{0}) :
      cons Y (cons D (cons t (cons Q (cons K e)))) ∘ candidateSlots = cons Y (cons D (cons K e)) := by
    funext i; rcases i with _|_|i <;> rfl
  simp only [eq,partialFormula_spec]

theorem domain_truth_mem (M K Q : ZFSet.{0}) (hM : Transitive M) (hT : SourceT M)
    (hK : K ∈ M) (hQ : Q ∈ M) (φ : Formula) (e : ℕ → ZFSet.{0}) (he : ∀ i, e i ∈ M) :
    domain φ e K Q ∈ M ∧ truth φ e K Q ∈ M := by
  have henv : ∀ i, cons Q (cons K e) i ∈ M := by
    intro i; rcases i with _|_|i; exact hQ; exact hK; exact he i
  constructor
  · have hs := sep_mem M hM hT.separation.finitePrefix.bounded (unionFormula φ 1) _ henv hK
    simpa only [unionFormula_spec,cons_succ,cons_zero,domain] using hs
  · have hs := sep_mem M hM hT.separation.finitePrefix.bounded (unionFormula φ 0) _ henv hK
    simpa only [unionFormula_spec,cons_succ,cons_zero,truth] using hs

theorem domain_transitive (φ : Formula) (e : ℕ → ZFSet.{0}) (K Q : ZFSet.{0}) :
    Transitive (domain φ e K Q) := by
  intro t ht s hst
  obtain ⟨_,D,hD,Y,hY,hp,htD⟩ := ZFSet.mem_sep.mp ht
  have hsD := hp.1 t htD s hst
  exact ZFSet.mem_sep.mpr ⟨hp.2.1 hsD,D,hD,Y,hY,hp,hsD⟩

theorem truth_subset_domain (φ : Formula) (e : ℕ → ZFSet.{0}) (K Q : ZFSet.{0}) :
    truth φ e K Q ⊆ domain φ e K Q := by
  intro t ht
  obtain ⟨htK,D,hD,Y,hY,hp,htY⟩ := ZFSet.mem_sep.mp ht
  exact ZFSet.mem_sep.mpr ⟨htK,D,hD,Y,hY,hp,hp.2.2.1 htY⟩

theorem truth_agrees (φ : Formula) (e : ℕ → ZFSet.{0}) (K Q Z : ZFSet.{0})
    (hl : Local φ e) (hz : ∀ t ∈ K, t ∈ Z ↔ φ.Eval (cons t (cons Z e))) :
    ∀ t ∈ domain φ e K Q, t ∈ truth φ e K Q ↔ t ∈ Z := by
  intro t ht
  constructor
  · intro h
    obtain ⟨_,D,_,Y,_,hp,htY⟩ := ZFSet.mem_sep.mp h
    exact (partial_sound φ e K D Y Z hl hp hz t (hp.2.2.1 htY)).mp htY
  · intro h
    obtain ⟨htK,D,hD,Y,hY,hp,htD⟩ := ZFSet.mem_sep.mp ht
    exact ZFSet.mem_sep.mpr ⟨htK,D,hD,Y,hY,hp,(partial_sound φ e K D Y Z hl hp hz t htD).mpr h⟩

theorem partial_of_agrees (φ : Formula) (e : ℕ → ZFSet.{0}) (K D Y Z : ZFSet.{0})
    (hl : Local φ e) (hz : ∀ t ∈ K, t ∈ Z ↔ φ.Eval (cons t (cons Z e)))
    (hD : Transitive D) (hDK : D ⊆ K) (hYD : Y ⊆ D)
    (ha : ∀ t ∈ D, t ∈ Y ↔ t ∈ Z) : Partial φ e K D Y := by
  refine ⟨hD,hDK,hYD,?_⟩
  intro t ht
  exact (ha t ht).trans ((hz t (hDK ht)).trans
    (hl D hD t ht Y Z (fun s hs _ => ha s hs)).symm)

theorem truth_internal (M K Z : ZFSet.{0}) (hM : Transitive M) (hT : SourceT M)
    (hKM : K ∈ M) (hK : Transitive K) (φ : Formula) (e : ℕ → ZFSet.{0})
    (he : ∀ i, e i ∈ M) (hl : Local φ e)
    (hz : ∀ t ∈ K, t ∈ Z ↔ φ.Eval (cons t (cons Z e))) :
    K.sep (fun t => t ∈ Z) ∈ M := by
  classical
  obtain ⟨Q,hQM,hQ⟩ := internal_power M hM hT.powerSet hKM
  let D := domain φ e K Q
  let Y := truth φ e K Q
  obtain ⟨hDM,hYM⟩ := domain_truth_mem M K Q hM hT hKM hQM φ e he
  have hD : Transitive D := domain_transitive φ e K Q
  have hDK : D ⊆ K := fun _ h => (ZFSet.mem_sep.mp h).1
  have hYD : Y ⊆ D := truth_subset_domain φ e K Q
  have ha : ∀ t ∈ D, t ∈ Y ↔ t ∈ Z := truth_agrees φ e K Q Z hl hz
  have hcover (t : ZFSet.{0}) : t ∈ K → t ∈ D := by
    induction t using ZFSet.inductionOn with
    | h t ih =>
      intro htK
      by_cases htD : t ∈ D
      · exact htD
      have hchildren : t ⊆ D := fun s hs => ih s hs (hK t htK s hs)
      let D' := D ∪ ({t} : ZFSet.{0})
      let Y' := if t ∈ Z then Y ∪ ({t} : ZFSet.{0}) else Y
      have hDD' : D ⊆ D' := fun _ h => ZFSet.mem_union.mpr (Or.inl h)
      have htD' : t ∈ D' := ZFSet.mem_union.mpr (Or.inr (ZFSet.mem_singleton.mpr rfl))
      have hD' : Transitive D' := by
        intro a ha b hb
        rcases ZFSet.mem_union.mp ha with ha | ha
        · exact hDD' (hD a ha b hb)
        · have ha := ZFSet.mem_singleton.mp ha
          subst a
          exact hDD' (hchildren hb)
      have hD'K : D' ⊆ K := by
        intro a ha
        rcases ZFSet.mem_union.mp ha with ha | ha
        · exact hDK ha
        · exact (ZFSet.mem_singleton.mp ha) ▸ htK
      have hY'D' : Y' ⊆ D' := by
        intro a ha
        dsimp [Y'] at ha
        split_ifs at ha
        · rcases ZFSet.mem_union.mp ha with ha | ha
          · exact hDD' (hYD ha)
          · exact (ZFSet.mem_singleton.mp ha) ▸ htD'
        · exact hDD' (hYD ha)
      have ha' : ∀ a ∈ D', a ∈ Y' ↔ a ∈ Z := by
        intro a haD'
        by_cases hat : a = t
        · subst a
          have htY : t ∉ Y := fun h => htD (hYD h)
          simp only [Y']
          split_ifs with htZ <;> simp [htZ,htY]
        · have haD : a ∈ D := (ZFSet.mem_union.mp haD').resolve_right (fun h => hat (ZFSet.mem_singleton.mp h))
          have hae := ha a haD
          dsimp [Y']
          split_ifs <;> simpa only [ZFSet.mem_union,ZFSet.mem_singleton,hat,or_false] using hae
      have htM := hM K hKM t htK
      have hsM := singleton_mem M hM hT.pairing htM
      have hD'M : D' ∈ M := binary_union_mem M hM hT.pairing hT.union hDM hsM
      have hY'M : Y' ∈ M := by
        dsimp [Y']; split_ifs
        · exact binary_union_mem M hM hT.pairing hT.union hYM hsM
        · exact hYM
      exact ZFSet.mem_sep.mpr ⟨htK,D',(hQ _).mpr ⟨hD'M,hD'K⟩,
        Y',(hQ _).mpr ⟨hY'M,fun _ h => hD'K (hY'D' h)⟩,
        partial_of_agrees φ e K D' Y' Z hl hz hD' hD'K hY'D' ha',htD'⟩
  have eq : Y = K.sep (fun t => t ∈ Z) := by
    apply ZFSet.ext; intro t
    constructor
    · intro ht
      exact ZFSet.mem_sep.mpr ⟨hDK (hYD ht),(ha t (hYD ht)).mp ht⟩
    · intro ht
      obtain ⟨htK,htZ⟩ := ZFSet.mem_sep.mp ht
      exact (ha t (hcover t htK)).mpr htZ
  exact eq ▸ hYM

end TuringRigidity.BoundedTruthRecursion

end OAI