File size: 4,397 Bytes
a2ee19a | 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 | 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
|