import OAI.Computability.DegreeRigidity.Syntax.BoundedRelations

namespace OAI

namespace TuringRigidity.TransitiveNameModel
open RecursiveNames BoundedSetTheory
universe u

noncomputable def checkedCode (t x : ZFSet.{u}) : ZFSet.{u} :=
  ZFSet.range (fun y : Shrink x =>
    ZFSet.pair (checkedCode t ((equivShrink x).symm y).val) t)
termination_by x
decreasing_by exact ((equivShrink x).symm y).property

theorem mem_checkedCode (t x z : ZFSet.{u}) :
    z ∈ checkedCode t x ↔ ∃ y ∈ x, z = ZFSet.pair (checkedCode t y) t := by
  rw [checkedCode, ZFSet.mem_range]
  constructor
  · rintro ⟨y,hy⟩
    exact ⟨_,((equivShrink x).symm y).property,hy.symm⟩
  · rintro ⟨y,hy,hz⟩
    refine ⟨equivShrink x ⟨y,hy⟩,?_⟩
    simpa using hz.symm

theorem encode_checkPSet {P : Type u} [Top P] (l : P → ZFSet.{u}) (x : PSet.{u}) :
    (Name.checkPSet x : Name P).encode l = checkedCode (l ⊤) (ZFSet.mk x) := by
  induction x with
  | mk ι child ih =>
    apply ZFSet.ext
    intro z
    change z ∈ ZFSet.range _ ↔ _
    rw [ZFSet.mem_range,mem_checkedCode]
    constructor
    · rintro ⟨i,hi⟩
      refine ⟨ZFSet.mk (child i),?_,by simpa only [ih] using hi.symm⟩
      change ∃ j, PSet.Equiv (child i) (child j)
      exact ⟨i,PSet.Equiv.refl _⟩
    · rintro ⟨y,hy,hz⟩
      induction y using Quotient.inductionOn with
      | h y =>
        change ∃ i, PSet.Equiv y (child i) at hy
        obtain ⟨i,hi⟩ := hy
        have he : ZFSet.mk y = ZFSet.mk (child i) := Quotient.sound hi
        change z = ZFSet.pair (checkedCode (l ⊤) (ZFSet.mk y)) (l ⊤) at hz
        rw [he] at hz
        exact ⟨i,by simpa only [ih] using hz.symm⟩

theorem encode_check {P : Type u} [Top P] (l : P → ZFSet.{u}) (x : ZFSet.{u}) :
    (Name.check x : Name P).encode l = checkedCode (l ⊤) x := by
  rw [Name.check,encode_checkPSet,ZFSet.mk_out]

def RecursionStep (f r t x v : ZFSet.{u}) : Prop :=
  (∀ z ∈ v, ∃ y ∈ x, ∃ w ∈ r, ZFSet.pair y w ∈ f ∧ z = ZFSet.pair w t) ∧
  (∀ y ∈ x, ∀ w ∈ r, ZFSet.pair y w ∈ f → ZFSet.pair w t ∈ v)

def CheckGraph (d r f t : ZFSet.{u}) : Prop :=
  Transitive d ∧
  (∀ z ∈ f, ∃ x ∈ d, ∃ y ∈ r, z = ZFSet.pair x y) ∧
  (∀ x ∈ d, ∃ y ∈ r, ZFSet.pair x y ∈ f ∧
    ∀ z ∈ r, ZFSet.pair x z ∈ f → z = y) ∧
  (∀ x ∈ d, ∀ y ∈ r, ZFSet.pair x y ∈ f → RecursionStep f r t x y)

theorem CheckGraph.correct {d r f t : ZFSet.{u}} (h : CheckGraph d r f t)
    (x : ZFSet.{u}) (hx : x ∈ d) (v : ZFSet.{u}) (hv : v ∈ r)
    (hfv : ZFSet.pair x v ∈ f) : v = checkedCode t x := by
  induction x using ZFSet.inductionOn generalizing v with
  | h x ih =>
    have hs := h.2.2.2 x hx v hv hfv
    apply ZFSet.ext
    intro z
    rw [mem_checkedCode]
    constructor
    · intro hz
      obtain ⟨y,hy,w,hw,hfw,rfl⟩ := hs.1 z hz
      exact ⟨y,hy,by rw [ih y hy (h.1 x hx y hy) w hw hfw]⟩
    · rintro ⟨y,hy,rfl⟩
      obtain ⟨w,hw,hfw,_⟩ := h.2.2.1 y (h.1 x hx y hy)
      rw [←ih y hy (h.1 x hx y hy) w hw hfw]
      exact hs.2 y hy w hw hfw

theorem CheckGraph.unique {d r s f g t : ZFSet.{u}}
    (hf : CheckGraph d r f t) (hg : CheckGraph d s g t) : f = g := by
  apply ZFSet.ext
  intro z
  have forward {r s f g : ZFSet.{u}} (hf : CheckGraph d r f t)
      (hg : CheckGraph d s g t) (hz : z ∈ f) : z ∈ g := by
    obtain ⟨x,hx,y,hy,rfl⟩ := hf.2.1 z hz
    obtain ⟨v,hv,hgv,_⟩ := hg.2.2.1 x hx
    have he := (hf.correct x hx y hy hz).trans (hg.correct x hx v hv hgv).symm
    exact he ▸ hgv
  exact ⟨forward hf hg,forward hg hf⟩

namespace CheckFormula
open BoundedSetTheory.Formula

def step (f r t x v : ℕ) : Formula :=
  .conj (allMem v (.existsMem (x+1) (.existsMem (r+2)
    (.conj (pairMem 1 0 (f+3)) (orderedPair 2 0 (t+3))))))
    (allMem x (allMem (r+1) (imp (pairMem 1 0 (f+2))
      (.existsMem (v+2) (orderedPair 0 1 (t+3))))))

theorem eval_step (f r t x v : ℕ) (e : ℕ → ZFSet.{u}) :
    (step f r t x v).Eval e ↔ RecursionStep (e f) (e r) (e t) (e x) (e v) := by
  simp only [step, Formula.Eval, eval_allMem, eval_pairMem, eval_orderedPair,
    eval_imp, cons_zero, cons_succ, RecursionStep]
  simp only [exists_eq_right]

def graph (d r f t : ℕ) : Formula :=
  .conj (transitive d) (.conj (functionGraph f d r)
    (allMem d (allMem (r+1) (imp (pairMem 1 0 (f+2)) (step (f+2) (r+2) (t+2) 1 0)))))

theorem eval_graph (d r f t : ℕ) (e : ℕ → ZFSet.{u}) :
    (graph d r f t).Eval e ↔ CheckGraph (e d) (e r) (e f) (e t) := by
  simp only [graph, Formula.Eval, eval_transitive, eval_functionGraph,
    eval_allMem, eval_imp, eval_pairMem, eval_step, cons_zero, cons_succ, CheckGraph]
  exact and_congr_right (fun _ => and_assoc)
end CheckFormula

end TuringRigidity.TransitiveNameModel

end OAI