| import OAI.Computability.DegreeRigidity.Computability.OracleCode |
|
|
| namespace OAI |
|
|
| namespace TuringRigidity |
|
|
| def Approximates {α : Type*} (p : Part α) (ps : ℕ → Part α) : Prop := |
| (∀ m a, a ∈ ps m → a ∈ p) ∧ |
| (∀ a, a ∈ p → ∃ M, ∀ m, M ≤ m → a ∈ ps m) |
|
|
| namespace Approximates |
| variable {α β : Type*} |
|
|
| theorem const (p : Part α) : Approximates p (fun _ => p) := |
| ⟨fun _ _ h => h, fun _ h => ⟨0,fun _ _ => h⟩⟩ |
|
|
| theorem bind {p : Part α} {ps : ℕ → Part α} {f : α → Part β} |
| {fs : ℕ → α → Part β} (hp : Approximates p ps) |
| (hf : ∀ a, Approximates (f a) (fun m => fs m a)) : |
| Approximates (p.bind f) (fun m => (ps m).bind (fs m)) := by |
| constructor |
| · intro m b hb |
| obtain ⟨a,ha,hb⟩ := Part.mem_bind_iff.mp hb |
| exact Part.mem_bind_iff.mpr ⟨a,hp.1 m a ha,(hf a).1 m b hb⟩ |
| · intro b hb |
| obtain ⟨a,ha,hb⟩ := Part.mem_bind_iff.mp hb |
| obtain ⟨M,hM⟩ := hp.2 a ha |
| obtain ⟨N,hN⟩ := (hf a).2 b hb |
| exact ⟨max M N,fun m hm => Part.mem_bind_iff.mpr |
| ⟨a,hM m ((le_max_left _ _).trans hm),hN m ((le_max_right _ _).trans hm)⟩⟩ |
|
|
| theorem map {p : Part α} {ps : ℕ → Part α} (hp : Approximates p ps) (f : α → β) : |
| Approximates (p.map f) (fun m => (ps m).map f) := by |
| simpa only [Part.bind_some_eq_map] using hp.bind (fun a => const (Part.some (f a))) |
|
|
| theorem finite_bounds (P : ℕ → ℕ → Prop) (n : ℕ) |
| (h : ∀ i, i < n → ∃ M, ∀ m, M ≤ m → P i m) : |
| ∃ M, ∀ m, M ≤ m → ∀ i, i < n → P i m := by |
| induction n with |
| | zero => exact ⟨0,by simp⟩ |
| | succ n ih => |
| obtain ⟨M,hM⟩ := ih (fun i hi => h i (Nat.lt_succ_of_lt hi)) |
| obtain ⟨N,hN⟩ := h n (Nat.lt_succ_self n) |
| refine ⟨max M N, fun m hm i hi => ?_⟩ |
| rcases Nat.lt_succ_iff_lt_or_eq.mp hi with hi | rfl |
| · exact hM m ((le_max_left _ _).trans hm) i hi |
| · exact hN m ((le_max_right _ _).trans hm) |
|
|
| theorem rfind {p : ℕ → Part Bool} {ps : ℕ → ℕ → Part Bool} |
| (hp : ∀ n, Approximates (p n) (fun m => ps m n)) : |
| Approximates (Nat.rfind p) (fun m => Nat.rfind (ps m)) := by |
| constructor |
| · intro m n hn |
| obtain ⟨ht,hf⟩ := Nat.mem_rfind.mp hn |
| exact Nat.mem_rfind.mpr ⟨(hp n).1 m true ht,fun {k} hk => (hp k).1 m false (hf hk)⟩ |
| · intro n hn |
| obtain ⟨ht,hf⟩ := Nat.mem_rfind.mp hn |
| obtain ⟨M,hM⟩ := (hp n).2 true ht |
| obtain ⟨N,hN⟩ := finite_bounds (fun k m => false ∈ ps m k) n |
| (fun k hk => (hp k).2 false (hf hk)) |
| exact ⟨max M N, fun m hm => Nat.mem_rfind.mpr |
| ⟨hM m ((le_max_left _ _).trans hm),fun {k} hk => hN m ((le_max_right _ _).trans hm) k hk⟩⟩ |
| end Approximates |
|
|
| namespace OracleCode |
|
|
| theorem eval_approximates {g : ℕ →. ℕ} {gs : ℕ → ℕ →. ℕ} |
| (hg : ∀ n, Approximates (g n) (fun m => gs m n)) (c : OracleCode) : |
| ∀ n, Approximates (eval g c n) (fun m => eval (gs m) c n) := by |
| induction c with |
| | zero => intro n; exact Approximates.const _ |
| | succ => intro n; exact Approximates.const _ |
| | left => intro n; exact Approximates.const _ |
| | right => intro n; exact Approximates.const _ |
| | query => exact hg |
| | pair c d hc hd => |
| intro n |
| exact (hc n).bind (fun a => (hd n).map (Nat.pair a)) |
| | comp c d hc hd => intro n; exact (hd n).bind hc |
| | prec c d hc hd => |
| intro p |
| have hr : ∀ k, Approximates |
| (Nat.rec (eval g c (Nat.unpair p).1) |
| (fun y ih => ih.bind (fun i => eval g d (Nat.pair (Nat.unpair p).1 (Nat.pair y i)))) k) |
| (fun m => Nat.rec (eval (gs m) c (Nat.unpair p).1) |
| (fun y ih => ih.bind (fun i => eval (gs m) d (Nat.pair (Nat.unpair p).1 (Nat.pair y i)))) k) := by |
| intro k |
| induction k with |
| | zero => exact hc _ |
| | succ k ih => exact ih.bind (fun i => hd _) |
| exact hr _ |
| | find c hc => |
| intro n |
| exact Approximates.rfind (fun k => (hc (Nat.pair n k)).map (fun m => decide (m=0))) |
|
|
| end OracleCode |
| end TuringRigidity |
|
|
| end OAI |
|
|
