Download data/lean/OAI/Computability/DegreeRigidity/SetModels/ElementarySchemas.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 6.06 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Computability/DegreeRigidity/SetModels/ElementarySchemas.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Computability/DegreeRigidity/SetModels/ElementarySchemas.lean
-
curl -L -o ElementarySchemas.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Computability/DegreeRigidity/SetModels/ElementarySchemas.lean
6.06 kB
| 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 | |