import OAI.Computability.DegreeRigidity.SetModels.ModelDegreeUniverse
import OAI.Computability.DegreeRigidity.SetModels.InternalPresentationEnumeration

namespace OAI


namespace TuringRigidity.BoundedSetTheory
open TransitiveNameModel EncodedForcing
universe u

namespace Formula
def selectedEnumerationBit (o Q I E F v : ℕ) : Formula :=
  .existsMem o (.existsMem (o+1) (.conj (naturalPair (o+2) (Q+2) 1 0 (v+2))
    (.existsMem (I+2) (.conj (.pairMem 2 0 (E+3))
      (.existsMem 0 (.conj (.pairMem 1 0 (F+4)) (.member 2 0)))))))

theorem selectedEnumerationBit_spec (o Q I E F v : ℕ) (e : ℕ → ZFSet.{u})
    (ho : e o = ZFSet.omega) (hQ : ∀ f : ℕ → ℕ, ∀ k, finiteNaturalGraph f k ∈ e Q)
    (N K : ℕ) (hv : e v = natSet (Nat.pair N K)) :
    (selectedEnumerationBit o Q I E F v).Eval e ↔
      ∃ D ∈ e I, ZFSet.pair (natSet N) D ∈ e E ∧
        ∃ A ∈ D, ZFSet.pair D A ∈ e F ∧ natSet K ∈ A := by
  simp only [selectedEnumerationBit,Formula.Eval,eval_pairMem,cons_zero,cons_succ]
  rw [ho]
  constructor
  · rintro ⟨n,hn,k,hk,hp,hrest⟩
    obtain ⟨n,rfl⟩ := (mem_omega n).mp hn
    obtain ⟨k,rfl⟩ := (mem_omega k).mp hk
    have hp' := (naturalPair_spec (o+2) (Q+2) 1 0 (v+2)
      (cons (natSet k) (cons (natSet n) e)) ho hQ n k rfl rfl).mp hp
    have hnk : Nat.pair N K = Nat.pair n k := natSet_injective (hv.symm.trans hp')
    have he := congrArg Nat.unpair hnk
    simp only [Nat.unpair_pair,Prod.mk.injEq] at he
    obtain ⟨rfl,rfl⟩ := he
    exact hrest
  · intro h
    refine ⟨natSet N,(mem_omega _).mpr ⟨N,rfl⟩,natSet K,(mem_omega _).mpr ⟨K,rfl⟩,?_,h⟩
    exact (naturalPair_spec (o+2) (Q+2) 1 0 (v+2)
      (cons (natSet K) (cons (natSet N) e)) ho hQ N K rfl rfl).mpr hv
end Formula

theorem internal_selected_enumeration_real (M : ZFSet.{u}) (hM : Transitive M) (hT : SourceT M)
    {I E F : ZFSet.{u}} (hIM : I ∈ M) (hEM : E ∈ M) (hFM : F ∈ M)
    (hE : TransitiveNameModel.FunctionGraph ZFSet.omega I E) (hF : ChoiceGraph I F) :
    ∃ H ∈ modelReals M, ∀ n, ∀ D ∈ I, ZFSet.pair (natSet n) D ∈ E →
      ∀ A : Oracle, realCode A ∈ D → ZFSet.pair D (realCode A) ∈ F → columns H n = A := by
  have hS := hT.separation.finitePrefix.bounded
  have hω := sourceT_omega_mem M hM hT
  obtain ⟨Q,hQM,_,hQ⟩ := internal_finite_natural_graph_bound M hM hT.pairing hT.union hT.powerSet hS hω
  let e := cons ZFSet.omega (cons Q (cons I (cons E (fun _ => F))))
  have he : ∀ i, e i ∈ M := by
    intro i
    rcases i with _|i; exact hω
    rcases i with _|i; exact hQM
    rcases i with _|i; exact hIM
    rcases i with _|i; exact hEM
    exact hFM
  let B := ZFSet.sep (fun v => (Formula.selectedEnumerationBit 1 2 3 4 5 0).Eval (cons v e)) ZFSet.omega
  have hBM : B ∈ M := sep_mem M hM hS _ e he hω
  have hsub : B ⊆ ZFSet.omega := fun _ h => (ZFSet.mem_sep.mp h).1
  have hB : realCode (decodeReal B) = B := realCode_decodeReal hsub
  refine ⟨decodeReal B,?_,?_⟩
  · change realCode (decodeReal B) ∈ M
    rw [hB]; exact hBM
  · intro n D hD hn A hA hDA
    funext k
    have hbit : columns (decodeReal B) n k = true ↔ A k = true := by
      change decodeReal B (Nat.pair n k) = true ↔ A k = true
      rw [decodeReal_true]
      change natSet (Nat.pair n k) ∈ ZFSet.sep _ ZFSet.omega ↔ _
      rw [ZFSet.mem_sep,Formula.selectedEnumerationBit_spec 1 2 3 4 5 0
        (cons (natSet (Nat.pair n k)) e) rfl hQ n k rfl]
      constructor
      · rintro ⟨_,D',_,hn',A',_,hDA',hk⟩
        have hDD := hE.functional ((mem_omega _).mpr ⟨n,rfl⟩) hn hn'
        subst D'
        have hAA := hF.functional hDA hDA'
        rw [←hAA,natSet_mem_realCode] at hk
        exact hk
      · intro hk
        exact ⟨(mem_omega _).mpr ⟨Nat.pair n k,rfl⟩,D,hD,hn,realCode A,hA,hDA,
          (natSet_mem_realCode A k).mpr hk⟩
    cases hx : columns (decodeReal B) n k <;> cases hy : A k <;> simp_all

def InternallyCountable (M I : ZFSet.{u}) : Prop :=
  ∃ E ∈ M, TransitiveNameModel.FunctionGraph ZFSet.omega I E ∧
    ∀ D ∈ I, ∃ n ∈ ZFSet.omega, ZFSet.pair n D ∈ E

theorem internal_countable_degree_presentation (M : ZFSet.{u}) (hM : Transitive M) (hT : SourceT M)
    (R : ZFSet.{u}) (hR : ∀ w ∈ R, ∃ A : Oracle, realCode A = w)
    {I : ZFSet.{u}} (hIM : I ∈ M) (hI : I ⊆ degreeUniverse R)
    (hcount : InternallyCountable M I) :
    ∃ H ∈ modelReals M, presentationSet R H = I := by
  obtain ⟨E,hEM,hE,honto⟩ := hcount
  obtain ⟨F,hFM,hF⟩ := hT.choice I hIM (fun D hD => by
    obtain ⟨A,hA,_⟩ := degreeUniverse_nonempty_member R D (hI hD)
    exact ⟨realCode A,hA⟩)
  obtain ⟨H,hHM,hH⟩ := internal_selected_enumeration_real M hM hT hIM hEM hFM hE hF
  have hentry (n : ℕ) (D : ZFSet.{u}) (hD : D ∈ I) (hn : ZFSet.pair (natSet n) D ∈ E) :
      degreeCode R (columns H n) = D := by
    obtain ⟨a,ha,hDa,_⟩ := hF.2 D hD
    obtain ⟨B,hB,hDB⟩ := (mem_degreeUniverse R D).mp (hI hD)
    have har : a ∈ R := degreeCode_subset R B (hDB ▸ ha)
    obtain ⟨A,rfl⟩ := hR a har
    rw [hH n D hD hn A ha hDa]
    have heq := ((realCode_mem_degreeCode R B A).mp (hDB ▸ ha)).2
    exact ((degreeCode_equal R har).mpr heq).trans hDB.symm
  refine ⟨H,hHM,?_⟩
  apply ZFSet.ext; intro D
  constructor
  · intro hD
    obtain ⟨n,rfl⟩ := (mem_presentationSet R H D).mp hD
    obtain ⟨D,hD,hn,_⟩ := hE.2 (natSet n) ((mem_omega _).mpr ⟨n,rfl⟩)
    rw [hentry n D hD hn]
    exact hD
  · intro hD
    obtain ⟨n,hn,hDn⟩ := honto D hD
    obtain ⟨n,rfl⟩ := (mem_omega n).mp hn
    exact (mem_presentationSet R H D).mpr ⟨n,(hentry n D hD hDn).symm⟩

end TuringRigidity.BoundedSetTheory

end OAI