| import OAI.Computability.DegreeRigidity.SetModels.ChoiceTrace |
|
|
| namespace OAI |
|
|
|
|
| namespace TuringRigidity.BoundedSetTheory |
| open TransitiveNameModel |
| universe u |
| namespace InternalWellOrder |
| open Formula |
|
|
| def remainingFormula (a f i r : ℕ) : Formula := |
| .conj (.subset r a) (.allMem a (.iff (.member 0 (r+1)) |
| (.neg (.existsMem (i+1) (.pairMem 0 1 (f+2)))))) |
|
|
| theorem eval_remainingFormula (a f i r : ℕ) (e : ℕ → ZFSet.{u}) : |
| (remainingFormula a f i r).Eval e ↔ Remaining (e a) (e f) (e i) (e r) := by |
| simp only [remainingFormula,Remaining,Formula.Eval,eval_subset,eval_allMem,eval_iff, |
| eval_pairMem,cons_zero,cons_succ] |
|
|
| def traceFormula (α a q s f : ℕ) : Formula := .conj |
| (.allMem f (.existsMem (α+1) (.existsMem (a+2) (.orderedPair 2 1 0)))) |
| (.conj |
| (.allMem α (.allMem (a+1) (.imp (.pairMem 1 0 (f+2)) |
| (.allMem 1 (.existsMem (a+3) (.pairMem 1 0 (f+4))))))) |
| (.allMem α (.allMem (a+1) (.imp (.pairMem 1 0 (f+2)) |
| (.existsMem (q+2) (.conj (remainingFormula (a+3) (f+3) 2 0) (.pairMem 0 1 (s+3)))))))) |
|
|
| theorem eval_traceFormula (α a q s f : ℕ) (e : ℕ → ZFSet.{u}) : |
| (traceFormula α a q s f).Eval e ↔ Trace (e α) (e a) (e q) (e s) (e f) := by |
| simp only [traceFormula,Formula.Eval,eval_allMem,eval_imp,eval_orderedPair, |
| eval_pairMem,eval_remainingFormula,cons_zero,cons_succ] |
| exact ⟨fun ⟨hshape,hinitial,hchoice⟩ => ⟨hshape,hinitial,hchoice⟩, |
| fun h => ⟨h.shape,h.initial,h.choice⟩⟩ |
|
|
| theorem Trace.subset {α a q s f : ZFSet.{u}} (hf : Trace α a q s f) : f ⊆ ZFSet.prod α a := |
| fun z hz => ZFSet.mem_prod.mpr (hf.shape z hz) |
|
|
| theorem internal_maximal_trace (M : ZFSet.{u}) (hM : Transitive M) |
| (hP : Pairing M) (hU : BoundedSetTheory.Union M) (hPow : PowerSet M) (hS : Separation M) |
| {α a q s : ZFSet.{u}} (hαM : α ∈ M) (ha : a ∈ M) (hq : q ∈ M) (hsM : s ∈ M) |
| (hα : Transitive α) (hs : ChoiceGraph q s) : |
| ∃ F ∈ M, Trace α a q s F ∧ ∀ f ∈ M, Trace α a q s f → f ⊆ F := by |
| have hp := product_mem M hM hP hU hPow hS hαM ha |
| obtain ⟨P,hP0,hPdef⟩ := internal_power M hM hPow hp |
| let e := cons α (cons a (cons q (fun _ => s))) |
| have he : ∀ i, e i ∈ M := by |
| intro i; rcases i with _|i; exact hαM |
| rcases i with _|i; exact ha |
| rcases i with _|i; exact hq |
| exact hsM |
| let C := ZFSet.sep (fun f => (traceFormula 1 2 3 4 0).Eval (cons f e)) P |
| have hC : C ∈ M := sep_mem M hM hS (traceFormula 1 2 3 4 0) e he hP0 |
| have hCdef (f : ZFSet.{u}) : f ∈ C ↔ f ∈ M ∧ Trace α a q s f := by |
| rw [ZFSet.mem_sep,hPdef,eval_traceFormula] |
| constructor |
| · rintro ⟨⟨hf,_⟩,ht⟩; exact ⟨hf,ht⟩ |
| · rintro ⟨hf,ht⟩; exact ⟨⟨hf,ht.subset⟩,ht⟩ |
| refine ⟨ZFSet.sUnion C,union_mem M hM hU hC,Trace.sUnion hα hs (fun f hf => ((hCdef f).mp hf).2),?_⟩ |
| intro f hf htrace z hz |
| exact ZFSet.mem_sUnion.mpr ⟨f,(hCdef f).mpr ⟨hf,htrace⟩,hz⟩ |
| |
| noncomputable def residual (a f i : ZFSet.{u}) : ZFSet.{u} := |
| ZFSet.sep (fun x => ¬ ∃ j ∈ i, ZFSet.pair j x ∈ f) a |
|
|
| theorem residual_remaining (a f i : ZFSet.{u}) : Remaining a f i (residual a f i) := by |
| refine ⟨fun _ hx => (ZFSet.mem_sep.mp hx).1,?_⟩ |
| intro x hx |
| exact ZFSet.mem_sep.trans (and_iff_right hx) |
|
|
| theorem residual_mem (M : ZFSet.{u}) (hM : Transitive M) (hS : Separation M) |
| {a f i : ZFSet.{u}} (ha : a ∈ M) (hf : f ∈ M) (hi : i ∈ M) : residual a f i ∈ M := by |
| simpa only [residual,Formula.Eval,eval_pairMem,cons_zero,cons_succ] using |
| sep_mem M hM hS (.neg (.existsMem 2 (.pairMem 0 1 2))) (cons f (fun _ => i)) |
| (by intro j; cases j <;> assumption) ha |
| |
| end InternalWellOrder |
| end TuringRigidity.BoundedSetTheory |
| |
| end OAI |
| |
