lean/OAI/Computability/DegreeRigidity/Syntax/BoundedSetTheory.lean

import OAI.Computability.DegreeRigidity.SetModels.TransitiveNameModel

namespace OAI

namespace TuringRigidity.BoundedSetTheory
open Set
open TransitiveNameModel (Transitive)
universe u

inductive Formula where
  | equal (i j : ℕ)
  | member (i j : ℕ)
  | conj (φ ψ : Formula)
  | neg (φ : Formula)
  | existsMem (i : ℕ) (φ : Formula)

def cons (x : ZFSet.{u}) (env : ℕ → ZFSet.{u}) : ℕ → ZFSet.{u}
  | 0 => x
  | n+1 => env n

@[simp] theorem cons_zero (x : ZFSet.{u}) (env : ℕ → ZFSet.{u}) : cons x env 0 = x := rfl
@[simp] theorem cons_succ (x : ZFSet.{u}) (env : ℕ → ZFSet.{u}) (n : ℕ) :
    cons x env (n+1) = env n := rfl

def Formula.Eval (env : ℕ → ZFSet.{u}) : Formula → Prop
  | .equal i j => env i = env j
  | .member i j => env i ∈ env j
  | .conj φ ψ => Eval env φ ∧ Eval env ψ
  | .neg φ => ¬ Eval env φ
  | .existsMem i φ => ∃ x ∈ env i, Eval (cons x env) φ

def Formula.Realize (M : ZFSet.{u}) (env : ℕ → ZFSet.{u}) : Formula → Prop
  | .equal i j => env i = env j
  | .member i j => env i ∈ env j
  | .conj φ ψ => Realize M env φ ∧ Realize M env ψ
  | .neg φ => ¬ Realize M env φ
  | .existsMem i φ => ∃ x ∈ M, x ∈ env i ∧ Realize M (cons x env) φ

theorem Formula.absolute (φ : Formula) (M : ZFSet.{u}) (hM : Transitive M)
    (env : ℕ → ZFSet.{u}) (he : ∀ i, env i ∈ M) :
    φ.Realize M env ↔ φ.Eval env := by
  induction φ generalizing env with
  | equal => rfl
  | member => rfl
  | conj φ ψ ihφ ihψ => exact and_congr (ihφ env he) (ihψ env he)
  | neg φ ih => exact not_congr (ih env he)
  | existsMem i φ ih =>
    constructor
    · rintro ⟨x,hx,hi,hφ⟩
      exact ⟨x,hi,(ih (cons x env) (fun n => by cases n <;> simp [cons,he,hx])).mp hφ⟩
    · rintro ⟨x,hi,hφ⟩
      have hx := hM _ (he i) _ hi
      exact ⟨x,hx,hi,(ih (cons x env) (fun n => by cases n <;> simp [cons,he,hx])).mpr hφ⟩

def Pairing (M : ZFSet.{u}) : Prop :=
  ∀ a ∈ M, ∀ b ∈ M, ∃ c ∈ M, ∀ x ∈ M, x ∈ c ↔ x = a ∨ x = b

def Union (M : ZFSet.{u}) : Prop :=
  ∀ a ∈ M, ∃ b ∈ M, ∀ x ∈ M, x ∈ b ↔ ∃ y ∈ M, y ∈ a ∧ x ∈ y

def PowerSet (M : ZFSet.{u}) : Prop :=
  ∀ a ∈ M, ∃ b ∈ M, ∀ x ∈ M, x ∈ b ↔ ∀ y ∈ M, y ∈ x → y ∈ a

def Separation (M : ZFSet.{u}) : Prop :=
  ∀ (φ : Formula) (env : ℕ → ZFSet.{u}), (∀ i, env i ∈ M) →
    ∀ a ∈ M, ∃ b ∈ M, ∀ x ∈ M, x ∈ b ↔ x ∈ a ∧ φ.Realize M (cons x env)

