openAI-math-dataset / lean /OAI /Computability /DegreeRigidity /Constructibility /ConstructionInlining.lean
| import OAI.Computability.DegreeRigidity.Syntax.SentenceInlining | |
| import OAI.Computability.DegreeRigidity.Constructibility.ConstructionDefinition | |
| namespace OAI | |
| namespace TuringRigidity.RelativeConstructible | |
| open ElementaryModel BoundedSetTheory TransitiveNameModel | |
| universe u | |
| noncomputable def Construction.inputs (R : ZFSet.{u}) (P : Oracle) : | |
| Construction.{u} → ℕ → ZFSet.{u} | |
| | .reals, _ => R | |
| | .parameter, _ => realCode P | |
| | .define o _ _ _, 0 => level R o | |
| | .define _ n _ c, k+1 => | |
| if h : (Nat.unpair k).1 < n then | |
| (c ⟨(Nat.unpair k).1,h⟩).inputs R (realPart P (Nat.unpair k).1) (Nat.unpair k).2 | |
| else R | |
| theorem Construction.inputs_child (R : ZFSet.{u}) (P : Oracle) | |
| (o : Ordinal.{u}) (n : ℕ) (p : SentenceForm) (c : Fin n → Construction.{u}) | |
| (i : Fin n) (k : ℕ) : | |
| (Construction.define o n p c).inputs R P (Nat.pair i k+1) = | |
| (c i).inputs R (realPart P i) k := by | |
| simp [Construction.inputs,Nat.unpair_pair,i.isLt] | |
| theorem Construction.inputs_mem (t : Construction.{u}) (M R : ZFSet.{u}) | |
| (hM : Transitive M) (hT : SourceT M) (hR : R ∈ M) (P : Oracle) | |
| (ht : t.Certified R P) (hi : t.Indexed M) : ∀ k, t.inputs R P k ∈ M := by | |
| induction t generalizing P with | |
| | reals => exact fun _ => hR | |
| | parameter => exact fun _ => hM R hR _ ht | |
| | define o n p c ih => | |
| intro k | |
| cases k with | |
| | zero => exact level_mem M R hM hT hR o hi.1 | |
| | succ k => | |
| simp only [Construction.inputs] | |
| split | |
| next h => | |
| exact ih ⟨(Nat.unpair k).1,h⟩ _ (ht.2 ⟨(Nat.unpair k).1,h⟩).1 | |
| (hi.2 ⟨(Nat.unpair k).1,h⟩) (Nat.unpair k).2 | |
| next => exact hR | |
| noncomputable def Construction.formula : Construction.{u} → ℕ → (ℕ → ℕ) → SentenceForm | |
| | .reals, out, r => .equal out (r 0) | |
| | .parameter, out, r => .equal out (r 0) | |
| | .define _ n p c, out, r => bindComputed n | |
| (fun i => if h : i < n then | |
| (c ⟨i,h⟩).formula 0 (fun k => r (Nat.pair i k+1)+1) | |
| else .equal 0 0) | |
| (subsetBody n out (r 0) p) | |
| theorem Construction.formula_spec (t : Construction.{u}) (M R : ZFSet.{u}) | |
| (hM : Transitive M) (hT : SourceT M) (hR : R ∈ M) (P : Oracle) | |
| (ht : t.Certified R P) (hi : t.Indexed M) | |
| (out : ℕ) (r : ℕ → ℕ) (e : ℕ → ZFSet.{u}) (he : ∀ i, e i ∈ M) | |
| (hr : ∀ k, e (r k) = t.inputs R P k) : | |
| (t.formula out r).Sat (M : Set ZFSet) e ↔ e out = t.value R P := by | |
| induction t generalizing P out r e with | |
| | reals => exact Iff.of_eq (congrArg (e out = ·) (hr 0)) | |
| | parameter => exact Iff.of_eq (congrArg (e out = ·) (hr 0)) | |
| | define o n p c ih => | |
| let w : ℕ → ZFSet.{u} := fun i => if h : i < n then | |
| (c ⟨i,h⟩).value R (realPart P i) else R | |
| have hw (i : ℕ) (hin : i < n) : w i ∈ M := by | |
| dsimp [w]; rw [dite_eq_left hin] | |
| exact hM _ (level_mem M R hM hT hR o hi.1) _ (ht.2 ⟨i,hin⟩).2 | |
| have hf (i : ℕ) (hin : i < n) (x : ZFSet.{u}) (hx : x ∈ M) : | |
| (if h : i < n then (c ⟨i,h⟩).formula 0 (fun k => r (Nat.pair i k+1)+1) | |
| else .equal 0 0).Sat (M : Set ZFSet) (cons x e) ↔ x = w i := by | |
| rw [dite_eq_left hin,show w i = (c ⟨i,hin⟩).value R (realPart P i) from dite_eq_left hin] | |
| apply ih ⟨i,hin⟩ _ (ht.2 ⟨i,hin⟩).1 (hi.2 ⟨i,hin⟩) 0 _ _ | |
| (by intro k; cases k; exact hx; exact he _) | |
| intro k | |
| change e (r (Nat.pair i k+1)) = _ | |
| rw [hr,Construction.inputs_child R P o n p c ⟨i,hin⟩ k] | |
| rw [Construction.formula,bindComputed_spec M n _ _ e w hw hf, | |
| subsetBody_spec M hM n out (r 0) p ht.1 e w he hw] | |
| have ha : e (r 0) = level R o := hr 0 | |
| rw [ha] | |
| have hv : (fun i : Fin n => w i) = (fun i : Fin n => (c i).value R (realPart P i)) := by | |
| funext i; exact dite_eq_left i.isLt | |
| rw [hv] | |
| rfl | |
| theorem Construction.inlined_definition (t : Construction.{u}) (M R : ZFSet.{u}) | |
| (hM : Transitive M) (hT : SourceT M) (hR : R ∈ M) (P : Oracle) | |
| (ht : t.Certified R P) (hi : t.Indexed M) : | |
| ∃ p : SentenceForm, ∀ x ∈ M, | |
| p.Sat (M : Set ZFSet) (cons x (t.inputs R P)) ↔ x = t.value R P := by | |
| refine ⟨t.formula 0 Nat.succ,?_⟩ | |
| intro x hx | |
| exact t.formula_spec M R hM hT hR P ht hi 0 Nat.succ _ | |
| (by intro i; cases i; exact hx; exact t.inputs_mem M R hM hT hR P ht hi _) (fun _ => rfl) | |
| end TuringRigidity.RelativeConstructible | |
| end OAI | |