import OAI.Computability.DegreeRigidity.SetModels.CollapseCollection

namespace OAI


namespace TuringRigidity.RelationCollapse
open TransitiveNameModel BoundedSetTheory
universe u

def Presents (a f : ZFSet.{u}) (j : ZFSet.{u} → ZFSet.{u}) : Prop :=
  ∀ z, z ∈ f ↔ ∃ x ∈ a, z = ZFSet.pair x (j x)

theorem Presents.pair_iff {a f : ZFSet.{u}} {j : ZFSet.{u} → ZFSet.{u}}
    (hf : Presents a f j) (x y : ZFSet.{u}) :
    ZFSet.pair x y ∈ f ↔ x ∈ a ∧ y = j x := by
  rw [hf]
  constructor
  · rintro ⟨z,hz,he⟩
    obtain ⟨rfl,rfl⟩ := ZFSet.pair_inj.mp he
    exact ⟨hz,rfl⟩
  · rintro ⟨hx,rfl⟩
    exact ⟨x,hx,rfl⟩

noncomputable def codedRelation (d a f : ZFSet.{u}) : ZFSet.{u} :=
  ZFSet.sep (fun z => ∃ u ∈ d, ∃ v ∈ d, z = ZFSet.pair u v ∧
    ∃ x ∈ a, ∃ y ∈ a, x ∈ y ∧ ZFSet.pair x u ∈ f ∧ ZFSet.pair y v ∈ f) (ZFSet.prod d d)

def codedFormula : Formula :=
  .existsMem 1 (.existsMem 2 (.conj (.orderedPair 2 1 0)
    (.existsMem 4 (.existsMem 5 (.conj (.member 1 0)
      (.conj (.pairMem 1 3 7) (.pairMem 0 2 7)))))))

theorem codedRelation_mem (M : ZFSet.{u}) (hM : Transitive M)
    (hP : Pairing M) (hU : BoundedSetTheory.Union M) (hPow : PowerSet M) (hS : Separation M)
    {d a f : ZFSet.{u}} (hd : d ∈ M) (ha : a ∈ M) (hf : f ∈ M) :
    codedRelation d a f ∈ M := by
  let e := cons d (cons a (cons f (fun _ => d)))
  have he : ∀ i, e i ∈ M := by
    intro i; rcases i with _|i; exact hd
    rcases i with _|i; exact ha
    rcases i with _|i; exact hf
    exact hd
  simpa only [codedFormula,Formula.Eval,Formula.eval_orderedPair,Formula.eval_pairMem,
    e,cons_zero,cons_succ,codedRelation] using
    sep_mem M hM hS codedFormula e he (product_mem M hM hP hU hPow hS hd hd)

theorem codedRelation_on (d a f : ZFSet.{u}) : On d (codedRelation d a f) :=
  fun _ hz => (ZFSet.mem_sep.mp hz).1

theorem codedRelation_pair {d a f : ZFSet.{u}} {j : ZFSet.{u} → ZFSet.{u}}
    (hf : Presents a f j) (hj : ∀ x ∈ a, j x ∈ d) (u v : ZFSet.{u}) :
    ZFSet.pair u v ∈ codedRelation d a f ↔
      ∃ x ∈ a, ∃ y ∈ a, x ∈ y ∧ u = j x ∧ v = j y := by
  rw [codedRelation,ZFSet.mem_sep]
  constructor
  · rintro ⟨_,u',_,v',_,hp,x,hx,y,hy,hxy,hxu,hyv⟩
    obtain ⟨rfl,rfl⟩ := ZFSet.pair_inj.mp hp
    exact ⟨x,hx,y,hy,hxy,((hf.pair_iff x u).mp hxu).2,((hf.pair_iff y v).mp hyv).2⟩
  · rintro ⟨x,hx,y,hy,hxy,rfl,rfl⟩
    exact ⟨ZFSet.mem_prod.mpr ⟨_,hj x hx,_,hj y hy,rfl⟩,
      _,hj x hx,_,hj y hy,rfl,x,hx,y,hy,hxy,
      (hf.pair_iff x _).mpr ⟨hx,rfl⟩,(hf.pair_iff y _).mpr ⟨hy,rfl⟩⟩

