import OAI.Computability.DegreeRigidity.Effective.FiniteCodeBound
import Mathlib.SetTheory.ZFC.Rank

namespace OAI


namespace TuringRigidity.BoundedSetTheory
open TransitiveNameModel
universe u
namespace FiniteTerm

noncomputable def tag (n : ℕ) (x : ZFSet.{u}) : ZFSet.{u} := ZFSet.pair (natSet n) x

theorem tag_inj (n m : ℕ) (x y : ZFSet.{u}) : tag n x = tag m y ↔ n = m ∧ x = y := by
  rw [tag,tag,ZFSet.pair_inj]
  exact and_congr ⟨fun h => natSet_injective h,fun h => congrArg natSet h⟩ Iff.rfl

inductive Eval (A B L O D : ZFSet.{u}) : ZFSet.{u} → ZFSet.{u} → Prop
  | leaf {a x : ZFSet.{u}} : a ∈ A → x ∈ D → ZFSet.pair a x ∈ L → Eval A B L O D (tag 0 a) x
  | app {o c x y : ZFSet.{u}} : o ∈ B → Eval A B L O D c x → y ∈ D →
      ZFSet.pair (ZFSet.pair o x) y ∈ O → Eval A B L O D (tag 1 (ZFSet.pair o c)) y
  | pair {a b x y : ZFSet.{u}} : Eval A B L O D a x → Eval A B L O D b y →
      ZFSet.pair x y ∈ D → Eval A B L O D (tag 2 (ZFSet.pair a b)) (ZFSet.pair x y)

theorem Eval.value_mem {A B L O D c x : ZFSet.{u}} (h : Eval A B L O D c x) : x ∈ D := by
  cases h with
  | leaf _ hx _ => exact hx
  | app _ _ hx _ => exact hx
  | pair _ _ hx => exact hx

theorem Eval.code_finite {A B L O D t c x : ZFSet.{u}}
    (hA : A ⊆ t) (hB : B ⊆ t) (hn : ∀ n, natSet.{u} n ∈ t)
    (h : Eval A B L O D c x) : FiniteTuple.FiniteCode t c := by
  induction h with
  | leaf ha _ _ => exact (FiniteTuple.FiniteCode.atom _ (hn 0)).orderedPair (.atom _ (hA ha))
  | app ho _ _ _ ih =>
    exact (FiniteTuple.FiniteCode.atom _ (hn 1)).orderedPair
      ((FiniteTuple.FiniteCode.atom _ (hB ho)).orderedPair ih)
  | pair _ _ _ iha ihb => exact (FiniteTuple.FiniteCode.atom _ (hn 2)).orderedPair (iha.orderedPair ihb)

def Step (A B L O K D f c v : ZFSet.{u}) : Prop :=
  (∃ a ∈ A, c = tag 0 a ∧ ZFSet.pair a v ∈ L) ∨
  (∃ o ∈ B, ∃ a ∈ K, ∃ x ∈ D, c = tag 1 (ZFSet.pair o a) ∧
    ZFSet.pair a x ∈ f ∧ ZFSet.pair (ZFSet.pair o x) v ∈ O) ∨
  (∃ a ∈ K, ∃ b ∈ K, ∃ x ∈ D, ∃ y ∈ D, c = tag 2 (ZFSet.pair a b) ∧
    ZFSet.pair a x ∈ f ∧ ZFSet.pair b y ∈ f ∧ v = ZFSet.pair x y)

def Certificate (A B L O K D f : ZFSet.{u}) : Prop :=
  ∀ z ∈ f, ∃ c ∈ K, ∃ v ∈ D, z = ZFSet.pair c v ∧ Step A B L O K D f c v

