| import OAI.Computability.DegreeRigidity.Syntax.SigmaSyntax |
|
|
| namespace OAI |
|
|
|
|
| namespace TuringRigidity.BoundedSetTheory |
| open TransitiveNameModel |
| universe u |
|
|
| namespace Formula |
| theorem eval_rename (φ : Formula) (v : ℕ → ℕ) (e : ℕ → ZFSet.{u}) : |
| (φ.rename v).Eval e ↔ φ.Eval (fun i => e (v i)) := by |
| induction φ generalizing v e with |
| | equal => rfl |
| | member => rfl |
| | conj φ ψ ihφ ihψ => exact and_congr (ihφ v e) (ihψ v e) |
| | neg φ ih => exact not_congr (ih v e) |
| | existsMem i φ ih => |
| simp only [rename,Eval] |
| apply exists_congr |
| intro x |
| apply and_congr_right |
| intro _ |
| have he : (fun i => cons x e (liftMap v i)) = cons x (fun i => e (v i)) := by |
| funext i; cases i <;> rfl |
| exact (ih (liftMap v) (cons x e)).trans (he ▸ Iff.rfl) |
| end Formula |
|
|
| namespace FiniteTuple |
| noncomputable def code : List ZFSet.{u} → ZFSet.{u} |
| | [] => ∅ |
| | x :: xs => ZFSet.pair x (code xs) |
|
|
| noncomputable def space (d : ZFSet.{u}) : ℕ → ZFSet.{u} |
| | 0 => {∅} |
| | n+1 => ZFSet.prod d (space d n) |
|
|
| def prepend (xs : List ZFSet.{u}) (e : ℕ → ZFSet.{u}) : ℕ → ZFSet.{u} := |
| xs.foldr cons e |
|
|
| @[simp] theorem prepend_nil (e : ℕ → ZFSet.{u}) : prepend [] e = e := rfl |
| @[simp] theorem prepend_cons (x : ZFSet.{u}) (xs : List ZFSet.{u}) (e : ℕ → ZFSet.{u}) : |
| prepend (x :: xs) e = cons x (prepend xs e) := rfl |
|
|
| theorem space_mem (M : ZFSet.{u}) (hM : Transitive M) |
| (hP : Pairing M) (hU : BoundedSetTheory.Union M) (hPow : PowerSet M) |
| (hS : Separation M) {d : ZFSet.{u}} (hd : d ∈ M) (n : ℕ) : space d n ∈ M := by |
| have h0 : (∅ : ZFSet.{u}) ∈ M := by |
| have hs := sep_mem M hM hS (.neg (.equal 0 0)) (fun _ => d) (fun _ => hd) hd |
| have heq : ZFSet.sep (fun x => (Formula.neg (.equal 0 0)).Eval (cons x (fun _ => d))) d = ∅ := by |
| apply ZFSet.ext; intro x; simp [ZFSet.mem_sep,Formula.Eval] |
| exact heq ▸ hs |
| induction n with |
| | zero => exact singleton_mem M hM hP h0 |
| | succ n ih => exact product_mem M hM hP hU hPow hS hd ih |
|
|
| theorem mem_space (d t : ZFSet.{u}) (n : ℕ) : |
| t ∈ space d n ↔ ∃ xs : List ZFSet.{u}, xs.length = n ∧ |
| (∀ x ∈ xs, x ∈ d) ∧ t = code xs := by |
| induction n generalizing t with |
| | zero => |
| simp only [space,ZFSet.mem_singleton,List.length_eq_zero_iff] |
| constructor |
| · intro h; exact ⟨[],rfl,by simp,h⟩ |
| · rintro ⟨xs,rfl,_,h⟩; exact h |
| | succ n ih => |
| rw [space,ZFSet.mem_prod] |
| constructor |
| · rintro ⟨x,hx,t,ht,rfl⟩ |
| obtain ⟨xs,hlen,hxs,rfl⟩ := (ih t).mp ht |
| exact ⟨x::xs,by simp [hlen],by intro y hy; rcases List.mem_cons.mp hy with rfl | hy; exact hx; exact hxs y hy,rfl⟩ |
| · rintro ⟨xs,hlen,hxs,rfl⟩ |
| cases xs with |
| | nil => simp at hlen |
| | cons x xs => |
| refine ⟨x,hxs x (by simp),code xs,(ih _).mpr ?_,rfl⟩ |
| exact ⟨xs,Nat.succ.inj hlen,fun y hy => hxs y (by simp [hy]),rfl⟩ |
|
|
| theorem code_mem_space (d : ZFSet.{u}) (xs : List ZFSet.{u}) |
| (hx : ∀ x ∈ xs, x ∈ d) : code xs ∈ space d xs.length := |
| (mem_space d _ _).mpr ⟨xs,rfl,hx,rfl⟩ |
|
|
| theorem code_mem (M : ZFSet.{u}) (hM : Transitive M) (hP : Pairing M) |
| (h0 : (∅ : ZFSet.{u}) ∈ M) (xs : List ZFSet.{u}) |
| (hx : ∀ x ∈ xs, x ∈ M) : code xs ∈ M := by |
| induction xs with |
| | nil => exact h0 |
| | cons x xs ih => |
| exact orderedPair_mem M hM hP (hx x (by simp)) |
| (ih (fun y hy => hx y (by simp [hy]))) |
|
|
| theorem code_injective_length (xs ys : List ZFSet.{u}) (hlen : xs.length = ys.length) |
| (h : code xs = code ys) : xs = ys := by |
| induction xs generalizing ys with |
| | nil => cases ys with |
| | nil => rfl |
| | cons => simp at hlen |
| | cons x xs ih => cases ys with |
| | nil => simp at hlen |
| | cons y ys => |
| obtain ⟨rfl,ht⟩ := ZFSet.pair_inj.mp h |
| rw [ih ys (Nat.succ.inj hlen) ht] |
|
|
| theorem prepend_tail (xs : List ZFSet.{u}) (e : ℕ → ZFSet.{u}) (i : ℕ) : |
| prepend xs e (xs.length+i) = e i := by |
| induction xs with |
| | nil => simp only [prepend_nil,List.length_nil,Nat.zero_add] |
| | cons x xs ih => simpa only [List.length_cons,Nat.succ_add,prepend_cons,cons_succ] using ih |
|
|
| theorem prepend_congr (xs : List ZFSet.{u}) (e f : ℕ → ZFSet.{u}) |
| (i : ℕ) (hi : i < xs.length) : prepend xs e i = prepend xs f i := by |
| induction xs generalizing i with |
| | nil => simp at hi |
| | cons x xs ih => cases i with |
| | zero => rfl |
| | succ i => exact ih i (Nat.lt_of_succ_lt_succ hi) |
|
|
| def rotate (n : ℕ) : ℕ → ℕ |
| | 0 => n+1 |
| | i+1 => if i < n then i else i+2 |
|
|
| theorem prepend_rotate (xs : List ZFSet.{u}) (x t : ZFSet.{u}) (e : ℕ → ZFSet.{u}) : |
| (fun i => prepend xs (cons t (cons x e)) (rotate xs.length i)) = |
| cons x (prepend xs e) := by |
| funext i |
| cases i with |
| | zero => exact prepend_tail xs (cons t (cons x e)) 1 |
| | succ i => |
| change prepend xs (cons t (cons x e)) (if i < xs.length then i else i+2) = prepend xs e i |
| by_cases hi : i < xs.length |
| · rw [ite_eq_left hi]; exact prepend_congr xs _ _ i hi |
| · rw [ite_eq_right hi] |
| obtain ⟨j,rfl⟩ := Nat.exists_eq_add_of_le (Nat.le_of_not_gt hi) |
| rw [Nat.add_assoc,prepend_tail,prepend_tail] |
| rfl |
|
|
| end FiniteTuple |
| end TuringRigidity.BoundedSetTheory |
|
|
| end OAI |
|
|
