File size: 5,387 Bytes
9dbc64e | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 | import OAI.Computability.DegreeRigidity.OrdinalCodes.CanonicalOmegaSyntax
import OAI.Computability.DegreeRigidity.SetModels.SetModelPairing
namespace OAI
namespace TuringRigidity.RelativeConstructible
open ElementaryModel BoundedSetTheory TransitiveNameModel SetModelArithmetic SetModelIteration
universe u
def AdditionSystem (w d A : ZFSet.{u}) : Prop :=
TransitiveNameModel.FunctionGraph d w A ∧
(∃ z ∈ w, z = ∅ ∧ ∀ x ∈ w, ZFSet.pair (ZFSet.pair x z) x ∈ A) ∧
∀ x ∈ w, ∀ y ∈ w, ∀ v ∈ w,
ZFSet.pair (ZFSet.pair x y) v ∈ A →
∀ y' ∈ w, ∀ v' ∈ w, y' = insert y y → v' = insert v v →
ZFSet.pair (ZFSet.pair x y') v' ∈ A
theorem additionSet_members (z : ZFSet.{u}) :
z ∈ additionSet ↔ ∃ n m, z = ZFSet.pair (ZFSet.pair (natSet n) (natSet m)) (natSet (n+m)) := by
rw [additionSet,mem_iterationSet setSucc setSucc_omega]
constructor
· rintro ⟨n,x,hx,hz⟩
obtain ⟨m,rfl⟩ := (mem_omega x).mp hx
exact ⟨n,m,by simpa only [iterate_setSucc,Nat.add_comm] using hz⟩
· rintro ⟨n,m,rfl⟩
exact ⟨n,natSet m,(mem_omega _).mpr ⟨m,rfl⟩,by rw [iterate_setSucc,Nat.add_comm]⟩
theorem additionSet_function : TransitiveNameModel.FunctionGraph pairNumbers.{u} ZFSet.omega additionSet := by
constructor
· intro z hz
obtain ⟨n,m,rfl⟩ := (additionSet_members z).mp hz
exact ⟨_,natPair_mem n m,_,(mem_omega _).mpr ⟨n+m,rfl⟩,rfl⟩
· intro x hx
obtain ⟨a,ha,b,hb,rfl⟩ := ZFSet.mem_prod.mp hx
obtain ⟨n,rfl⟩ := (mem_omega a).mp ha
obtain ⟨m,rfl⟩ := (mem_omega b).mp hb
refine ⟨natSet (n+m),(mem_omega _).mpr ⟨n+m,rfl⟩,(addition_code n m _).mpr rfl,?_⟩
intro z hz hpair
obtain ⟨k,rfl⟩ := (mem_omega z).mp hz
exact congrArg natSet ((addition_code n m k).mp hpair)
theorem additionSystem_canonical : AdditionSystem ZFSet.omega pairNumbers.{u} additionSet := by
refine ⟨additionSet_function,⟨natSet 0,(mem_omega _).mpr ⟨0,rfl⟩,rfl,?_⟩,?_⟩
· intro x hx
obtain ⟨n,rfl⟩ := (mem_omega x).mp hx
exact (addition_code n 0 n).mpr (Nat.add_zero n).symm
· intro x hx y hy v hv hp y' _ v' _ hy' hv'
obtain ⟨n,rfl⟩ := (mem_omega x).mp hx
obtain ⟨m,rfl⟩ := (mem_omega y).mp hy
obtain ⟨k,rfl⟩ := (mem_omega v).mp hv
subst y'; subst v'
change ZFSet.pair (ZFSet.pair (natSet n) (natSet (m+1))) (natSet (k+1)) ∈ additionSet
exact (addition_code n (m+1) (k+1)).mpr (by have hk := (addition_code n m k).mp hp; omega)
theorem AdditionSystem.exact {A : ZFSet.{u}} (h : AdditionSystem ZFSet.omega pairNumbers A) :
A = additionSet := by
have hn (n : ℕ) : natSet.{u} n ∈ ZFSet.omega := (mem_omega _).mpr ⟨n,rfl⟩
have computes (n m : ℕ) : ZFSet.pair (ZFSet.pair (natSet n) (natSet m)) (natSet (n+m)) ∈ A := by
induction m with
| zero =>
obtain ⟨z,_,rfl,hzero⟩ := h.2.1
simpa only [Nat.add_zero,natSet] using hzero _ (hn n)
| succ m ih =>
have hs := h.2.2 _ (hn n) _ (hn m) _ (hn (n+m)) ih _ (hn (m+1)) _ (hn (n+m+1)) rfl rfl
simpa only [Nat.add_succ] using hs
apply ZFSet.ext; intro z
constructor
· intro hz
obtain ⟨x,hx,y,hy,rfl⟩ := h.1.1 z hz
obtain ⟨a,ha,b,hb,rfl⟩ := ZFSet.mem_prod.mp hx
obtain ⟨n,rfl⟩ := (mem_omega a).mp ha
obtain ⟨m,rfl⟩ := (mem_omega b).mp hb
have eq := h.1.functional (natPair_mem n m) hz (computes n m)
rw [eq]
exact (addition_code n m _).mpr rfl
· intro hz
obtain ⟨n,m,rfl⟩ := (additionSet_members z).mp hz
exact computes n m
def additionSystemFormula (w d A : ℕ) : Formula :=
.conj (.functionGraph A d w)
(.conj (.existsMem w (.conj (.empty 0)
(.allMem (w+1) (tripleFormula 0 1 0 (A+2) (d+2)))))
(.allMem w (.allMem (w+1) (.allMem (w+2)
(.imp (tripleFormula 2 1 0 (A+3) (d+3))
(.allMem (w+3) (.allMem (w+4)
(.imp (.successor 1 3) (.imp (.successor 0 2)
(tripleFormula 4 1 0 (A+5) (d+5)))))))))))
theorem additionSystemFormula_spec (w d A : ℕ) (e : ℕ → ZFSet.{u})
(hd : e d = ZFSet.prod (e w) (e w)) :
(additionSystemFormula w d A).Eval e ↔ AdditionSystem (e w) (e d) (e A) := by
simp only [additionSystemFormula,AdditionSystem,Formula.Eval,Formula.eval_functionGraph,
Formula.eval_empty,Formula.eval_allMem,Formula.eval_imp,Formula.eval_successor,
eval_tripleFormula,cons_zero,cons_succ]
simp only [hd,ZFSet.pair_mem_prod]
constructor
· rintro ⟨hf,⟨z,hz,he,hzero⟩,hstep⟩
exact ⟨hf,⟨z,hz,he,fun x hx => (hzero x hx).2⟩,
fun x hx y hy v hv hp y' hy' v' hv' hys hvs =>
(hstep x hx y hy v hv ⟨⟨hx,hy⟩,hp⟩ y' hy' v' hv' hys hvs).2⟩
· rintro ⟨hf,⟨z,hz,he,hzero⟩,hstep⟩
exact ⟨hf,⟨z,hz,he,fun x hx => ⟨⟨hx,hz⟩,hzero x hx⟩⟩,
fun x hx y hy v hv hp y' hy' v' hv' hys hvs =>
⟨⟨hx,hy'⟩,hstep x hx y hy v hv hp.2 y' hy' v' hv' hys hvs⟩⟩
theorem additionSystemFormula_unique (w d A : ℕ) (e : ℕ → ZFSet.{u})
(hw : e w = ZFSet.omega) (hd : e d = pairNumbers) :
(additionSystemFormula w d A).Eval e ↔ e A = additionSet := by
rw [additionSystemFormula_spec w d A e (by rw [hd,hw]; rfl),hw,hd]
exact ⟨AdditionSystem.exact,fun h => h ▸ additionSystem_canonical⟩
end TuringRigidity.RelativeConstructible
end OAI
|