theorem Step.mono {A B L O K D f g c v : ZFSet.{u}} (hfg : f ⊆ g)
    (h : Step A B L O K D f c v) : Step A B L O K D g c v := by
  rcases h with h|h|h
  · exact Or.inl h
  · obtain ⟨o,ho,a,ha,x,hx,hc,hax,hox⟩ := h
    exact Or.inr (Or.inl ⟨o,ho,a,ha,x,hx,hc,hfg hax,hox⟩)
  · obtain ⟨a,ha,b,hb,x,hx,y,hy,hc,hax,hby,hv⟩ := h
    exact Or.inr (Or.inr ⟨a,ha,b,hb,x,hx,y,hy,hc,hfg hax,hfg hby,hv⟩)

theorem Certificate.subset {A B L O K D f : ZFSet.{u}} (hf : Certificate A B L O K D f) :
    f ⊆ ZFSet.prod K D := by
  intro z hz
  obtain ⟨c,hc,v,hv,hz,_⟩ := hf z hz
  exact ZFSet.mem_prod.mpr ⟨c,hc,v,hv,hz⟩

theorem Certificate.step {A B L O K D f c v : ZFSet.{u}}
    (hf : Certificate A B L O K D f) (hp : ZFSet.pair c v ∈ f) :
    c ∈ K ∧ v ∈ D ∧ Step A B L O K D f c v := by
  obtain ⟨c',hc,v',hv,he,hs⟩ := hf _ hp
  obtain ⟨rfl,rfl⟩ := ZFSet.pair_inj.mp he
  exact ⟨hc,hv,hs⟩

theorem pair_rank_left (x y : ZFSet.{u}) : ZFSet.rank x < ZFSet.rank (ZFSet.pair x y) := by
  have ha : x ∈ ({x,y} : ZFSet.{u}) := ZFSet.mem_pair.mpr (Or.inl rfl)
  have hb : ({x,y} : ZFSet.{u}) ∈ ZFSet.pair x y := ZFSet.mem_pair.mpr (Or.inr rfl)
  exact (ZFSet.rank_lt_of_mem ha).trans (ZFSet.rank_lt_of_mem hb)

theorem pair_rank_right (x y : ZFSet.{u}) : ZFSet.rank y < ZFSet.rank (ZFSet.pair x y) := by
  have ha : y ∈ ({x,y} : ZFSet.{u}) := ZFSet.mem_pair.mpr (Or.inr rfl)
  have hb : ({x,y} : ZFSet.{u}) ∈ ZFSet.pair x y := ZFSet.mem_pair.mpr (Or.inr rfl)
  exact (ZFSet.rank_lt_of_mem ha).trans (ZFSet.rank_lt_of_mem hb)

theorem Certificate.sound {A B L O K D f : ZFSet.{u}}
    (hf : Certificate A B L O K D f) (c v : ZFSet.{u})
    (hp : ZFSet.pair c v ∈ f) : Eval A B L O D c v := by
  have wf : WellFounded (fun a b : ZFSet.{u} => ZFSet.rank a < ZFSet.rank b) :=
    InvImage.wf ZFSet.rank Ordinal.lt_wf
  induction c using wf.induction generalizing v with
  | h c ih =>
    have hv := (hf.step hp).2.1
    rcases (hf.step hp).2.2 with h|h|h
    · obtain ⟨a,ha,rfl,hav⟩ := h
      exact .leaf ha hv hav
    · obtain ⟨o,ho,a,_,x,_,rfl,hax,hov⟩ := h
      have hlt := (pair_rank_right o a).trans (pair_rank_right (natSet 1) (ZFSet.pair o a))
      exact .app ho (ih a hlt x hax) hv hov
    · obtain ⟨a,_,b,_,x,_,y,_,rfl,hax,hby,rfl⟩ := h
      have ha := (pair_rank_left a b).trans (pair_rank_right (natSet 2) (ZFSet.pair a b))
      have hb := (pair_rank_right a b).trans (pair_rank_right (natSet 2) (ZFSet.pair a b))
      exact .pair (ih a ha x hax) (ih b hb y hby) hv

end FiniteTerm
end TuringRigidity.BoundedSetTheory

end OAI