| import OAI.Computability.DegreeRigidity.SetModels.ElementaryAxioms |
|
|
| namespace OAI |
|
|
|
|
| namespace TuringRigidity.ElementaryModel |
| open BoundedSetTheory TransitiveNameModel SentenceForm |
| universe u |
|
|
| private def sepMap : ℕ → ℕ | 0 => 0 | i+1 => i+3 |
| private def relationMap : ℕ → ℕ | 0 => 0 | 1 => 1 | i+2 => i+3 |
| private def uniqueMap : ℕ → ℕ | 0 => 0 | 1 => 2 | i+2 => i+4 |
| private def imageMap : ℕ → ℕ | 0 => 1 | 1 => 0 | i+2 => i+4 |
|
|
| private theorem sat_sepMap (q : SentenceForm) (D : Set ZFSet.{u}) |
| (x b a : ZFSet.{u}) (e : ℕ → ZFSet.{u}) : |
| (q.rename sepMap).Sat D (cons x (cons b (cons a e))) ↔ q.Sat D (cons x e) := by |
| rw [sat_rename] |
| have he : (fun i => cons x (cons b (cons a e)) (sepMap i)) = cons x e := by |
| funext i; cases i <;> rfl |
| rw [he] |
|
|
| private theorem sat_relationMap (q : SentenceForm) (D : Set ZFSet.{u}) |
| (y x a : ZFSet.{u}) (e : ℕ → ZFSet.{u}) : |
| (q.rename relationMap).Sat D (cons y (cons x (cons a e))) ↔ q.Sat D (cons y (cons x e)) := by |
| rw [sat_rename] |
| have he : (fun i => cons y (cons x (cons a e)) (relationMap i)) = cons y (cons x e) := by |
| funext i; rcases i with _|_|i <;> rfl |
| rw [he] |
|
|
| private theorem sat_uniqueMap (q : SentenceForm) (D : Set ZFSet.{u}) |
| (z y x a : ZFSet.{u}) (e : ℕ → ZFSet.{u}) : |
| (q.rename uniqueMap).Sat D (cons z (cons y (cons x (cons a e)))) ↔ q.Sat D (cons z (cons x e)) := by |
| rw [sat_rename] |
| have he : (fun i => cons z (cons y (cons x (cons a e))) (uniqueMap i)) = cons z (cons x e) := by |
| funext i; rcases i with _|_|i <;> rfl |
| rw [he] |
|
|
| private theorem sat_imageMap (q : SentenceForm) (D : Set ZFSet.{u}) |
| (x y b a : ZFSet.{u}) (e : ℕ → ZFSet.{u}) : |
| (q.rename imageMap).Sat D (cons x (cons y (cons b (cons a e)))) ↔ q.Sat D (cons y (cons x e)) := by |
| rw [sat_rename] |
| have he : (fun i => cons x (cons y (cons b (cons a e))) (imageMap i)) = cons y (cons x e) := by |
| funext i; rcases i with _|_|i <;> rfl |
| rw [he] |
|
|
| theorem Valid.separate {M : ZFSet.{u}} (hv : Valid M) (q : SentenceForm) |
| (e : ℕ → ZFSet.{u}) (he : ∀ i, e i ∈ M) (a : ZFSet.{u}) (ha : a ∈ M) : |
| ∃ b ∈ M, ∀ x ∈ M, x ∈ b ↔ x ∈ a ∧ q.Sat (M : Set ZFSet) (cons x e) := by |
| let p := ex (all (iff (.member 0 1) (.conj (.member 0 2) (q.rename sepMap)))) |
| have hp : ∀ v : ℕ → ZFSet.{u}, p.Sat Set.univ v := by |
| intro v |
| let e' := fun i => v (i+1) |
| have hv' : v = cons (v 0) e' := by funext i; cases i <;> rfl |
| rw [hv'] |
| simp only [p,Sat,sat_all,sat_iff,sat_sepMap,cons_zero,cons_succ,Set.mem_univ,true_and,forall_const] |
| exact ⟨ZFSet.sep (fun x => q.Sat Set.univ (cons x e')) (v 0),fun x => ZFSet.mem_sep⟩ |
| have h := hv p hp (cons a e) (by intro i; cases i <;> simp [cons,he,ha]) |
| simpa only [p,Sat,sat_all,sat_iff,sat_sepMap,cons_zero,cons_succ,SetLike.mem_coe] using h |
|
|
| theorem ambient_image (a : ZFSet.{u}) (R : ZFSet.{u} → ZFSet.{u} → Prop) |
| (ht : ∀ x ∈ a, ∃ y, R x y ∧ ∀ z, R x z → z = y) : |
| ∃ b : ZFSet.{u}, ∀ y, y ∈ b ↔ ∃ x ∈ a, R x y := by |
| classical |
| let f (i : Conditions a) := Classical.choose (ht (label a i) (label_mem a i)) |
| have hf (i : Conditions a) : R (label a i) (f i) ∧ ∀ z, R (label a i) z → z = f i := |
| Classical.choose_spec (ht _ (label_mem a i)) |
| refine ⟨ZFSet.range f,?_⟩ |
| intro y; rw [ZFSet.mem_range] |
| constructor |
| · rintro ⟨i,rfl⟩; exact ⟨_,label_mem a i,(hf i).1⟩ |
| · rintro ⟨x,hx,hr⟩ |
| obtain ⟨i,rfl⟩ := label_surjective a hx |
| exact ⟨i,((hf i).2 y hr).symm⟩ |
|
|
| theorem Valid.replace {M : ZFSet.{u}} (hv : Valid M) (hM : Transitive M) (q : SentenceForm) |
| (e : ℕ → ZFSet.{u}) (he : ∀ i, e i ∈ M) (a : ZFSet.{u}) (ha : a ∈ M) |
| (ht : ∀ x ∈ a, ∃ y ∈ M, q.Sat (M : Set ZFSet) (cons y (cons x e)) ∧ |
| ∀ z ∈ M, q.Sat (M : Set ZFSet) (cons z (cons x e)) → z = y) : |
| ∃ b ∈ M, ∀ y ∈ M, y ∈ b ↔ ∃ x ∈ a, q.Sat (M : Set ZFSet) (cons y (cons x e)) := by |
| let p := imp |
| (all (imp (.member 0 1) (ex (.conj (q.rename relationMap) |
| (all (imp (q.rename uniqueMap) (.equal 0 1))))))) |
| (ex (all (iff (.member 0 1) (ex (.conj (.member 0 3) (q.rename imageMap)))))) |
| have hp : ∀ v : ℕ → ZFSet.{u}, p.Sat Set.univ v := by |
| intro v |
| let e' := fun i => v (i+1) |
| have hv' : v = cons (v 0) e' := by funext i; cases i <;> rfl |
| rw [hv'] |
| simp only [p,Sat,sat_all,sat_iff,sat_imp,sat_relationMap,sat_uniqueMap,sat_imageMap, |
| cons_zero,cons_succ,Set.mem_univ,true_and,forall_const] |
| exact ambient_image (v 0) (fun x y => q.Sat Set.univ (cons y (cons x e'))) |
| have h := hv p hp (cons a e) (by intro i; cases i <;> simp [cons,he,ha]) |
| simp only [p,Sat,sat_all,sat_iff,sat_imp,sat_relationMap,sat_uniqueMap,sat_imageMap, |
| cons_zero,cons_succ] at h |
| obtain ⟨b,hb,hbdef⟩ := h (fun x _ hx => ht x hx) |
| refine ⟨b,hb,?_⟩ |
| intro y hy |
| rw [hbdef y hy] |
| exact ⟨fun ⟨x,_,hx,hr⟩ => ⟨x,hx,hr⟩,fun ⟨x,hx,hr⟩ => ⟨x,hM a ha x hx,hx,hr⟩⟩ |
|
|
| theorem Valid.sigmaSeparation {M : ZFSet.{u}} (hv : Valid M) : SigmaSeparation M := by |
| intro p e he a ha |
| obtain ⟨b,hb,h⟩ := hv.separate (fromSigma p) e he a ha |
| exact ⟨b,hb,fun x hx => (h x hx).trans (and_congr_right (fun _ => sigma_sat p M _))⟩ |
|
|
| theorem Valid.sigmaReplacement {M : ZFSet.{u}} (hv : Valid M) (hM : Transitive M) : SigmaReplacement M := by |
| intro p e he a ha ht |
| obtain ⟨b,hb,h⟩ := hv.replace hM (fromSigma p) e he a ha (by |
| intro x hx |
| obtain ⟨y,hy,hp,hu⟩ := ht x hx |
| exact ⟨y,hy,(sigma_sat p M _).mpr hp,fun z hz hpz => hu z hz ((sigma_sat p M _).mp hpz)⟩) |
| refine ⟨b,hb,?_⟩ |
| intro y hy |
| rw [h y hy] |
| apply exists_congr; intro x |
| exact and_congr_right (fun _ => sigma_sat p M _) |
|
|
| theorem Valid.sourceT {M : ZFSet.{u}} (hv : Valid M) (hM : Transitive M) |
| (hne : ∃ a, a ∈ M) : SourceT M := |
| sourceT_of_finite_schemas M hM hv.pairing hv.union hv.powerSet hv.sigmaSeparation |
| (hv.sigmaReplacement hM) (hv.infinity hne) (hv.choice hM) |
|
|
| end TuringRigidity.ElementaryModel |
|
|
| end OAI |
|
|
