| import OAI.Computability.DegreeRigidity.SetModels.InternalFixedPoint |
|
|
| namespace OAI |
|
|
| namespace TuringRigidity.AtomicForcing |
| open TransitiveNameModel BoundedSetTheory |
| universe u |
|
|
| def Triple (k f a b q : ZFSet.{u}) : Prop := |
| ∃ v ∈ k, v = ZFSet.pair a b ∧ ZFSet.pair v q ∈ f |
|
|
| def Match (flip : Bool) (d c k o f a y q : ZFSet.{u}) : Prop := |
| ∃ r ∈ c, ZFSet.pair r q ∈ o ∧ ∃ b ∈ d, ∃ t ∈ c, |
| ZFSet.pair b t ∈ y ∧ ZFSet.pair r t ∈ o ∧ |
| Triple k f (if flip then b else a) (if flip then a else b) r |
|
|
| def Side (flip : Bool) (d c k o f x y p : ZFSet.{u}) : Prop := |
| ∀ a ∈ d, ∀ s ∈ c, ZFSet.pair a s ∈ x → |
| ∀ q ∈ c, ZFSet.pair q p ∈ o → ZFSet.pair q s ∈ o → Match flip d c k o f a y q |
|
|
| def Step (d c k o f x y p : ZFSet.{u}) : Prop := |
| Side false d c k o f x y p ∧ Side true d c k o f y x p |
|
|
| def Vertex (d c k o f z : ZFSet.{u}) : Prop := |
| ∃ x ∈ d, ∃ y ∈ d, ∃ q ∈ c, ∃ v ∈ k, |
| v = ZFSet.pair x y ∧ z = ZFSet.pair v q ∧ Step d c k o f x y q |
|
|
| namespace AtomicFormula |
| open Formula |
|
|
| def triple (k f a b q : ℕ) : Formula := |
| .existsMem k (.conj (orderedPair 0 (a+1) (b+1)) (pairMem 0 (q+1) (f+1))) |
|
|
| theorem eval_triple (k f a b q : ℕ) (e : ℕ → ZFSet.{u}) : |
| (triple k f a b q).Eval e ↔ Triple (e k) (e f) (e a) (e b) (e q) := by |
| simp only [triple,Formula.Eval,eval_orderedPair,eval_pairMem,cons_zero,cons_succ,Triple] |
|
|
| def matchF (flip : Bool) (d c k o f a y q : ℕ) : Formula := |
| .existsMem c (.conj (pairMem 0 (q+1) (o+1)) |
| (.existsMem (d+1) (.existsMem (c+2) |
| (.conj (pairMem 1 0 (y+3)) (.conj (pairMem 2 0 (o+3)) |
| (triple (k+3) (f+3) (if flip then 1 else a+3) (if flip then a+3 else 1) 2)))))) |
|
|
| theorem eval_matchF (flip : Bool) (d c k o f a y q : ℕ) (e : ℕ → ZFSet.{u}) : |
| (matchF flip d c k o f a y q).Eval e ↔ |
| Match flip (e d) (e c) (e k) (e o) (e f) (e a) (e y) (e q) := by |
| cases flip <;> simp only [matchF,Formula.Eval,eval_pairMem,eval_triple, |
| cons_zero,cons_succ,Match,Bool.false_eq_true,ite_false,ite_true] |
|
|
| def side (flip : Bool) (d c k o f x y p : ℕ) : Formula := |
| allMem d (allMem (c+1) (imp (pairMem 1 0 (x+2)) |
| (allMem (c+2) (imp (.conj (pairMem 0 (p+3) (o+3)) (pairMem 0 1 (o+3))) |
| (matchF flip (d+3) (c+3) (k+3) (o+3) (f+3) 2 (y+3) 0))))) |
|
|
| theorem eval_side (flip : Bool) (d c k o f x y p : ℕ) (e : ℕ → ZFSet.{u}) : |
| (side flip d c k o f x y p).Eval e ↔ |
| Side flip (e d) (e c) (e k) (e o) (e f) (e x) (e y) (e p) := by |
| simp only [side,eval_allMem,eval_imp,Formula.Eval,eval_pairMem,eval_matchF, |
| cons_zero,cons_succ,Side,and_imp] |
|
|
| def step (d c k o f x y p : ℕ) : Formula := |
| .conj (side false d c k o f x y p) (side true d c k o f y x p) |
|
|
| theorem eval_step (d c k o f x y p : ℕ) (e : ℕ → ZFSet.{u}) : |
| (step d c k o f x y p).Eval e ↔ |
| Step (e d) (e c) (e k) (e o) (e f) (e x) (e y) (e p) := by |
| simp only [step,Formula.Eval,eval_side,Step] |
|
|
| def vertex (d c k o f z : ℕ) : Formula := |
| .existsMem d (.existsMem (d+1) (.existsMem (c+2) (.existsMem (k+3) |
| (.conj (orderedPair 0 3 2) (.conj (orderedPair (z+4) 0 1) |
| (step (d+4) (c+4) (k+4) (o+4) (f+4) 3 2 1)))))) |
|
|
| theorem eval_vertex (d c k o f z : ℕ) (e : ℕ → ZFSet.{u}) : |
| (vertex d c k o f z).Eval e ↔ Vertex (e d) (e c) (e k) (e o) (e f) (e z) := by |
| simp only [vertex,Formula.Eval,eval_orderedPair,eval_step,cons_zero,cons_succ,Vertex] |
| end AtomicFormula |
|
|
| theorem match_mono (flip : Bool) (d c k o f g a y q : ZFSet.{u}) |
| (hfg : f ⊆ g) (h : Match flip d c k o f a y q) : Match flip d c k o g a y q := by |
| obtain ⟨r,hr,hrq,b,hb,t,ht,hbt,hrt,v,hv,hve,hvf⟩ := h |
| exact ⟨r,hr,hrq,b,hb,t,ht,hbt,hrt,v,hv,hve,hfg hvf⟩ |
|
|
| theorem step_mono (d c k o f g x y p : ZFSet.{u}) (hfg : f ⊆ g) |
| (h : Step d c k o f x y p) : Step d c k o g x y p := by |
| exact ⟨fun a ha s hs hax q hq hqp hqs => |
| match_mono _ _ _ _ _ _ _ _ _ _ hfg (h.1 a ha s hs hax q hq hqp hqs), |
| fun a ha s hs hay q hq hqp hqs => |
| match_mono _ _ _ _ _ _ _ _ _ _ hfg (h.2 a ha s hs hay q hq hqp hqs)⟩ |
|
|
| theorem vertex_mono (d c k o f g z : ZFSet.{u}) (hfg : f ⊆ g) |
| (h : Vertex d c k o f z) : Vertex d c k o g z := by |
| obtain ⟨x,hx,y,hy,q,hq,v,hv,hve,hze,hs⟩ := h |
| exact ⟨x,hx,y,hy,q,hq,v,hv,hve,hze,step_mono _ _ _ _ _ _ _ _ _ hfg hs⟩ |
|
|
| end TuringRigidity.AtomicForcing |
|
|
| end OAI |
|
|