theorem pair_mem (M : ZFSet.{u}) (hM : Transitive M) (hP : Pairing M)
    {a b : ZFSet.{u}} (ha : a ∈ M) (hb : b ∈ M) : ({a,b} : ZFSet.{u}) ∈ M := by
  obtain ⟨c,hc,hcdef⟩ := hP a ha b hb
  have hc' : c = ({a,b} : ZFSet.{u}) := by
    apply ZFSet.ext
    intro x
    constructor
    · intro hx
      exact ZFSet.mem_pair.mpr ((hcdef x (hM c hc x hx)).mp hx)
    · intro hx
      have hx' := ZFSet.mem_pair.mp hx
      have hxM : x ∈ M := hx'.elim (fun h => h ▸ ha) (fun h => h ▸ hb)
      exact (hcdef x hxM).mpr hx'
  exact hc' ▸ hc

theorem singleton_mem (M : ZFSet.{u}) (hM : Transitive M) (hP : Pairing M)
    {a : ZFSet.{u}} (ha : a ∈ M) : ({a} : ZFSet.{u}) ∈ M := by
  simpa using pair_mem M hM hP ha ha

theorem orderedPair_mem (M : ZFSet.{u}) (hM : Transitive M) (hP : Pairing M)
    {a b : ZFSet.{u}} (ha : a ∈ M) (hb : b ∈ M) : ZFSet.pair a b ∈ M := by
  exact pair_mem M hM hP (singleton_mem M hM hP ha) (pair_mem M hM hP ha hb)

theorem union_mem (M : ZFSet.{u}) (hM : Transitive M) (hU : Union M)
    {a : ZFSet.{u}} (ha : a ∈ M) : ZFSet.sUnion a ∈ M := by
  obtain ⟨b,hb,hbdef⟩ := hU a ha
  have he : b = ZFSet.sUnion a := by
    apply ZFSet.ext
    intro x
    constructor
    · intro hx
      obtain ⟨y,_,hy,hxy⟩ := (hbdef x (hM b hb x hx)).mp hx
      exact ZFSet.mem_sUnion.mpr ⟨y,hy,hxy⟩
    · intro hx
      obtain ⟨y,hy,hxy⟩ := ZFSet.mem_sUnion.mp hx
      have hyM := hM a ha y hy
      exact (hbdef x (hM y hyM x hxy)).mpr ⟨y,hyM,hy,hxy⟩
  exact he ▸ hb

theorem internal_power (M : ZFSet.{u}) (hM : Transitive M) (hP : PowerSet M)
    {a : ZFSet.{u}} (ha : a ∈ M) :
    ∃ b ∈ M, ∀ x, x ∈ b ↔ x ∈ M ∧ x ⊆ a := by
  obtain ⟨b,hb,hbdef⟩ := hP a ha
  refine ⟨b,hb,fun x => ?_⟩
  constructor
  · intro hx
    have hxM := hM b hb x hx
    exact ⟨hxM,fun y hy => (hbdef x hxM).mp hx y (hM x hxM y hy) hy⟩
  · rintro ⟨hxM,hsub⟩
    exact (hbdef x hxM).mpr (fun y _ hy => hsub hy)

theorem sep_mem (M : ZFSet.{u}) (hM : Transitive M) (hS : Separation M)
    (φ : Formula) (env : ℕ → ZFSet.{u}) (he : ∀ i, env i ∈ M)
    {a : ZFSet.{u}} (ha : a ∈ M) :
    ZFSet.sep (fun x => φ.Eval (cons x env)) a ∈ M := by
  obtain ⟨b,hb,hbdef⟩ := hS φ env he a ha
  have heq : b = ZFSet.sep (fun x => φ.Eval (cons x env)) a := by
    apply ZFSet.ext
    intro x
    constructor
    · intro hx
      have hxM := hM b hb x hx
      obtain ⟨hxa,hφ⟩ := (hbdef x hxM).mp hx
      refine ZFSet.mem_sep.mpr ⟨hxa,?_⟩
      exact (φ.absolute M hM _ (fun n => by cases n <;> simp [cons,he,hxM])).mp hφ
    · intro hx
      obtain ⟨hxa,hφ⟩ := ZFSet.mem_sep.mp hx
      have hxM := hM a ha x hxa
      apply (hbdef x hxM).mpr
      exact ⟨hxa,(φ.absolute M hM _ (fun n => by cases n <;> simp [cons,he,hxM])).mpr hφ⟩
  exact heq ▸ hb

namespace Formula

