openAI-math-dataset / lean /OAI /Computability /DegreeRigidity /SetModels /CountableElementaryHull.lean
| import OAI.Computability.DegreeRigidity.SetModels.ElementaryLanguage | |
| import Mathlib.Data.Set.Countable | |
| namespace OAI | |
| namespace TuringRigidity.ElementaryModel | |
| open BoundedSetTheory | |
| universe u | |
| noncomputable def listEnv : List ZFSet.{u} → ℕ → ZFSet.{u} | |
| | [], _ => ∅ | |
| | x :: _, 0 => x | |
| | _ :: xs, n+1 => listEnv xs n | |
| noncomputable def envPrefix : ℕ → (ℕ → ZFSet.{u}) → List ZFSet.{u} | |
| | 0, _ => [] | |
| | n+1, e => e 0 :: envPrefix n (fun i => e (i+1)) | |
| theorem prefix_agrees (n : ℕ) (e : ℕ → ZFSet.{u}) : | |
| ∀ i, i < n → listEnv (envPrefix n e) i = e i := by | |
| induction n generalizing e with | |
| | zero => omega | |
| | succ n ih => | |
| intro i hi | |
| cases i with | |
| | zero => rfl | |
| | succ i => exact ih (fun j => e (j+1)) i (by omega) | |
| theorem prefix_members (n : ℕ) (e : ℕ → ZFSet.{u}) (D : Set ZFSet.{u}) | |
| (he : ∀ i, e i ∈ D) : ∀ x ∈ envPrefix n e, x ∈ D := by | |
| induction n generalizing e with | |
| | zero => simp [envPrefix] | |
| | succ n ih => | |
| intro x hx | |
| rcases List.mem_cons.mp hx with rfl|hx | |
| · exact he 0 | |
| · exact ih _ (fun i => he (i+1)) x hx | |
| noncomputable def witness (p : SentenceForm) (xs : List ZFSet.{u}) : ZFSet.{u} := by | |
| classical | |
| exact if h : ∃ x : ZFSet.{u}, p.Sat Set.univ (cons x (listEnv xs)) then Classical.choose h else ∅ | |
| theorem witness_spec (p : SentenceForm) (xs : List ZFSet.{u}) | |
| (h : ∃ x : ZFSet.{u}, p.Sat Set.univ (cons x (listEnv xs))) : | |
| p.Sat Set.univ (cons (witness p xs) (listEnv xs)) := by | |
| classical | |
| simp only [witness,dite_eq_left h] | |
| exact Classical.choose_spec h | |
| noncomputable def stage (a : ℕ → ZFSet.{u}) : ℕ → Set ZFSet.{u} | |
| | 0 => Set.range a | |
| | n+1 => stage a n ∪ {x | ∃ p : SentenceForm, ∃ xs : List ZFSet.{u}, | |
| (∀ y ∈ xs, y ∈ stage a n) ∧ x = witness p xs} | |
| noncomputable def hull (a : ℕ → ZFSet.{u}) : Set ZFSet.{u} := ⋃ n, stage a n | |
| theorem stage_mono (a : ℕ → ZFSet.{u}) : Monotone (stage a) := by | |
| apply monotone_nat_of_le_succ | |
| intro n x hx | |
| exact Or.inl hx | |
| theorem stage_countable (a : ℕ → ZFSet.{u}) (n : ℕ) : (stage a n).Countable := by | |
| induction n with | |
| | zero => exact Set.countable_range a | |
| | succ n ih => | |
| apply ih.union | |
| let : Countable (stage a n) := ih.to_subtype | |
| have hc := Set.countable_range (fun z : SentenceForm × List (stage a n) => | |
| witness z.1 (z.2.map Subtype.val)) | |
| apply hc.mono | |
| rintro x ⟨p,xs,hxs,rfl⟩ | |
| let ys : List (stage a n) := xs.attach.map (fun y => ⟨y.val,hxs y.val y.property⟩) | |
| have hy : ys.map Subtype.val = xs := by simp [ys,List.map_map] | |
| exact ⟨(p,ys),by simp only [hy]⟩ | |
| theorem hull_countable (a : ℕ → ZFSet.{u}) : (hull a).Countable := | |
| Set.countable_iUnion (stage_countable a) | |
| theorem parameter_mem (a : ℕ → ZFSet.{u}) (n : ℕ) : a n ∈ hull a := | |
| Set.mem_iUnion.mpr ⟨0,⟨n,rfl⟩⟩ | |
| theorem list_in_stage (a : ℕ → ZFSet.{u}) (xs : List ZFSet.{u}) | |
| (hxs : ∀ x ∈ xs, x ∈ hull a) : ∃ n, ∀ x ∈ xs, x ∈ stage a n := by | |
| induction xs with | |
| | nil => exact ⟨0,by simp⟩ | |
| | cons x xs ih => | |
| obtain ⟨n,hn⟩ := Set.mem_iUnion.mp (hxs x (by simp)) | |
| obtain ⟨m,hm⟩ := ih (fun y hy => hxs y (by simp [hy])) | |
| refine ⟨max n m,?_⟩ | |
| intro y hy | |
| rcases List.mem_cons.mp hy with rfl|hy | |
| · exact stage_mono a (Nat.le_max_left n m) hn | |
| · exact stage_mono a (Nat.le_max_right n m) (hm y hy) | |
| theorem witness_mem (a : ℕ → ZFSet.{u}) (p : SentenceForm) (xs : List ZFSet.{u}) | |
| (hxs : ∀ x ∈ xs, x ∈ hull a) : witness p xs ∈ hull a := by | |
| obtain ⟨n,hn⟩ := list_in_stage a xs hxs | |
| exact Set.mem_iUnion.mpr ⟨n+1,Or.inr ⟨p,xs,hn,rfl⟩⟩ | |
| theorem hull_elementary (a : ℕ → ZFSet.{u}) : Elementary (hull a) := by | |
| intro p | |
| induction p with | |
| | equal => intros; rfl | |
| | member => intros; rfl | |
| | conj p q ihp ihq => intro e he; exact and_congr (ihp e he) (ihq e he) | |
| | neg p ih => intro e he; exact not_congr (ih e he) | |
| | ex p ih => | |
| intro e he | |
| constructor | |
| · rintro ⟨x,hx,hp⟩ | |
| exact ⟨x,Set.mem_univ x,(ih (cons x e) (by intro i; cases i <;> simp [cons,he,hx])).mp hp⟩ | |
| · rintro ⟨x,_,hp⟩ | |
| let xs := envPrefix p.bound e | |
| have eq (y : ZFSet.{u}) : p.Sat Set.univ (cons y (listEnv xs)) ↔ | |
| p.Sat Set.univ (cons y e) := by | |
| apply p.finite_support | |
| intro i hi | |
| cases i with | |
| | zero => rfl | |
| | succ i => exact prefix_agrees p.bound e i (by omega) | |
| have hw := witness_mem a p xs (prefix_members p.bound e (hull a) he) | |
| have hs := (eq _).mp (witness_spec p xs ⟨x,(eq x).mpr hp⟩) | |
| exact ⟨_,hw,(ih (cons (witness p xs) e) | |
| (by intro i; cases i <;> simp [cons,he,hw])).mpr hs⟩ | |
| end TuringRigidity.ElementaryModel | |
| end OAI | |