lean/OAI/Computability/DegreeRigidity/OrdinalCodes/OmegaModelCollapse.lean

import OAI.Computability.DegreeRigidity.OrdinalCodes.OmegaModelCore

namespace OAI

namespace TuringRigidity.OmegaModelCore
open BoundedSetTheory TransitiveNameModel SetModelReals
universe u
noncomputable section
namespace OmegaData
variable {α : Type u} (S : OmegaData α)

def collapse : S.Core → ZFSet.{u} := S.core_wellFounded.fix
  (fun x rec => ZFSet.range (fun y : {y : S.Core // S.Rel y x} => rec y.val y.property))

theorem collapse_eq (x : S.Core) :
    S.collapse x = ZFSet.range (fun y : {y : S.Core // S.Rel y x} => S.collapse y.val) := by
  rw [collapse,WellFounded.fix_eq]

@[simp] theorem mem_collapse (x : S.Core) (z : ZFSet.{u}) :
    z ∈ S.collapse x ↔ ∃ y : S.Core, S.Rel y x ∧ z = S.collapse y := by
  rw [S.collapse_eq,ZFSet.mem_range]
  constructor
  · rintro ⟨⟨y,hy⟩,he⟩
    exact ⟨y,hy,he.symm⟩
  · rintro ⟨y,hy,he⟩
    exact ⟨⟨y,hy⟩,he.symm⟩

theorem collapse_injective : Function.Injective S.collapse := by
  intro x
  induction x using S.core_wellFounded.induction with
  | h x ih =>
    intro y he
    apply S.core_extensional
    intro z
    constructor
    · intro hz
      have hm : S.collapse z ∈ S.collapse y := he ▸ (S.mem_collapse x _).mpr ⟨z,hz,rfl⟩
      obtain ⟨w,hw,hew⟩ := (S.mem_collapse y _).mp hm
      have hzw := ih z hz hew
      exact hzw ▸ hw
    · intro hz
      have hm : S.collapse z ∈ S.collapse x := he.symm ▸ (S.mem_collapse y _).mpr ⟨z,hz,rfl⟩
      obtain ⟨w,hw,hew⟩ := (S.mem_collapse x _).mp hm
      have hwz := ih w hw hew.symm
      exact hwz ▸ hw

@[simp] theorem collapse_mem_iff (x y : S.Core) : S.collapse x ∈ S.collapse y ↔ S.Rel x y := by
  rw [S.mem_collapse]
  constructor
  · rintro ⟨z,hz,he⟩
    exact S.collapse_injective he ▸ hz
  · intro h
    exact ⟨x,h,rfl⟩

def collapsedModel : ZFSet.{u} := ZFSet.range S.collapse

@[simp] theorem mem_collapsedModel (z : ZFSet.{u}) :
    z ∈ S.collapsedModel ↔ ∃ x : S.Core, z = S.collapse x := by
  rw [collapsedModel,ZFSet.mem_range]
  exact exists_congr (fun x => eq_comm)

theorem collapsedModel_transitive : Transitive S.collapsedModel := by
  intro x hx y hy
  obtain ⟨a,rfl⟩ := (S.mem_collapsedModel x).mp hx
  obtain ⟨b,hb,rfl⟩ := (S.mem_collapse a y).mp hy
  exact (S.mem_collapsedModel _).mpr ⟨b,rfl⟩

def numNode (n : ℕ) : S.Core := ⟨S.num n,0,(S.omega_mem _).mpr ⟨n,rfl⟩⟩

theorem rel_numNode (x : S.Core) (n : ℕ) :
    S.Rel x (S.numNode n) ↔ ∃ k < n, x = S.numNode k := by
  change S.mem x.val (S.num n) ↔ _
  rw [S.num_mem]
  constructor
  · rintro ⟨k,hk,he⟩
    exact ⟨k,hk,Subtype.ext he⟩
  · rintro ⟨k,hk,rfl⟩
    exact ⟨k,hk,rfl⟩

theorem collapse_num (n : ℕ) : S.collapse (S.numNode n) = natSet n := by
  induction n using Nat.strong_induction_on with
  | h n ih =>
    apply ZFSet.ext
    intro z
    rw [S.mem_collapse,mem_natSet]
    constructor
    · rintro ⟨x,hx,hz⟩
      obtain ⟨k,hk,rfl⟩ := (S.rel_numNode x n).mp hx
      exact ⟨k,hk,hz.trans (ih k hk)⟩
    · rintro ⟨k,hk,rfl⟩
      exact ⟨S.numNode k,(S.rel_numNode _ n).mpr ⟨k,hk,rfl⟩,(ih k hk).symm⟩

def omegaNode : S.Core := ⟨S.omega,1,(S.mem_power S.omega S.omega).mpr (fun _ h => h)⟩

theorem collapse_omega : S.collapse S.omegaNode = ZFSet.omega := by
  apply ZFSet.ext
  intro z
  rw [S.mem_collapse,mem_omega]
  constructor
  · rintro ⟨x,hx,hz⟩
    obtain ⟨n,hn⟩ := (S.omega_mem x.val).mp hx
    have he : x = S.numNode n := Subtype.ext hn
    exact ⟨n,by rw [hz,he,S.collapse_num]⟩
  · rintro ⟨n,rfl⟩
    exact ⟨S.numNode n,(S.omega_mem _).mpr ⟨n,rfl⟩,(S.collapse_num n).symm⟩

theorem collapsedModel_omega : ZFSet.omega.{u} ∈ S.collapsedModel :=
  (S.mem_collapsedModel _).mpr ⟨S.omegaNode,S.collapse_omega.symm⟩

theorem collapse_real (x : α) (hx : S.mem x (S.power S.omega)) :
    ∃ A : TuringRigidity.Oracle,
      S.collapse (⟨x,1,hx⟩ : S.Core) = realSet A ∧
      ∀ n, A n = true ↔ S.mem (S.num n) x := by
  let c : S.Core := ⟨x,1,hx⟩
  have hsub : S.collapse c ⊆ ZFSet.omega := by
    intro z hz
    obtain ⟨y,hy,rfl⟩ := (S.mem_collapse c z).mp hz
    have hyω := (S.mem_power _ _).mp hx y.val hy
    rw [←S.collapse_omega,S.collapse_mem_iff]
    exact hyω
  refine ⟨oracleOf (S.collapse c),(realSet_oracleOf hsub).symm,?_⟩
  intro n
  simp only [oracleOf,decide_eq_true_eq]
  rw [←S.collapse_num,S.collapse_mem_iff]
  rfl

end OmegaData
end
end TuringRigidity.OmegaModelCore

end OAI