def disj (φ ψ : Formula) : Formula := .neg (.conj (.neg φ) (.neg ψ))
def allMem (i : ℕ) (φ : Formula) : Formula := .neg (.existsMem i (.neg φ))

@[simp] theorem eval_disj (φ ψ : Formula) (env : ℕ → ZFSet.{u}) :
    (disj φ ψ).Eval env ↔ φ.Eval env ∨ ψ.Eval env := by
  classical
  simp only [disj,Eval]
  constructor
  · intro h
    by_cases hφ : φ.Eval env
    · exact Or.inl hφ
    · exact Or.inr (Classical.byContradiction (fun hψ => h ⟨hφ,hψ⟩))
  · intro h hn
    exact h.elim hn.1 hn.2

@[simp] theorem eval_allMem (i : ℕ) (φ : Formula) (env : ℕ → ZFSet.{u}) :
    (allMem i φ).Eval env ↔ ∀ x ∈ env i, φ.Eval (cons x env) := by
  classical
  simp [allMem,Eval]

def singleton (s a : ℕ) : Formula :=
  .conj (.member a s) (allMem s (.equal 0 (a+1)))

def unorderedPair (s a b : ℕ) : Formula :=
  .conj (.member a s) (.conj (.member b s)
    (allMem s (disj (.equal 0 (a+1)) (.equal 0 (b+1)))))

@[simp] theorem eval_singleton (s a : ℕ) (env : ℕ → ZFSet.{u}) :
    (singleton s a).Eval env ↔ env s = ({env a} : ZFSet.{u}) := by
  simp only [singleton,Eval,eval_allMem,cons_zero,cons_succ]
  constructor
  · rintro ⟨ha,hall⟩
    apply ZFSet.ext
    intro x
    rw [ZFSet.mem_singleton]
    exact ⟨hall x,fun hx => hx ▸ ha⟩
  · intro h
    simp [h]

@[simp] theorem eval_unorderedPair (s a b : ℕ) (env : ℕ → ZFSet.{u}) :
    (unorderedPair s a b).Eval env ↔ env s = ({env a,env b} : ZFSet.{u}) := by
  simp only [unorderedPair,Eval,eval_allMem,eval_disj,cons_zero,cons_succ]
  constructor
  · rintro ⟨ha,hb,hall⟩
    apply ZFSet.ext
    intro x
    rw [ZFSet.mem_pair]
    exact ⟨hall x,fun hx => hx.elim (fun h => h ▸ ha) (fun h => h ▸ hb)⟩
  · intro h
    simp [h]

def orderedPair (s a b : ℕ) : Formula :=
  .conj (allMem s (disj (singleton 0 (a+1)) (unorderedPair 0 (a+1) (b+1))))
    (.conj (.existsMem s (singleton 0 (a+1)))
      (.existsMem s (unorderedPair 0 (a+1) (b+1))))

@[simp] theorem eval_orderedPair (s a b : ℕ) (env : ℕ → ZFSet.{u}) :
    (orderedPair s a b).Eval env ↔ env s = ZFSet.pair (env a) (env b) := by
  simp only [orderedPair,Eval,eval_allMem,eval_disj,eval_singleton,
    eval_unorderedPair,cons_zero,cons_succ]
  constructor
  · rintro ⟨hall,⟨x,hx,hxa⟩,y,hy,hyab⟩
    apply ZFSet.ext
    intro z
    change z ∈ env s ↔ z ∈ ({({env a} : ZFSet.{u}),({env a,env b} : ZFSet.{u})} : ZFSet.{u})
    rw [ZFSet.mem_pair]
    exact ⟨hall z,fun hz => hz.elim (fun h => h ▸ hxa ▸ hx) (fun h => h ▸ hyab ▸ hy)⟩
  · intro h
    rw [h]
    simp [ZFSet.pair]

def pairMem (a b s : ℕ) : Formula := .existsMem s (orderedPair 0 (a+1) (b+1))

@[simp] theorem eval_pairMem (a b s : ℕ) (env : ℕ → ZFSet.{u}) :
    (pairMem a b s).Eval env ↔ ZFSet.pair (env a) (env b) ∈ env s := by
  simp [pairMem,Eval]
end Formula

end TuringRigidity.BoundedSetTheory

end OAI