theorem codedRelation_wellFounded {d a f : ZFSet.{u}} {j : ZFSet.{u} → ZFSet.{u}}
    (hf : Presents a f j) (hj : ∀ x ∈ a, j x ∈ d)
    (hi : ∀ x ∈ a, ∀ y ∈ a, j x = j y → x = y) :
    WellFounded (Rel d (codedRelation d a f)) := by
  classical
  let F : ZFSet.{u} → ZFSet.{u} := fun u =>
    if h : ∃ x ∈ a, j x = u then h.choose else ∅
  have hF (x : ZFSet.{u}) (hx : x ∈ a) : F (j x) = x := by
    have h : ∃ y ∈ a, j y = j x := ⟨x,hx,rfl⟩
    simp only [F,dite_eq_left h]
    exact hi _ h.choose_spec.1 x hx h.choose_spec.2
  apply (show WellFounded (fun y x => F y ∈ F x) from InvImage.wf F ZFSet.mem_wf).mono
  intro u v huv
  obtain ⟨x,hx,y,hy,hxy,rfl,rfl⟩ := (codedRelation_pair hf hj u v).mp huv.2
  simpa only [hF x hx,hF y hy] using hxy

theorem codedRelation_value {d a f : ZFSet.{u}} {j : ZFSet.{u} → ZFSet.{u}}
    (ha : Transitive a) (hf : Presents a f j) (hj : ∀ x ∈ a, j x ∈ d)
    (hi : ∀ x ∈ a, ∀ y ∈ a, j x = j y → x = y)
    (wf : WellFounded (Rel d (codedRelation d a f)))
    (x : ZFSet.{u}) (hx : x ∈ a) : value d (codedRelation d a f) wf (j x) = x := by
  induction x using ZFSet.inductionOn with
  | h x ih =>
    apply ZFSet.ext
    intro z
    rw [mem_value]
    constructor
    · rintro ⟨u,_,hux,hz⟩
      obtain ⟨y,hy,w,hw,hyw,rfl,hwx⟩ := (codedRelation_pair hf hj u (j x)).mp hux
      have hwx' : x = w := hi x hx w hw hwx
      subst w
      rw [ih y hyw hy] at hz
      exact hz ▸ hyw
    · intro hz
      have hza := ha x hx z hz
      refine ⟨j z,hj z hza,(codedRelation_pair hf hj _ _).mpr
        ⟨z,hza,x,hx,hz,rfl,rfl⟩,?_⟩
      exact (ih z hz hza).symm

theorem internal_small_transitive_bound (M d : ZFSet.{u}) (hM : Transitive M)
    (hP : Pairing M) (hU : BoundedSetTheory.Union M) (hPow : PowerSet M)
    (hS : SigmaSeparation M) (hR : SigmaReplacement M) (hd : d ∈ M) :
    ∃ W ∈ M, ∀ a ∈ M, Transitive a → ∀ f ∈ M, ∀ j : ZFSet.{u} → ZFSet.{u},
      Presents a f j → (∀ x ∈ a, j x ∈ d) →
      (∀ x ∈ a, ∀ y ∈ a, j x = j y → x = y) → a ⊆ W := by
  obtain ⟨W,hW,hbound⟩ := internal_value_bound M d hM hP hU hPow hS hR hd
  refine ⟨W,hW,?_⟩
  intro a ha hat f hf j hfj hj hi x hx
  have hr := codedRelation_mem M hM hP hU hPow hS.bounded hd ha hf
  have wf := codedRelation_wellFounded hfj hj hi
  have hv := hbound _ hr (codedRelation_on d a f) wf (j x) (hj x hx)
  rw [codedRelation_value hat hfj hj hi wf x hx] at hv
  exact hv

end TuringRigidity.RelationCollapse

end OAI