| import OAI.MathematicalPhysics.RapidForcing.RatOperations |
| import Mathlib.Computability.PartrecCode |
|
|
| namespace OAI |
|
|
| namespace FixedClauseThreshold.Computability |
|
|
| open Filter |
| open scoped Topology |
| open RapidForcing.EffectiveArithmetic |
|
|
| def tolerance (r : ℕ) : ℚ := (2 ^ r : ℚ)⁻¹ |
|
|
| @[fun_prop] |
| theorem tolerance_computable : Computable tolerance := by |
| unfold tolerance |
| fun_prop |
|
|
| theorem tolerance_pos (r : ℕ) : 0 < tolerance r := by |
| unfold tolerance |
| positivity |
|
|
| def certificateTest (lower upper : ℕ → ℚ) (valid : ℕ → Bool) |
| (r n : ℕ) : Option ℚ := |
| let i := n.unpair.1 |
| let j := n.unpair.2 |
| if valid j = true ∧ upper j - lower i ≤ 2 * tolerance r then |
| some ((lower i + upper j) / 2) |
| else none |
|
|
| theorem certificateTest_computable {lower upper : ℕ → ℚ} {valid : ℕ → Bool} |
| (hl : Computable lower) (hu : Computable upper) (hv : Computable valid) : |
| Computable₂ (certificateTest lower upper valid) := by |
| unfold Computable₂ certificateTest |
| fun_prop |
|
|
| def certificateProgram (lower upper : ℕ → ℚ) (valid : ℕ → Bool) |
| (r : ℕ) : Part ℚ := |
| Nat.rfindOpt (certificateTest lower upper valid r) |
|
|
| theorem certificateProgram_partrec {lower upper : ℕ → ℚ} {valid : ℕ → Bool} |
| (hl : Computable lower) (hu : Computable upper) (hv : Computable valid) : |
| Partrec (certificateProgram lower upper valid) := |
| Partrec.rfindOpt (certificateTest_computable hl hu hv) |
|
|
| theorem certificateTest_sound {α : ℝ} {lower upper : ℕ → ℚ} {valid : ℕ → Bool} |
| (hl : ∀ i, (lower i : ℝ) ≤ α) |
| (hu : ∀ j, valid j = true → α ≤ (upper j : ℝ)) |
| {r n : ℕ} {q : ℚ} (hq : q ∈ certificateTest lower upper valid r n) : |
| |(q : ℝ) - α| ≤ (tolerance r : ℝ) := by |
| dsimp only [certificateTest] at hq |
| split_ifs at hq with h |
| · obtain rfl := Option.mem_some_iff.mp hq |
| have hlo := hl n.unpair.1 |
| have hup := hu n.unpair.2 h.1 |
| have hwidth : (upper n.unpair.2 : ℝ) - lower n.unpair.1 ≤ |
| 2 * (tolerance r : ℝ) := by exact_mod_cast h.2 |
| push_cast |
| apply abs_le.mpr |
| constructor <;> linarith |
| · contradiction |
|
|
| theorem certificateProgram_total {α : ℝ} {lower upper : ℕ → ℚ} {valid : ℕ → Bool} |
| (hl : ∀ ε : ℝ, 0 < ε → ∃ i, α - ε < (lower i : ℝ)) |
| (hu : ∀ ε : ℝ, 0 < ε → ∃ j, valid j = true ∧ (upper j : ℝ) < α + ε) |
| (r : ℕ) : (certificateProgram lower upper valid r).Dom := by |
| have hε : (0 : ℝ) < tolerance r := by exact_mod_cast tolerance_pos r |
| obtain ⟨i, hi⟩ := hl (tolerance r) hε |
| obtain ⟨j, hj, hj'⟩ := hu (tolerance r) hε |
| apply Nat.rfindOpt_dom.mpr |
| refine ⟨Nat.pair i j, (lower i + upper j) / 2, ?_⟩ |
| have hwidth : upper j - lower i ≤ 2 * tolerance r := by |
| have : (upper j : ℝ) - lower i ≤ 2 * (tolerance r : ℝ) := by linarith |
| exact_mod_cast this |
| simp [certificateTest, hj, hwidth] |
|
|
| theorem finite_certificate_search {α : ℝ} |
| {lower upper : ℕ → ℚ} {valid : ℕ → Bool} |
| (hlc : Computable lower) (huc : Computable upper) (hvc : Computable valid) |
| (hls : ∀ i, (lower i : ℝ) ≤ α) |
| (hus : ∀ j, valid j = true → α ≤ (upper j : ℝ)) |
| (hld : ∀ ε : ℝ, 0 < ε → ∃ i, α - ε < (lower i : ℝ)) |
| (hud : ∀ ε : ℝ, 0 < ε → ∃ j, valid j = true ∧ (upper j : ℝ) < α + ε) : |
| ∃ q : ℕ → ℚ, Computable q ∧ |
| (∀ r, q r ∈ certificateProgram lower upper valid r) ∧ |
| ∀ r, |(q r : ℝ) - α| ≤ (2 ^ r : ℝ)⁻¹ := by |
| let total := certificateProgram_total hld hud |
| let q := fun r => (certificateProgram lower upper valid r).get (total r) |
| have hq (r : ℕ) : q r ∈ certificateProgram lower upper valid r := Part.get_mem _ |
| refine ⟨q, (certificateProgram_partrec hlc huc hvc).of_eq_tot hq, hq, ?_⟩ |
| intro r |
| obtain ⟨n, hn⟩ := Nat.rfindOpt_spec (hq r) |
| simpa only [tolerance, Rat.cast_inv, Rat.cast_pow, Rat.cast_ofNat] using |
| certificateTest_sound hls hus hn |
|
|
| theorem rational_sequence_code {q : ℕ → ℚ} (hq : Computable q) : |
| ∃ c : Nat.Partrec.Code, ∀ r, |
| Nat.Partrec.Code.eval c r = Part.some (Encodable.encode (q r)) := by |
| have hencode := Computable.encode.comp hq |
| obtain ⟨c, hc⟩ := Nat.Partrec.Code.exists_code.mp (Partrec.nat_iff.mp hencode) |
| exact ⟨c, fun r => congrFun hc r⟩ |
|
|
| end FixedClauseThreshold.Computability |
|
|
| end OAI |
|
|
