| import OAI.Computability.DegreeRigidity.SetModels.InternalRelationCollapse |
|
|
| namespace OAI |
|
|
|
|
| namespace TuringRigidity.RelationCollapse |
| open TransitiveNameModel BoundedSetTheory |
| universe u |
|
|
| theorem internal_graph (M d r : ZFSet.{u}) (hM : Transitive M) |
| (hP : Pairing M) (hU : BoundedSetTheory.Union M) (hPow : PowerSet M) |
| (hS : Separation M) (hR : SigmaReplacement M) |
| (hd : d ∈ M) (hr : r ∈ M) (wf : WellFounded (Rel d r)) : |
| ∃ f ∈ M, Graph d r d (iterUnion 2 f) f := by |
| obtain ⟨q,hqM,hq⟩ := internal_power M hM hPow hd |
| let e := cons q (cons d (cons r (fun _ => d))) |
| have he : ∀ i, e i ∈ M := by |
| intro i; rcases i with _|i; exact hqM |
| rcases i with _|i; exact hd |
| rcases i with _|i; exact hr |
| exact hd |
| have cert (x f : ZFSet.{u}) (hx : x ∈ d) (hf : f ∈ M) : |
| certificate.Realize M (cons f (cons x e)) ↔ |
| ∃ b ∈ M, Graph d r (RelationHull.hull d r q x) b f := |
| realize_certificate M d r q hM hS hd hr hqM hq hx hf |
| obtain ⟨B,hB,hBdef⟩ := hR certificate e he d hd (by |
| intro x hx |
| obtain ⟨f,hf,hfg⟩ := internal_hull_graph M d r q hM hP hU hS hR hd hr hqM hq wf x hx |
| refine ⟨f,hf,(cert x f hx hf).mpr ⟨_,iterUnion_mem M hM hU hf 2,hfg⟩,?_⟩ |
| intro g hg hcg |
| obtain ⟨b,_,hgg⟩ := (cert x g hx hg).mp hcg |
| exact hgg.unique wf hfg) |
| have hBg (f : ZFSet.{u}) : f ∈ B ↔ |
| ∃ x ∈ d, ∃ b ∈ M, Graph d r (RelationHull.hull d r q x) b f := by |
| constructor |
| · intro hf |
| have hfM := hM B hB f hf |
| obtain ⟨x,hx,hc⟩ := (hBdef f hfM).mp hf |
| exact ⟨x,hx,(cert x f hx hfM).mp hc⟩ |
| · rintro ⟨x,hx,b,hb,hg⟩ |
| obtain ⟨g,hgM,hgg⟩ := internal_hull_graph M d r q hM hP hU hS hR hd hr hqM hq wf x hx |
| have hfM : f ∈ M := hg.unique wf hgg ▸ hgM |
| exact (hBdef f hfM).mpr ⟨x,hx,(cert x f hx hfM).mpr ⟨b,hb,hg⟩⟩ |
| refine ⟨ZFSet.sUnion B,union_mem M hM hU hB, |
| graph_of_mem_iff d r d _ wf (fun _ h => h) (fun _ _ _ h _ => h) ?_⟩ |
| intro z |
| rw [ZFSet.mem_sUnion] |
| constructor |
| · rintro ⟨f,hf,hzf⟩ |
| obtain ⟨x,_,b,_,hfg⟩ := (hBg f).mp hf |
| obtain ⟨y,hy,hz⟩ := (hfg.mem_iff wf z).mp hzf |
| exact ⟨y,RelationHull.hull_subset d r q x hy,hz⟩ |
| · rintro ⟨x,hx,hz⟩ |
| obtain ⟨f,hf,hfg⟩ := internal_hull_graph M d r q hM hP hU hS hR hd hr hqM hq wf x hx |
| exact ⟨f,(hBg f).mpr ⟨x,hx,_,iterUnion_mem M hM hU hf 2,hfg⟩, |
| (hfg.mem_iff wf z).mpr ⟨x,RelationHull.self_mem d r q hx,hz⟩⟩ |
|
|
| def On (d r : ZFSet.{u}) : Prop := r ⊆ ZFSet.prod d d |
|
|
| theorem right_mem {d r x y : ZFSet.{u}} (hr : On d r) (hyx : ZFSet.pair y x ∈ r) : x ∈ d := by |
| obtain ⟨a,_,b,hb,heq⟩ := ZFSet.mem_prod.mp (hr hyx) |
| exact (ZFSet.pair_inj.mp heq).2 ▸ hb |
|
|
| theorem Graph.wellFounded {d r b f : ZFSet.{u}} (hr : On d r) |
| (hg : Graph d r d b f) : WellFounded (Rel d r) := by |
| classical |
| let F : ZFSet.{u} → ZFSet.{u} := fun x => |
| if hx : x ∈ d then (hg.2.2.2.1 x hx).choose else ∅ |
| have hF (x : ZFSet.{u}) (hx : x ∈ d) : |
| F x ∈ b ∧ ZFSet.pair x (F x) ∈ f := by |
| simpa only [F,dite_eq_left hx] using (hg.2.2.2.1 x hx).choose_spec |>.imp_right And.left |
| have wf : WellFounded (fun y x => F y ∈ F x) := InvImage.wf F ZFSet.mem_wf |
| apply wf.mono |
| intro y x hyx |
| have hx := right_mem hr hyx.2 |
| exact (hg.2.2.2.2 x hx (F x) (hF x hx).1 (hF x hx).2).2 |
| y hyx.1 hyx.2 (F y) (hF y hyx.1).1 (hF y hyx.1).2 |
|
|
| namespace Code |
|
|
| def full (d r f : ℕ) : SigmaFormula := |
| .existsSet (.bounded (graph (d+1) (r+1) (d+1) 0 (f+1))) |
|
|
| theorem realize_full (M : ZFSet.{u}) (hM : Transitive M) |
| (e : ℕ → ZFSet.{u}) (he : ∀ i, e i ∈ M) (d r f : ℕ) : |
| (full d r f).Realize M e ↔ ∃ b ∈ M, Graph (e d) (e r) (e d) b (e f) := by |
| change (∃ b ∈ M, _) ↔ _ |
| apply exists_congr |
| intro b |
| apply and_congr_right |
| intro hb |
| simp only [SigmaFormula.Realize] |
| rw [Formula.absolute _ M hM _ (by intro i; cases i with |
| | zero => exact hb |
| | succ i => exact he i)] |
| exact eval_graph (d+1) (r+1) (d+1) 0 (f+1) _ |
| end Code |
|
|
| end TuringRigidity.RelationCollapse |
|
|
| end OAI |
|
|
